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


5442835f57ea5957513cb4d7807031460564b09d
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_double swig_types[2]
2469 #define SWIGTYPE_p_form_ops_t swig_types[3]
2470 #define SWIGTYPE_p_int 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_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxAlphaPixelData swig_types[11]
2478 #define SWIGTYPE_p_wxAlphaPixelData_Accessor swig_types[12]
2479 #define SWIGTYPE_p_wxBMPHandler swig_types[13]
2480 #define SWIGTYPE_p_wxBitmap swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBrush swig_types[16]
2483 #define SWIGTYPE_p_wxBrushList swig_types[17]
2484 #define SWIGTYPE_p_wxBufferedDC swig_types[18]
2485 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[19]
2486 #define SWIGTYPE_p_wxCURHandler swig_types[20]
2487 #define SWIGTYPE_p_wxChar swig_types[21]
2488 #define SWIGTYPE_p_wxChildFocusEvent swig_types[22]
2489 #define SWIGTYPE_p_wxClientDC swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxColourDatabase swig_types[27]
2494 #define SWIGTYPE_p_wxCommandEvent swig_types[28]
2495 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2496 #define SWIGTYPE_p_wxControl swig_types[30]
2497 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2498 #define SWIGTYPE_p_wxCursor swig_types[32]
2499 #define SWIGTYPE_p_wxDC swig_types[33]
2500 #define SWIGTYPE_p_wxDash swig_types[34]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[35]
2502 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[36]
2503 #define SWIGTYPE_p_wxDropFilesEvent swig_types[37]
2504 #define SWIGTYPE_p_wxDuplexMode swig_types[38]
2505 #define SWIGTYPE_p_wxEffects swig_types[39]
2506 #define SWIGTYPE_p_wxEncodingConverter swig_types[40]
2507 #define SWIGTYPE_p_wxEraseEvent swig_types[41]
2508 #define SWIGTYPE_p_wxEvent swig_types[42]
2509 #define SWIGTYPE_p_wxEvtHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFSFile swig_types[44]
2511 #define SWIGTYPE_p_wxFileSystem swig_types[45]
2512 #define SWIGTYPE_p_wxFlexGridSizer swig_types[46]
2513 #define SWIGTYPE_p_wxFocusEvent swig_types[47]
2514 #define SWIGTYPE_p_wxFont swig_types[48]
2515 #define SWIGTYPE_p_wxFontList swig_types[49]
2516 #define SWIGTYPE_p_wxFontMapper swig_types[50]
2517 #define SWIGTYPE_p_wxGBSizerItem swig_types[51]
2518 #define SWIGTYPE_p_wxGDIObjListBase swig_types[52]
2519 #define SWIGTYPE_p_wxGDIObject swig_types[53]
2520 #define SWIGTYPE_p_wxGIFHandler swig_types[54]
2521 #define SWIGTYPE_p_wxGridBagSizer swig_types[55]
2522 #define SWIGTYPE_p_wxGridSizer swig_types[56]
2523 #define SWIGTYPE_p_wxICOHandler swig_types[57]
2524 #define SWIGTYPE_p_wxIcon swig_types[58]
2525 #define SWIGTYPE_p_wxIconBundle swig_types[59]
2526 #define SWIGTYPE_p_wxIconLocation swig_types[60]
2527 #define SWIGTYPE_p_wxIconizeEvent swig_types[61]
2528 #define SWIGTYPE_p_wxIdleEvent swig_types[62]
2529 #define SWIGTYPE_p_wxImage swig_types[63]
2530 #define SWIGTYPE_p_wxImageHandler swig_types[64]
2531 #define SWIGTYPE_p_wxImageList swig_types[65]
2532 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[66]
2533 #define SWIGTYPE_p_wxInitDialogEvent swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLanguageInfo swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxLocale swig_types[72]
2539 #define SWIGTYPE_p_wxMask swig_types[73]
2540 #define SWIGTYPE_p_wxMaximizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxMemoryDC swig_types[75]
2542 #define SWIGTYPE_p_wxMenu swig_types[76]
2543 #define SWIGTYPE_p_wxMenuBar swig_types[77]
2544 #define SWIGTYPE_p_wxMenuEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMenuItem swig_types[79]
2546 #define SWIGTYPE_p_wxMetaFile swig_types[80]
2547 #define SWIGTYPE_p_wxMetaFileDC swig_types[81]
2548 #define SWIGTYPE_p_wxMirrorDC swig_types[82]
2549 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[83]
2550 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[84]
2551 #define SWIGTYPE_p_wxMouseEvent swig_types[85]
2552 #define SWIGTYPE_p_wxMoveEvent swig_types[86]
2553 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[87]
2554 #define SWIGTYPE_p_wxNativeFontInfo swig_types[88]
2555 #define SWIGTYPE_p_wxNativePixelData swig_types[89]
2556 #define SWIGTYPE_p_wxNativePixelData_Accessor swig_types[90]
2557 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[91]
2558 #define SWIGTYPE_p_wxNcPaintEvent swig_types[92]
2559 #define SWIGTYPE_p_wxNotifyEvent swig_types[93]
2560 #define SWIGTYPE_p_wxObject swig_types[94]
2561 #define SWIGTYPE_p_wxPCXHandler swig_types[95]
2562 #define SWIGTYPE_p_wxPNGHandler swig_types[96]
2563 #define SWIGTYPE_p_wxPNMHandler swig_types[97]
2564 #define SWIGTYPE_p_wxPaintDC swig_types[98]
2565 #define SWIGTYPE_p_wxPaintEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPalette swig_types[100]
2567 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPaperSize swig_types[102]
2569 #define SWIGTYPE_p_wxPen swig_types[103]
2570 #define SWIGTYPE_p_wxPenList swig_types[104]
2571 #define SWIGTYPE_p_wxPixelDataBase swig_types[105]
2572 #define SWIGTYPE_p_wxPoint swig_types[106]
2573 #define SWIGTYPE_p_wxPostScriptDC swig_types[107]
2574 #define SWIGTYPE_p_wxPrintData swig_types[108]
2575 #define SWIGTYPE_p_wxPrinterDC swig_types[109]
2576 #define SWIGTYPE_p_wxPseudoDC swig_types[110]
2577 #define SWIGTYPE_p_wxPyApp swig_types[111]
2578 #define SWIGTYPE_p_wxPyCommandEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPyEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[114]
2581 #define SWIGTYPE_p_wxPyImageHandler swig_types[115]
2582 #define SWIGTYPE_p_wxPyLocale swig_types[116]
2583 #define SWIGTYPE_p_wxPySizer swig_types[117]
2584 #define SWIGTYPE_p_wxPyValidator swig_types[118]
2585 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[119]
2586 #define SWIGTYPE_p_wxRect swig_types[120]
2587 #define SWIGTYPE_p_wxRegion swig_types[121]
2588 #define SWIGTYPE_p_wxRegionIterator swig_types[122]
2589 #define SWIGTYPE_p_wxRendererNative swig_types[123]
2590 #define SWIGTYPE_p_wxRendererVersion swig_types[124]
2591 #define SWIGTYPE_p_wxScreenDC swig_types[125]
2592 #define SWIGTYPE_p_wxScrollEvent swig_types[126]
2593 #define SWIGTYPE_p_wxScrollWinEvent swig_types[127]
2594 #define SWIGTYPE_p_wxSetCursorEvent swig_types[128]
2595 #define SWIGTYPE_p_wxShowEvent swig_types[129]
2596 #define SWIGTYPE_p_wxSize swig_types[130]
2597 #define SWIGTYPE_p_wxSizeEvent swig_types[131]
2598 #define SWIGTYPE_p_wxSizer swig_types[132]
2599 #define SWIGTYPE_p_wxSizerItem swig_types[133]
2600 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[134]
2601 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[135]
2602 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[136]
2603 #define SWIGTYPE_p_wxStockGDI swig_types[137]
2604 #define SWIGTYPE_p_wxString swig_types[138]
2605 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[139]
2606 #define SWIGTYPE_p_wxTIFFHandler swig_types[140]
2607 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[141]
2608 #define SWIGTYPE_p_wxValidator swig_types[142]
2609 #define SWIGTYPE_p_wxWindow swig_types[143]
2610 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[144]
2611 #define SWIGTYPE_p_wxWindowDC swig_types[145]
2612 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[146]
2613 #define SWIGTYPE_p_wxXPMHandler swig_types[147]
2614 static swig_type_info *swig_types[149];
2615 static swig_module_info swig_module = {swig_types, 148, 0, 0, 0, 0};
2616 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2617 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2618
2619 /* -------- TYPES TABLE (END) -------- */
2620
2621 #if (PY_VERSION_HEX <= 0x02000000)
2622 # if !defined(SWIG_PYTHON_CLASSIC)
2623 # error "This python version requires to use swig with the '-classic' option"
2624 # endif
2625 #endif
2626 #if (PY_VERSION_HEX <= 0x02020000)
2627 # error "This python version requires to use swig with the '-nomodern' option"
2628 #endif
2629 #if (PY_VERSION_HEX <= 0x02020000)
2630 # error "This python version requires to use swig with the '-nomodernargs' option"
2631 #endif
2632 #ifndef METH_O
2633 # error "This python version requires to use swig with the '-nofastunpack' option"
2634 #endif
2635
2636 /*-----------------------------------------------
2637 @(target):= _gdi_.so
2638 ------------------------------------------------*/
2639 #define SWIG_init init_gdi_
2640
2641 #define SWIG_name "_gdi_"
2642
2643 #define SWIGVERSION 0x010329
2644
2645
2646 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2647 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2648
2649
2650 #include <stdexcept>
2651
2652
2653 namespace swig {
2654 class PyObject_ptr {
2655 protected:
2656 PyObject *_obj;
2657
2658 public:
2659 PyObject_ptr() :_obj(0)
2660 {
2661 }
2662
2663 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2664 {
2665 Py_XINCREF(_obj);
2666 }
2667
2668 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2669 {
2670 if (initial_ref) Py_XINCREF(_obj);
2671 }
2672
2673 PyObject_ptr & operator=(const PyObject_ptr& item)
2674 {
2675 Py_XINCREF(item._obj);
2676 Py_XDECREF(_obj);
2677 _obj = item._obj;
2678 return *this;
2679 }
2680
2681 ~PyObject_ptr()
2682 {
2683 Py_XDECREF(_obj);
2684 }
2685
2686 operator PyObject *() const
2687 {
2688 return _obj;
2689 }
2690
2691 PyObject *operator->() const
2692 {
2693 return _obj;
2694 }
2695 };
2696 }
2697
2698
2699 namespace swig {
2700 struct PyObject_var : PyObject_ptr {
2701 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2702
2703 PyObject_var & operator = (PyObject* obj)
2704 {
2705 Py_XDECREF(_obj);
2706 _obj = obj;
2707 return *this;
2708 }
2709 };
2710 }
2711
2712
2713 #include "wx/wxPython/wxPython.h"
2714 #include "wx/wxPython/pyclasses.h"
2715
2716
2717 static const wxString wxPyEmptyString(wxEmptyString);
2718
2719 #define SWIG_From_long PyInt_FromLong
2720
2721
2722 SWIGINTERNINLINE PyObject *
2723 SWIG_From_int (int value)
2724 {
2725 return SWIG_From_long (value);
2726 }
2727
2728
2729 #include <limits.h>
2730 #ifndef LLONG_MIN
2731 # define LLONG_MIN LONG_LONG_MIN
2732 #endif
2733 #ifndef LLONG_MAX
2734 # define LLONG_MAX LONG_LONG_MAX
2735 #endif
2736 #ifndef ULLONG_MAX
2737 # define ULLONG_MAX ULONG_LONG_MAX
2738 #endif
2739
2740
2741 SWIGINTERN int
2742 SWIG_AsVal_long (PyObject* obj, long* val)
2743 {
2744 if (PyNumber_Check(obj)) {
2745 if (val) *val = PyInt_AsLong(obj);
2746 return SWIG_OK;
2747 }
2748 return SWIG_TypeError;
2749 }
2750
2751
2752 SWIGINTERN int
2753 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2754 {
2755 long v = 0;
2756 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2757 return SWIG_TypeError;
2758 }
2759 else if (val)
2760 *val = (unsigned long)v;
2761 return SWIG_OK;
2762 }
2763
2764
2765 SWIGINTERN int
2766 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
2767 {
2768 unsigned long v;
2769 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2770 if (SWIG_IsOK(res)) {
2771 if ((v > UCHAR_MAX)) {
2772 return SWIG_OverflowError;
2773 } else {
2774 if (val) *val = static_cast< unsigned char >(v);
2775 }
2776 }
2777 return res;
2778 }
2779
2780
2781 SWIGINTERNINLINE PyObject*
2782 SWIG_From_unsigned_SS_long (unsigned long value)
2783 {
2784 return (value > LONG_MAX) ?
2785 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2786 }
2787
2788
2789 SWIGINTERNINLINE PyObject *
2790 SWIG_From_unsigned_SS_char (unsigned char value)
2791 {
2792 return SWIG_From_unsigned_SS_long (value);
2793 }
2794
2795 SWIGINTERN bool wxColour___eq__(wxColour *self,PyObject *other){
2796 wxColour temp, *obj = &temp;
2797 if ( other == Py_None ) return false;
2798 if ( ! wxColour_helper(other, &obj) ) {
2799 PyErr_Clear();
2800 return false;
2801 }
2802 return self->operator==(*obj);
2803 }
2804 SWIGINTERN bool wxColour___ne__(wxColour *self,PyObject *other){
2805 wxColour temp, *obj = &temp;
2806 if ( other == Py_None ) return true;
2807 if ( ! wxColour_helper(other, &obj)) {
2808 PyErr_Clear();
2809 return true;
2810 }
2811 return self->operator!=(*obj);
2812 }
2813
2814 SWIGINTERN int
2815 SWIG_AsVal_bool (PyObject *obj, bool *val)
2816 {
2817 if (obj == Py_True) {
2818 if (val) *val = true;
2819 return SWIG_OK;
2820 } else if (obj == Py_False) {
2821 if (val) *val = false;
2822 return SWIG_OK;
2823 } else {
2824 long v = 0;
2825 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2826 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2827 return res;
2828 }
2829 }
2830
2831 SWIGINTERN PyObject *wxColour_Get(wxColour *self,bool includeAlpha=false){
2832 PyObject* rv = PyTuple_New(includeAlpha ? 4 : 3);
2833 int red = -1;
2834 int green = -1;
2835 int blue = -1;
2836 int alpha = wxALPHA_OPAQUE;
2837 if (self->Ok()) {
2838 red = self->Red();
2839 green = self->Green();
2840 blue = self->Blue();
2841 alpha = self->Alpha();
2842 }
2843 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
2844 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
2845 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
2846 if (includeAlpha)
2847 PyTuple_SetItem(rv, 3, PyInt_FromLong(alpha));
2848 return rv;
2849 }
2850 SWIGINTERN unsigned long wxColour_GetRGB(wxColour *self){
2851 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
2852 }
2853
2854 SWIGINTERN int
2855 SWIG_AsVal_int (PyObject * obj, int *val)
2856 {
2857 long v;
2858 int res = SWIG_AsVal_long (obj, &v);
2859 if (SWIG_IsOK(res)) {
2860 if ((v < INT_MIN || v > INT_MAX)) {
2861 return SWIG_OverflowError;
2862 } else {
2863 if (val) *val = static_cast< int >(v);
2864 }
2865 }
2866 return res;
2867 }
2868
2869 SWIGINTERN PyObject *wxPen_GetDashes(wxPen *self){
2870 wxDash* dashes;
2871 int count = self->GetDashes(&dashes);
2872 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2873 PyObject* retval = PyList_New(0);
2874 for (int x=0; x<count; x++) {
2875 PyObject* pyint = PyInt_FromLong(dashes[x]);
2876 PyList_Append(retval, pyint);
2877 Py_DECREF(pyint);
2878 }
2879 wxPyEndBlockThreads(blocked);
2880 return retval;
2881 }
2882 SWIGINTERN void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
2883 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2884 int size = PyList_Size(pyDashes);
2885 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
2886
2887 // black magic warning! The array of wxDashes needs to exist as
2888 // long as the pen does because wxPen does not copy the array. So
2889 // stick a copy in a Python string object and attach it to _self,
2890 // and then call SetDashes with a pointer to that array. Then
2891 // when the Python pen object is destroyed the array will be
2892 // cleaned up too.
2893 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
2894 PyObject_SetAttrString(_self, "_dashes", strDashes);
2895
2896 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
2897 delete [] dashes;
2898 Py_DECREF(strDashes);
2899 wxPyEndBlockThreads(blocked);
2900 }
2901 SWIGINTERN bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
2902 SWIGINTERN bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
2903
2904 SWIGINTERNINLINE PyObject *
2905 SWIG_From_short (short value)
2906 {
2907 return SWIG_From_long (value);
2908 }
2909
2910
2911 SWIGINTERN int
2912 SWIG_AsVal_short (PyObject * obj, short *val)
2913 {
2914 long v;
2915 int res = SWIG_AsVal_long (obj, &v);
2916 if (SWIG_IsOK(res)) {
2917 if ((v < SHRT_MIN || v > SHRT_MAX)) {
2918 return SWIG_OverflowError;
2919 } else {
2920 if (val) *val = static_cast< short >(v);
2921 }
2922 }
2923 return res;
2924 }
2925
2926
2927 #include <wx/rawbmp.h>
2928
2929
2930 #include <wx/image.h>
2931
2932 static char** ConvertListOfStrings(PyObject* listOfStrings) {
2933 char** cArray = NULL;
2934 int count;
2935
2936 if (!PyList_Check(listOfStrings)) {
2937 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2938 return NULL;
2939 }
2940 count = PyList_Size(listOfStrings);
2941 cArray = new char*[count];
2942
2943 for(int x=0; x<count; x++) {
2944 // TODO: Need some validation and error checking here
2945 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
2946 }
2947 return cArray;
2948 }
2949
2950
2951 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *listOfStrings){
2952 char** cArray = NULL;
2953 wxBitmap* bmp;
2954
2955 cArray = ConvertListOfStrings(listOfStrings);
2956 if (! cArray)
2957 return NULL;
2958 bmp = new wxBitmap(cArray);
2959 delete [] cArray;
2960 return bmp;
2961 }
2962 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
2963 char* buf;
2964 Py_ssize_t length;
2965 PyString_AsStringAndSize(bits, &buf, &length);
2966 return new wxBitmap(buf, width, height, depth);
2967 }
2968 SWIGINTERN wxSize wxBitmap_GetSize(wxBitmap *self){
2969 wxSize size(self->GetWidth(), self->GetHeight());
2970 return size;
2971 }
2972 SWIGINTERN void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
2973 wxMask *mask = new wxMask(*self, colour);
2974 self->SetMask(mask);
2975 }
2976 SWIGINTERN void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
2977 self->SetWidth(size.x);
2978 self->SetHeight(size.y);
2979 }
2980 SWIGINTERN bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
2981 SWIGINTERN bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
2982
2983 // See http://tinyurl.com/e5adr for what premultiplying alpha means. It
2984 // appears to me that the other platforms are already doing it, so I'll just
2985 // automatically do it for wxMSW here.
2986 #ifdef __WXMSW__
2987 #define wxPy_premultiply(p, a) ((p) * (a) / 0xff)
2988 #define wxPy_unpremultiply(p, a) ((a) ? ((p) * 0xff / (a)) : (p))
2989 #else
2990 #define wxPy_premultiply(p, a) (p)
2991 #define wxPy_unpremultiply(p, a) (p)
2992 #endif
2993
2994
2995 wxBitmap* _BitmapFromBufferAlpha(int width, int height,
2996 buffer data, int DATASIZE,
2997 buffer alpha, int ALPHASIZE)
2998 {
2999 if (DATASIZE != width*height*3) {
3000 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3001 return NULL;
3002 }
3003
3004 if (ALPHASIZE != width*height) {
3005 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3006 return NULL;
3007 }
3008
3009 wxBitmap* bmp = new wxBitmap(width, height, 32);
3010 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3011 if (! pixData) {
3012 // raise an exception...
3013 wxPyErr_SetString(PyExc_RuntimeError,
3014 "Failed to gain raw access to bitmap data.");
3015 return NULL;
3016 }
3017
3018 pixData.UseAlpha();
3019 wxAlphaPixelData::Iterator p(pixData);
3020 for (int y=0; y<height; y++) {
3021 wxAlphaPixelData::Iterator rowStart = p;
3022 for (int x=0; x<width; x++) {
3023 byte a = *(alpha++);
3024 p.Red() = wxPy_premultiply(*(data++), a);
3025 p.Green() = wxPy_premultiply(*(data++), a);
3026 p.Blue() = wxPy_premultiply(*(data++), a);
3027 p.Alpha() = a;
3028 ++p;
3029 }
3030 p = rowStart;
3031 p.OffsetY(pixData, 1);
3032 }
3033 return bmp;
3034 }
3035
3036 wxBitmap* _BitmapFromBuffer(int width, int height, buffer data, int DATASIZE)
3037 {
3038 if (DATASIZE != width*height*3) {
3039 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3040 return NULL;
3041 }
3042
3043 wxBitmap* bmp = new wxBitmap(width, height, 24);
3044 wxNativePixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3045 if (! pixData) {
3046 // raise an exception...
3047 wxPyErr_SetString(PyExc_RuntimeError,
3048 "Failed to gain raw access to bitmap data.");
3049 return NULL;
3050 }
3051
3052 wxNativePixelData::Iterator p(pixData);
3053 for (int y=0; y<height; y++) {
3054 wxNativePixelData::Iterator rowStart = p;
3055 for (int x=0; x<width; x++) {
3056 p.Red() = *(data++);
3057 p.Green() = *(data++);
3058 p.Blue() = *(data++);
3059 ++p;
3060 }
3061 p = rowStart;
3062 p.OffsetY(pixData, 1);
3063 }
3064 return bmp;
3065 }
3066
3067
3068 wxBitmap* _BitmapFromBufferRGBA(int width, int height, buffer data, int DATASIZE)
3069 {
3070 if (DATASIZE != width*height*4) {
3071 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3072 return NULL;
3073 }
3074
3075 wxBitmap* bmp = new wxBitmap(width, height, 32);
3076 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3077 if (! pixData) {
3078 // raise an exception...
3079 wxPyErr_SetString(PyExc_RuntimeError,
3080 "Failed to gain raw access to bitmap data.");
3081 return NULL;
3082 }
3083
3084 pixData.UseAlpha();
3085 wxAlphaPixelData::Iterator p(pixData);
3086 for (int y=0; y<height; y++) {
3087 wxAlphaPixelData::Iterator rowStart = p;
3088 for (int x=0; x<width; x++) {
3089 byte a = data[3];
3090 p.Red() = wxPy_premultiply(*(data++), a);
3091 p.Green() = wxPy_premultiply(*(data++), a);
3092 p.Blue() = wxPy_premultiply(*(data++), a);
3093 p.Alpha() = a; data++;
3094 ++p;
3095 }
3096 p = rowStart;
3097 p.OffsetY(pixData, 1);
3098 }
3099 return bmp;
3100 }
3101
3102
3103 typedef wxNativePixelData::Iterator wxNativePixelData_Accessor;
3104
3105 SWIGINTERN bool wxNativePixelData___nonzero__(wxNativePixelData *self){ return self->operator bool(); }
3106 SWIGINTERN void wxNativePixelData_Accessor_nextPixel(wxNativePixelData_Accessor *self){ ++(*self); }
3107 SWIGINTERN void wxNativePixelData_Accessor_Set(wxNativePixelData_Accessor *self,byte red,byte green,byte blue){
3108 self->Red() = red;
3109 self->Green() = green;
3110 self->Blue() = blue;
3111 }
3112 SWIGINTERN PyObject *wxNativePixelData_Accessor_Get(wxNativePixelData_Accessor *self){
3113 PyObject* rv = PyTuple_New(3);
3114 PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
3115 PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
3116 PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
3117 return rv;
3118 }
3119
3120 typedef wxAlphaPixelData::Iterator wxAlphaPixelData_Accessor;
3121
3122 SWIGINTERN bool wxAlphaPixelData___nonzero__(wxAlphaPixelData *self){ return self->operator bool(); }
3123 SWIGINTERN void wxAlphaPixelData_Accessor_nextPixel(wxAlphaPixelData_Accessor *self){ ++(*self); }
3124 SWIGINTERN void wxAlphaPixelData_Accessor_Set(wxAlphaPixelData_Accessor *self,byte red,byte green,byte blue,byte alpha){
3125 self->Red() = wxPy_premultiply(red, alpha);
3126 self->Green() = wxPy_premultiply(green, alpha);
3127 self->Blue() = wxPy_premultiply(blue, alpha);
3128 self->Alpha() = alpha;
3129 }
3130 SWIGINTERN PyObject *wxAlphaPixelData_Accessor_Get(wxAlphaPixelData_Accessor *self){
3131 PyObject* rv = PyTuple_New(4);
3132 int red = self->Red();
3133 int green = self->Green();
3134 int blue = self->Blue();
3135 int alpha = self->Alpha();
3136
3137 PyTuple_SetItem(rv, 0, PyInt_FromLong( wxPy_unpremultiply(red, alpha) ));
3138 PyTuple_SetItem(rv, 1, PyInt_FromLong( wxPy_unpremultiply(green, alpha) ));
3139 PyTuple_SetItem(rv, 2, PyInt_FromLong( wxPy_unpremultiply(blue, alpha) ));
3140 PyTuple_SetItem(rv, 3, PyInt_FromLong( alpha ));
3141 return rv;
3142 }
3143 SWIGINTERN wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
3144 if ( !colour.Ok() )
3145 return new wxMask(bitmap, *wxBLACK);
3146 else
3147 return new wxMask(bitmap, colour);
3148 }
3149
3150 #include <wx/iconbndl.h>
3151
3152 SWIGINTERN wxIcon *new_wxIcon(wxBitmap const &bmp){
3153 wxIcon* icon = new wxIcon();
3154 icon->CopyFromBitmap(bmp);
3155 return icon;
3156 }
3157 SWIGINTERN wxIcon *new_wxIcon(PyObject *listOfStrings){
3158 char** cArray = NULL;
3159 wxIcon* icon;
3160
3161 cArray = ConvertListOfStrings(listOfStrings);
3162 if (! cArray)
3163 return NULL;
3164 icon = new wxIcon(cArray);
3165 delete [] cArray;
3166 return icon;
3167 }
3168 SWIGINTERN wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
3169
3170
3171
3172 return new wxIconLocation(*filename);
3173
3174 }
3175 SWIGINTERN void wxIconLocation_SetIndex(wxIconLocation *self,int num){
3176
3177
3178
3179 // do nothing
3180
3181 }
3182 SWIGINTERN int wxIconLocation_GetIndex(wxIconLocation *self){
3183
3184
3185
3186 return -1;
3187
3188 }
3189 SWIGINTERN wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
3190 #ifdef __WXGTK__
3191 wxImage img(cursorName, type);
3192 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
3193 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
3194 return new wxCursor(img);
3195 #else
3196 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
3197 #endif
3198 }
3199
3200
3201 SWIGINTERN void wxRegionIterator_Next(wxRegionIterator *self){
3202 (*self) ++;
3203 }
3204 SWIGINTERN bool wxRegionIterator___nonzero__(wxRegionIterator *self){
3205 return self->operator bool();
3206 }
3207
3208 #include <wx/fontutil.h>
3209 #include <wx/fontmap.h>
3210 #include <wx/fontenum.h>
3211
3212 SWIGINTERN wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
3213 return self->ToString();
3214 }
3215
3216 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
3217 static wxNativeEncodingInfo info;
3218 if ( wxGetNativeFontEncoding(encoding, &info) )
3219 return &info;
3220 else
3221 return NULL;
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERNINLINE int
3233 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3234 {
3235 unsigned long v;
3236 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3237 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3238 return res;
3239 }
3240
3241 SWIGINTERN PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
3242 wxFontEncoding alt_enc;
3243 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
3244 return PyInt_FromLong(alt_enc);
3245 else {
3246 Py_INCREF(Py_None);
3247 return Py_None;
3248 }
3249 }
3250 SWIGINTERN wxFont *new_wxFont(wxString const &info){
3251 wxNativeFontInfo nfi;
3252 nfi.FromString(info);
3253 return new wxFont(nfi);
3254 }
3255 SWIGINTERN wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3256 return wxFont::New(pointSize, family, flags, face, encoding);
3257 }
3258 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3259 return wxFontBase::New(pixelSize, family,
3260 style, weight, underlined,
3261 face, encoding);
3262 }
3263 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3264 return wxFontBase::New(pixelSize, family, flags, face, encoding);
3265 }
3266 SWIGINTERN bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
3267 SWIGINTERN bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
3268
3269 class wxPyFontEnumerator : public wxFontEnumerator {
3270 public:
3271 wxPyFontEnumerator() {}
3272 ~wxPyFontEnumerator() {}
3273
3274 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
3275 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
3276
3277 PYPRIVATE;
3278 };
3279
3280 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
3281 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
3282
3283
3284 SWIGINTERN PyObject *wxPyFontEnumerator_GetEncodings(){
3285 PyObject* ret;
3286 wxArrayString arr = wxFontEnumerator::GetEncodings();
3287 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3288 ret = wxArrayString2PyList_helper(arr);
3289 wxPyEndBlockThreads(blocked);
3290 return ret;
3291 }
3292 SWIGINTERN PyObject *wxPyFontEnumerator_GetFacenames(){
3293 PyObject* ret;
3294 wxArrayString arr = wxFontEnumerator::GetFacenames();
3295 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3296 ret = wxArrayString2PyList_helper(arr);
3297 wxPyEndBlockThreads(blocked);
3298 return ret;
3299 }
3300
3301 #include <locale.h>
3302
3303 SWIGINTERN wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3304 wxLocale* loc;
3305 if (language == -1)
3306 loc = new wxLocale();
3307 else
3308 loc = new wxLocale(language, flags);
3309 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3310 // for the floating point conversions and such to work right.
3311 #if PY_VERSION_HEX < 0x02040000
3312 setlocale(LC_NUMERIC, "C");
3313 #endif
3314 return loc;
3315 }
3316 SWIGINTERN bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
3317 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
3318 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3319 // for the floating point conversions and such to work right.
3320 #if PY_VERSION_HEX < 0x02040000
3321 setlocale(LC_NUMERIC, "C");
3322 #endif
3323 return rc;
3324 }
3325 SWIGINTERN bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3326 bool rc = self->Init(language, flags);
3327 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3328 // for the floating point conversions and such to work right.
3329 #if PY_VERSION_HEX < 0x02040000
3330 setlocale(LC_NUMERIC, "C");
3331 #endif
3332 return rc;
3333 }
3334
3335 class wxPyLocale : public wxLocale
3336 {
3337 public:
3338 wxPyLocale();
3339
3340 wxPyLocale(const wxChar *szName, // name (for messages)
3341 const wxChar *szShort = (const wxChar *) NULL, // dir prefix (for msg files)
3342 const wxChar *szLocale = (const wxChar *) NULL, // locale (for setlocale)
3343 bool bLoadDefault = true, // preload wxstd.mo?
3344 bool bConvertEncoding = false); // convert Win<->Unix if necessary?
3345
3346 wxPyLocale(int language, // wxLanguage id or custom language
3347 int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
3348
3349 ~wxPyLocale();
3350
3351 virtual const wxChar *GetString(const wxChar *szOrigString,
3352 const wxChar *szDomain = NULL) const;
3353 virtual const wxChar *GetString(const wxChar *szOrigString,
3354 const wxChar *szOrigString2, size_t n,
3355 const wxChar *szDomain = NULL) const;
3356
3357 virtual wxChar *GetSingularString(const wxChar *szOrigString,
3358 const wxChar *szDomain = NULL) const;
3359 virtual wxChar *GetPluralString(const wxChar *szOrigString,
3360 const wxChar *szOrigString2, size_t n,
3361 const wxChar *szDomain = NULL) const;
3362
3363 PYPRIVATE;
3364 private:
3365 DECLARE_NO_COPY_CLASS(wxPyLocale)
3366 };
3367
3368 wxPyLocale::wxPyLocale() : wxLocale()
3369 {
3370 }
3371
3372 wxPyLocale::wxPyLocale(const wxChar *szName, // name (for messages)
3373 const wxChar *szShort, // dir prefix (for msg files)
3374 const wxChar *szLocale, // locale (for setlocale)
3375 bool bLoadDefault, // preload wxstd.mo?
3376 bool bConvertEncoding) // convert Win<->Unix if necessary?
3377 : wxLocale(szName, szShort, szLocale, bLoadDefault, bConvertEncoding)
3378 {
3379 }
3380
3381 wxPyLocale::wxPyLocale(int language, // wxLanguage id or custom language
3382 int flags) : wxLocale(language, flags)
3383 {
3384 }
3385
3386 wxPyLocale::~wxPyLocale()
3387 {
3388 }
3389
3390 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3391 const wxChar *szDomain) const
3392 {
3393 wxChar *str = GetSingularString(szOrigString, szDomain);
3394 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szDomain);
3395 }
3396
3397 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3398 const wxChar *szOrigString2, size_t n,
3399 const wxChar *szDomain) const
3400 {
3401 wxChar *str = GetPluralString(szOrigString, szOrigString2, n, szDomain);
3402 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szOrigString2, n, szDomain);
3403 }
3404
3405 wxChar *wxPyLocale::GetSingularString(const wxChar *szOrigString,
3406 const wxChar *szDomain) const
3407 {
3408 bool found;
3409 static wxString str;
3410 str = _T("error in translation"); // when the first if condition is true but the second if condition is not we do not want to return the previously queried string.
3411 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3412 if((found=wxPyCBH_findCallback(m_myInst, "GetSingularString"))) {
3413 PyObject* param1 = wx2PyString(szOrigString);
3414 PyObject* param2 = wx2PyString(szDomain);
3415 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", param1, param2));
3416 Py_DECREF(param1);
3417 Py_DECREF(param2);
3418 if (ret) {
3419 str = Py2wxString(ret);
3420 Py_DECREF(ret);
3421 }
3422 }
3423 wxPyEndBlockThreads(blocked);
3424 return (found ? (wxChar*)str.c_str() : NULL);
3425 }
3426
3427 wxChar *wxPyLocale::GetPluralString(const wxChar *szOrigString,
3428 const wxChar *szOrigString2, size_t n,
3429 const wxChar *szDomain) const
3430 {
3431 bool found;
3432 static wxString str;
3433 str = _T("error in translation"); // when the first if condition is true but the second if condition is not we do not want to return the previously queried string.
3434 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3435 if((found=wxPyCBH_findCallback(m_myInst, "GetPluralString"))) {
3436 PyObject* param1 = wx2PyString(szOrigString);
3437 PyObject* param2 = wx2PyString(szOrigString2);
3438 PyObject* param4 = wx2PyString(szDomain);
3439 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOiO)", param1, param2, (int)n, param4));
3440 Py_DECREF(param1);
3441 Py_DECREF(param2);
3442 Py_DECREF(param4);
3443 if( ret) {
3444 str = Py2wxString(ret);
3445 Py_DECREF(ret);
3446 }
3447 }
3448 wxPyEndBlockThreads(blocked);
3449 return (found ? (wxChar*)str.c_str() : NULL);
3450 }
3451
3452 SWIGINTERN wxPyLocale *new_wxPyLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3453 wxPyLocale* loc;
3454 if (language == -1)
3455 loc = new wxPyLocale();
3456 else
3457 loc = new wxPyLocale(language, flags);
3458 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3459 // for the floating point conversions and such to work right.
3460 #if PY_VERSION_HEX < 0x02040000
3461 setlocale(LC_NUMERIC, "C");
3462 #endif
3463 return loc;
3464 }
3465
3466 #include "wx/wxPython/pydrawxxx.h"
3467
3468 SWIGINTERN wxColour wxDC_GetPixel(wxDC *self,int x,int y){
3469 wxColour col;
3470 self->GetPixel(x, y, &col);
3471 return col;
3472 }
3473 SWIGINTERN wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
3474 wxColour col;
3475 self->GetPixel(pt, &col);
3476 return col;
3477 }
3478
3479 SWIGINTERN int
3480 SWIG_AsVal_double (PyObject *obj, double* val)
3481 {
3482 if (PyNumber_Check(obj)) {
3483 if (val) *val = PyFloat_AsDouble(obj);
3484 return SWIG_OK;
3485 }
3486 return SWIG_TypeError;
3487 }
3488
3489 SWIGINTERN wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
3490 wxRect rv;
3491 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
3492 return rv;
3493 }
3494 SWIGINTERN wxRect wxDC_GetClippingRect(wxDC *self){
3495 wxRect rect;
3496 self->GetClippingBox(rect);
3497 return rect;
3498 }
3499 SWIGINTERN wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
3500 wxArrayInt widths;
3501 self->GetPartialTextExtents(text, widths);
3502 return widths;
3503 }
3504
3505 #define SWIG_From_double PyFloat_FromDouble
3506
3507 SWIGINTERN void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
3508 self->SetLogicalOrigin(point.x, point.y);
3509 }
3510 SWIGINTERN void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
3511 self->SetDeviceOrigin(point.x, point.y);
3512 }
3513 SWIGINTERN void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
3514 self->CalcBoundingBox(point.x, point.y);
3515 }
3516 SWIGINTERN PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3517 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
3518 }
3519 SWIGINTERN PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3520 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
3521 }
3522 SWIGINTERN PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3523 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
3524 }
3525 SWIGINTERN PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3526 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
3527 }
3528 SWIGINTERN PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3529 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
3530 }
3531 SWIGINTERN PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
3532 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
3533 }
3534
3535 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
3536 *x1 = dc->MinX();
3537 *y1 = dc->MinY();
3538 *x2 = dc->MaxX();
3539 *y2 = dc->MaxY();
3540 }
3541
3542
3543 #include <wx/dcbuffer.h>
3544
3545
3546 #include <wx/dcps.h>
3547
3548
3549 #include <wx/metafile.h>
3550
3551
3552
3553 SWIGINTERN void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
3554 self->AddColour(name, wxColour(red, green, blue));
3555 }
3556
3557 wxFontList* _wxPyInitTheFontList() { return wxTheFontList; }
3558 wxPenList* _wxPyInitThePenList() { return wxThePenList; }
3559 wxBrushList* _wxPyInitTheBrushList() { return wxTheBrushList; }
3560 wxColourDatabase* _wxPyInitTheColourDatabase() { return wxTheColourDatabase; }
3561
3562
3563 #include <wx/effects.h>
3564
3565
3566 #include "wx/renderer.h"
3567
3568
3569 SWIGINTERNINLINE PyObject*
3570 SWIG_From_bool (bool value)
3571 {
3572 return PyBool_FromLong(value ? 1 : 0);
3573 }
3574
3575
3576 #include "wx/wxPython/pseudodc.h"
3577
3578 SWIGINTERN wxRect wxPseudoDC_GetIdBounds(wxPseudoDC *self,int id){
3579 wxRect rect;
3580 self->GetIdBounds(id, rect);
3581 return rect;
3582 }
3583 #ifdef __cplusplus
3584 extern "C" {
3585 #endif
3586 SWIGINTERN PyObject *_wrap_new_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3587 PyObject *resultobj = 0;
3588 wxGDIObject *result = 0 ;
3589
3590 if (!SWIG_Python_UnpackTuple(args,"new_GDIObject",0,0,0)) SWIG_fail;
3591 {
3592 if (!wxPyCheckForApp()) SWIG_fail;
3593 PyThreadState* __tstate = wxPyBeginAllowThreads();
3594 result = (wxGDIObject *)new wxGDIObject();
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObject, SWIG_POINTER_NEW | 0 );
3599 return resultobj;
3600 fail:
3601 return NULL;
3602 }
3603
3604
3605 SWIGINTERN PyObject *_wrap_delete_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3606 PyObject *resultobj = 0;
3607 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3608 void *argp1 = 0 ;
3609 int res1 = 0 ;
3610 PyObject *swig_obj[1] ;
3611
3612 if (!args) SWIG_fail;
3613 swig_obj[0] = args;
3614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, SWIG_POINTER_DISOWN | 0 );
3615 if (!SWIG_IsOK(res1)) {
3616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObject" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3617 }
3618 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3619 {
3620 PyThreadState* __tstate = wxPyBeginAllowThreads();
3621 delete arg1;
3622
3623 wxPyEndAllowThreads(__tstate);
3624 if (PyErr_Occurred()) SWIG_fail;
3625 }
3626 resultobj = SWIG_Py_Void();
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 SWIGINTERN PyObject *_wrap_GDIObject_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3634 PyObject *resultobj = 0;
3635 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3636 bool result;
3637 void *argp1 = 0 ;
3638 int res1 = 0 ;
3639 PyObject *swig_obj[1] ;
3640
3641 if (!args) SWIG_fail;
3642 swig_obj[0] = args;
3643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3644 if (!SWIG_IsOK(res1)) {
3645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_IsNull" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3646 }
3647 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3648 {
3649 PyThreadState* __tstate = wxPyBeginAllowThreads();
3650 result = (bool)(arg1)->IsNull();
3651 wxPyEndAllowThreads(__tstate);
3652 if (PyErr_Occurred()) SWIG_fail;
3653 }
3654 {
3655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3656 }
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 SWIGINTERN PyObject *GDIObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3664 PyObject *obj;
3665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3666 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObject, SWIG_NewClientData(obj));
3667 return SWIG_Py_Void();
3668 }
3669
3670 SWIGINTERN PyObject *GDIObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3671 return SWIG_Python_InitShadowInstance(args);
3672 }
3673
3674 SWIGINTERN PyObject *_wrap_new_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3675 PyObject *resultobj = 0;
3676 byte arg1 = (byte) 0 ;
3677 byte arg2 = (byte) 0 ;
3678 byte arg3 = (byte) 0 ;
3679 byte arg4 = (byte) wxALPHA_OPAQUE ;
3680 wxColour *result = 0 ;
3681 unsigned char val1 ;
3682 int ecode1 = 0 ;
3683 unsigned char val2 ;
3684 int ecode2 = 0 ;
3685 unsigned char val3 ;
3686 int ecode3 = 0 ;
3687 unsigned char val4 ;
3688 int ecode4 = 0 ;
3689 PyObject * obj0 = 0 ;
3690 PyObject * obj1 = 0 ;
3691 PyObject * obj2 = 0 ;
3692 PyObject * obj3 = 0 ;
3693 char * kwnames[] = {
3694 (char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
3695 };
3696
3697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Colour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3698 if (obj0) {
3699 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
3700 if (!SWIG_IsOK(ecode1)) {
3701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Colour" "', expected argument " "1"" of type '" "byte""'");
3702 }
3703 arg1 = static_cast< byte >(val1);
3704 }
3705 if (obj1) {
3706 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3707 if (!SWIG_IsOK(ecode2)) {
3708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Colour" "', expected argument " "2"" of type '" "byte""'");
3709 }
3710 arg2 = static_cast< byte >(val2);
3711 }
3712 if (obj2) {
3713 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3714 if (!SWIG_IsOK(ecode3)) {
3715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Colour" "', expected argument " "3"" of type '" "byte""'");
3716 }
3717 arg3 = static_cast< byte >(val3);
3718 }
3719 if (obj3) {
3720 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3721 if (!SWIG_IsOK(ecode4)) {
3722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Colour" "', expected argument " "4"" of type '" "byte""'");
3723 }
3724 arg4 = static_cast< byte >(val4);
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 result = (wxColour *)new wxColour(arg1,arg2,arg3,arg4);
3729 wxPyEndAllowThreads(__tstate);
3730 if (PyErr_Occurred()) SWIG_fail;
3731 }
3732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_NEW | 0 );
3733 return resultobj;
3734 fail:
3735 return NULL;
3736 }
3737
3738
3739 SWIGINTERN PyObject *_wrap_new_NamedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3740 PyObject *resultobj = 0;
3741 wxString *arg1 = 0 ;
3742 wxColour *result = 0 ;
3743 bool temp1 = false ;
3744 PyObject * obj0 = 0 ;
3745 char * kwnames[] = {
3746 (char *) "colorName", NULL
3747 };
3748
3749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) SWIG_fail;
3750 {
3751 arg1 = wxString_in_helper(obj0);
3752 if (arg1 == NULL) SWIG_fail;
3753 temp1 = true;
3754 }
3755 {
3756 if (!wxPyCheckForApp()) SWIG_fail;
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 result = (wxColour *)new wxColour((wxString const &)*arg1);
3759 wxPyEndAllowThreads(__tstate);
3760 if (PyErr_Occurred()) SWIG_fail;
3761 }
3762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3763 {
3764 if (temp1)
3765 delete arg1;
3766 }
3767 return resultobj;
3768 fail:
3769 {
3770 if (temp1)
3771 delete arg1;
3772 }
3773 return NULL;
3774 }
3775
3776
3777 SWIGINTERN PyObject *_wrap_new_ColourRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj = 0;
3779 unsigned long arg1 ;
3780 wxColour *result = 0 ;
3781 unsigned long val1 ;
3782 int ecode1 = 0 ;
3783 PyObject * obj0 = 0 ;
3784 char * kwnames[] = {
3785 (char *) "colRGB", NULL
3786 };
3787
3788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) SWIG_fail;
3789 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
3790 if (!SWIG_IsOK(ecode1)) {
3791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourRGB" "', expected argument " "1"" of type '" "unsigned long""'");
3792 }
3793 arg1 = static_cast< unsigned long >(val1);
3794 {
3795 PyThreadState* __tstate = wxPyBeginAllowThreads();
3796 result = (wxColour *)new wxColour(arg1);
3797 wxPyEndAllowThreads(__tstate);
3798 if (PyErr_Occurred()) SWIG_fail;
3799 }
3800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3801 return resultobj;
3802 fail:
3803 return NULL;
3804 }
3805
3806
3807 SWIGINTERN PyObject *_wrap_delete_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3808 PyObject *resultobj = 0;
3809 wxColour *arg1 = (wxColour *) 0 ;
3810 void *argp1 = 0 ;
3811 int res1 = 0 ;
3812 PyObject *swig_obj[1] ;
3813
3814 if (!args) SWIG_fail;
3815 swig_obj[0] = args;
3816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, SWIG_POINTER_DISOWN | 0 );
3817 if (!SWIG_IsOK(res1)) {
3818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Colour" "', expected argument " "1"" of type '" "wxColour *""'");
3819 }
3820 arg1 = reinterpret_cast< wxColour * >(argp1);
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 delete arg1;
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 resultobj = SWIG_Py_Void();
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 SWIGINTERN PyObject *_wrap_Colour_Red(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3836 PyObject *resultobj = 0;
3837 wxColour *arg1 = (wxColour *) 0 ;
3838 byte result;
3839 void *argp1 = 0 ;
3840 int res1 = 0 ;
3841 PyObject *swig_obj[1] ;
3842
3843 if (!args) SWIG_fail;
3844 swig_obj[0] = args;
3845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3846 if (!SWIG_IsOK(res1)) {
3847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Red" "', expected argument " "1"" of type '" "wxColour *""'");
3848 }
3849 arg1 = reinterpret_cast< wxColour * >(argp1);
3850 {
3851 PyThreadState* __tstate = wxPyBeginAllowThreads();
3852 result = (byte)(arg1)->Red();
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3857 return resultobj;
3858 fail:
3859 return NULL;
3860 }
3861
3862
3863 SWIGINTERN PyObject *_wrap_Colour_Green(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3864 PyObject *resultobj = 0;
3865 wxColour *arg1 = (wxColour *) 0 ;
3866 byte result;
3867 void *argp1 = 0 ;
3868 int res1 = 0 ;
3869 PyObject *swig_obj[1] ;
3870
3871 if (!args) SWIG_fail;
3872 swig_obj[0] = args;
3873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3874 if (!SWIG_IsOK(res1)) {
3875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Green" "', expected argument " "1"" of type '" "wxColour *""'");
3876 }
3877 arg1 = reinterpret_cast< wxColour * >(argp1);
3878 {
3879 PyThreadState* __tstate = wxPyBeginAllowThreads();
3880 result = (byte)(arg1)->Green();
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3885 return resultobj;
3886 fail:
3887 return NULL;
3888 }
3889
3890
3891 SWIGINTERN PyObject *_wrap_Colour_Blue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3892 PyObject *resultobj = 0;
3893 wxColour *arg1 = (wxColour *) 0 ;
3894 byte result;
3895 void *argp1 = 0 ;
3896 int res1 = 0 ;
3897 PyObject *swig_obj[1] ;
3898
3899 if (!args) SWIG_fail;
3900 swig_obj[0] = args;
3901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3902 if (!SWIG_IsOK(res1)) {
3903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Blue" "', expected argument " "1"" of type '" "wxColour *""'");
3904 }
3905 arg1 = reinterpret_cast< wxColour * >(argp1);
3906 {
3907 PyThreadState* __tstate = wxPyBeginAllowThreads();
3908 result = (byte)(arg1)->Blue();
3909 wxPyEndAllowThreads(__tstate);
3910 if (PyErr_Occurred()) SWIG_fail;
3911 }
3912 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3913 return resultobj;
3914 fail:
3915 return NULL;
3916 }
3917
3918
3919 SWIGINTERN PyObject *_wrap_Colour_Alpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3920 PyObject *resultobj = 0;
3921 wxColour *arg1 = (wxColour *) 0 ;
3922 byte result;
3923 void *argp1 = 0 ;
3924 int res1 = 0 ;
3925 PyObject *swig_obj[1] ;
3926
3927 if (!args) SWIG_fail;
3928 swig_obj[0] = args;
3929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3930 if (!SWIG_IsOK(res1)) {
3931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Alpha" "', expected argument " "1"" of type '" "wxColour *""'");
3932 }
3933 arg1 = reinterpret_cast< wxColour * >(argp1);
3934 {
3935 PyThreadState* __tstate = wxPyBeginAllowThreads();
3936 result = (byte)(arg1)->Alpha();
3937 wxPyEndAllowThreads(__tstate);
3938 if (PyErr_Occurred()) SWIG_fail;
3939 }
3940 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3941 return resultobj;
3942 fail:
3943 return NULL;
3944 }
3945
3946
3947 SWIGINTERN PyObject *_wrap_Colour_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3948 PyObject *resultobj = 0;
3949 wxColour *arg1 = (wxColour *) 0 ;
3950 bool result;
3951 void *argp1 = 0 ;
3952 int res1 = 0 ;
3953 PyObject *swig_obj[1] ;
3954
3955 if (!args) SWIG_fail;
3956 swig_obj[0] = args;
3957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3958 if (!SWIG_IsOK(res1)) {
3959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Ok" "', expected argument " "1"" of type '" "wxColour *""'");
3960 }
3961 arg1 = reinterpret_cast< wxColour * >(argp1);
3962 {
3963 PyThreadState* __tstate = wxPyBeginAllowThreads();
3964 result = (bool)(arg1)->Ok();
3965 wxPyEndAllowThreads(__tstate);
3966 if (PyErr_Occurred()) SWIG_fail;
3967 }
3968 {
3969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3970 }
3971 return resultobj;
3972 fail:
3973 return NULL;
3974 }
3975
3976
3977 SWIGINTERN PyObject *_wrap_Colour_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3978 PyObject *resultobj = 0;
3979 wxColour *arg1 = (wxColour *) 0 ;
3980 byte arg2 ;
3981 byte arg3 ;
3982 byte arg4 ;
3983 byte arg5 = (byte) wxALPHA_OPAQUE ;
3984 void *argp1 = 0 ;
3985 int res1 = 0 ;
3986 unsigned char val2 ;
3987 int ecode2 = 0 ;
3988 unsigned char val3 ;
3989 int ecode3 = 0 ;
3990 unsigned char val4 ;
3991 int ecode4 = 0 ;
3992 unsigned char val5 ;
3993 int ecode5 = 0 ;
3994 PyObject * obj0 = 0 ;
3995 PyObject * obj1 = 0 ;
3996 PyObject * obj2 = 0 ;
3997 PyObject * obj3 = 0 ;
3998 PyObject * obj4 = 0 ;
3999 char * kwnames[] = {
4000 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
4001 };
4002
4003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4005 if (!SWIG_IsOK(res1)) {
4006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Set" "', expected argument " "1"" of type '" "wxColour *""'");
4007 }
4008 arg1 = reinterpret_cast< wxColour * >(argp1);
4009 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4010 if (!SWIG_IsOK(ecode2)) {
4011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Set" "', expected argument " "2"" of type '" "byte""'");
4012 }
4013 arg2 = static_cast< byte >(val2);
4014 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4015 if (!SWIG_IsOK(ecode3)) {
4016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Colour_Set" "', expected argument " "3"" of type '" "byte""'");
4017 }
4018 arg3 = static_cast< byte >(val3);
4019 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4020 if (!SWIG_IsOK(ecode4)) {
4021 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Colour_Set" "', expected argument " "4"" of type '" "byte""'");
4022 }
4023 arg4 = static_cast< byte >(val4);
4024 if (obj4) {
4025 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
4026 if (!SWIG_IsOK(ecode5)) {
4027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Colour_Set" "', expected argument " "5"" of type '" "byte""'");
4028 }
4029 arg5 = static_cast< byte >(val5);
4030 }
4031 {
4032 PyThreadState* __tstate = wxPyBeginAllowThreads();
4033 (arg1)->Set(arg2,arg3,arg4,arg5);
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 resultobj = SWIG_Py_Void();
4038 return resultobj;
4039 fail:
4040 return NULL;
4041 }
4042
4043
4044 SWIGINTERN PyObject *_wrap_Colour_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4045 PyObject *resultobj = 0;
4046 wxColour *arg1 = (wxColour *) 0 ;
4047 unsigned long arg2 ;
4048 void *argp1 = 0 ;
4049 int res1 = 0 ;
4050 unsigned long val2 ;
4051 int ecode2 = 0 ;
4052 PyObject * obj0 = 0 ;
4053 PyObject * obj1 = 0 ;
4054 char * kwnames[] = {
4055 (char *) "self",(char *) "colRGB", NULL
4056 };
4057
4058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4060 if (!SWIG_IsOK(res1)) {
4061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4062 }
4063 arg1 = reinterpret_cast< wxColour * >(argp1);
4064 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
4065 if (!SWIG_IsOK(ecode2)) {
4066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_SetRGB" "', expected argument " "2"" of type '" "unsigned long""'");
4067 }
4068 arg2 = static_cast< unsigned long >(val2);
4069 {
4070 PyThreadState* __tstate = wxPyBeginAllowThreads();
4071 (arg1)->Set(arg2);
4072 wxPyEndAllowThreads(__tstate);
4073 if (PyErr_Occurred()) SWIG_fail;
4074 }
4075 resultobj = SWIG_Py_Void();
4076 return resultobj;
4077 fail:
4078 return NULL;
4079 }
4080
4081
4082 SWIGINTERN PyObject *_wrap_Colour_SetFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4083 PyObject *resultobj = 0;
4084 wxColour *arg1 = (wxColour *) 0 ;
4085 wxString *arg2 = 0 ;
4086 void *argp1 = 0 ;
4087 int res1 = 0 ;
4088 bool temp2 = false ;
4089 PyObject * obj0 = 0 ;
4090 PyObject * obj1 = 0 ;
4091 char * kwnames[] = {
4092 (char *) "self",(char *) "colourName", NULL
4093 };
4094
4095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) SWIG_fail;
4096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4097 if (!SWIG_IsOK(res1)) {
4098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetFromName" "', expected argument " "1"" of type '" "wxColour *""'");
4099 }
4100 arg1 = reinterpret_cast< wxColour * >(argp1);
4101 {
4102 arg2 = wxString_in_helper(obj1);
4103 if (arg2 == NULL) SWIG_fail;
4104 temp2 = true;
4105 }
4106 {
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 (arg1)->InitFromName((wxString const &)*arg2);
4109 wxPyEndAllowThreads(__tstate);
4110 if (PyErr_Occurred()) SWIG_fail;
4111 }
4112 resultobj = SWIG_Py_Void();
4113 {
4114 if (temp2)
4115 delete arg2;
4116 }
4117 return resultobj;
4118 fail:
4119 {
4120 if (temp2)
4121 delete arg2;
4122 }
4123 return NULL;
4124 }
4125
4126
4127 SWIGINTERN PyObject *_wrap_Colour_GetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj = 0;
4129 wxColour *arg1 = (wxColour *) 0 ;
4130 long arg2 = (long) wxC2S_NAME|wxC2S_CSS_SYNTAX ;
4131 wxString result;
4132 void *argp1 = 0 ;
4133 int res1 = 0 ;
4134 long val2 ;
4135 int ecode2 = 0 ;
4136 PyObject * obj0 = 0 ;
4137 PyObject * obj1 = 0 ;
4138 char * kwnames[] = {
4139 (char *) "self",(char *) "flags", NULL
4140 };
4141
4142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_GetAsString",kwnames,&obj0,&obj1)) SWIG_fail;
4143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4144 if (!SWIG_IsOK(res1)) {
4145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetAsString" "', expected argument " "1"" of type '" "wxColour const *""'");
4146 }
4147 arg1 = reinterpret_cast< wxColour * >(argp1);
4148 if (obj1) {
4149 ecode2 = SWIG_AsVal_long(obj1, &val2);
4150 if (!SWIG_IsOK(ecode2)) {
4151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_GetAsString" "', expected argument " "2"" of type '" "long""'");
4152 }
4153 arg2 = static_cast< long >(val2);
4154 }
4155 {
4156 PyThreadState* __tstate = wxPyBeginAllowThreads();
4157 result = ((wxColour const *)arg1)->GetAsString(arg2);
4158 wxPyEndAllowThreads(__tstate);
4159 if (PyErr_Occurred()) SWIG_fail;
4160 }
4161 {
4162 #if wxUSE_UNICODE
4163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4164 #else
4165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4166 #endif
4167 }
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_Colour_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4175 PyObject *resultobj = 0;
4176 wxColour *arg1 = (wxColour *) 0 ;
4177 long result;
4178 void *argp1 = 0 ;
4179 int res1 = 0 ;
4180 PyObject *swig_obj[1] ;
4181
4182 if (!args) SWIG_fail;
4183 swig_obj[0] = args;
4184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4185 if (!SWIG_IsOK(res1)) {
4186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetPixel" "', expected argument " "1"" of type '" "wxColour const *""'");
4187 }
4188 arg1 = reinterpret_cast< wxColour * >(argp1);
4189 {
4190 PyThreadState* __tstate = wxPyBeginAllowThreads();
4191 result = (long)((wxColour const *)arg1)->GetPixel();
4192 wxPyEndAllowThreads(__tstate);
4193 if (PyErr_Occurred()) SWIG_fail;
4194 }
4195 resultobj = SWIG_From_long(static_cast< long >(result));
4196 return resultobj;
4197 fail:
4198 return NULL;
4199 }
4200
4201
4202 SWIGINTERN PyObject *_wrap_Colour___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4203 PyObject *resultobj = 0;
4204 wxColour *arg1 = (wxColour *) 0 ;
4205 PyObject *arg2 = (PyObject *) 0 ;
4206 bool result;
4207 void *argp1 = 0 ;
4208 int res1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4211 char * kwnames[] = {
4212 (char *) "self",(char *) "other", NULL
4213 };
4214
4215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4217 if (!SWIG_IsOK(res1)) {
4218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___eq__" "', expected argument " "1"" of type '" "wxColour *""'");
4219 }
4220 arg1 = reinterpret_cast< wxColour * >(argp1);
4221 arg2 = obj1;
4222 {
4223 result = (bool)wxColour___eq__(arg1,arg2);
4224 if (PyErr_Occurred()) SWIG_fail;
4225 }
4226 {
4227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4228 }
4229 return resultobj;
4230 fail:
4231 return NULL;
4232 }
4233
4234
4235 SWIGINTERN PyObject *_wrap_Colour___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4236 PyObject *resultobj = 0;
4237 wxColour *arg1 = (wxColour *) 0 ;
4238 PyObject *arg2 = (PyObject *) 0 ;
4239 bool result;
4240 void *argp1 = 0 ;
4241 int res1 = 0 ;
4242 PyObject * obj0 = 0 ;
4243 PyObject * obj1 = 0 ;
4244 char * kwnames[] = {
4245 (char *) "self",(char *) "other", NULL
4246 };
4247
4248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4250 if (!SWIG_IsOK(res1)) {
4251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___ne__" "', expected argument " "1"" of type '" "wxColour *""'");
4252 }
4253 arg1 = reinterpret_cast< wxColour * >(argp1);
4254 arg2 = obj1;
4255 {
4256 result = (bool)wxColour___ne__(arg1,arg2);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4261 }
4262 return resultobj;
4263 fail:
4264 return NULL;
4265 }
4266
4267
4268 SWIGINTERN PyObject *_wrap_Colour_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4269 PyObject *resultobj = 0;
4270 wxColour *arg1 = (wxColour *) 0 ;
4271 bool arg2 = (bool) false ;
4272 PyObject *result = 0 ;
4273 void *argp1 = 0 ;
4274 int res1 = 0 ;
4275 bool val2 ;
4276 int ecode2 = 0 ;
4277 PyObject * obj0 = 0 ;
4278 PyObject * obj1 = 0 ;
4279 char * kwnames[] = {
4280 (char *) "self",(char *) "includeAlpha", NULL
4281 };
4282
4283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_Get",kwnames,&obj0,&obj1)) SWIG_fail;
4284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4285 if (!SWIG_IsOK(res1)) {
4286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Get" "', expected argument " "1"" of type '" "wxColour *""'");
4287 }
4288 arg1 = reinterpret_cast< wxColour * >(argp1);
4289 if (obj1) {
4290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4291 if (!SWIG_IsOK(ecode2)) {
4292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Get" "', expected argument " "2"" of type '" "bool""'");
4293 }
4294 arg2 = static_cast< bool >(val2);
4295 }
4296 {
4297 result = (PyObject *)wxColour_Get(arg1,arg2);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 resultobj = result;
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 SWIGINTERN PyObject *_wrap_Colour_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxColour *arg1 = (wxColour *) 0 ;
4310 unsigned long result;
4311 void *argp1 = 0 ;
4312 int res1 = 0 ;
4313 PyObject *swig_obj[1] ;
4314
4315 if (!args) SWIG_fail;
4316 swig_obj[0] = args;
4317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4318 if (!SWIG_IsOK(res1)) {
4319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4320 }
4321 arg1 = reinterpret_cast< wxColour * >(argp1);
4322 {
4323 result = (unsigned long)wxColour_GetRGB(arg1);
4324 if (PyErr_Occurred()) SWIG_fail;
4325 }
4326 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
4327 return resultobj;
4328 fail:
4329 return NULL;
4330 }
4331
4332
4333 SWIGINTERN PyObject *Colour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4334 PyObject *obj;
4335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4336 SWIG_TypeNewClientData(SWIGTYPE_p_wxColour, SWIG_NewClientData(obj));
4337 return SWIG_Py_Void();
4338 }
4339
4340 SWIGINTERN PyObject *Colour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4341 return SWIG_Python_InitShadowInstance(args);
4342 }
4343
4344 SWIGINTERN PyObject *_wrap_new_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj = 0;
4346 int arg1 ;
4347 unsigned char *arg2 = (unsigned char *) 0 ;
4348 unsigned char *arg3 = (unsigned char *) 0 ;
4349 unsigned char *arg4 = (unsigned char *) 0 ;
4350 wxPalette *result = 0 ;
4351 int val1 ;
4352 int ecode1 = 0 ;
4353 void *argp2 = 0 ;
4354 int res2 = 0 ;
4355 void *argp3 = 0 ;
4356 int res3 = 0 ;
4357 void *argp4 = 0 ;
4358 int res4 = 0 ;
4359 PyObject * obj0 = 0 ;
4360 PyObject * obj1 = 0 ;
4361 PyObject * obj2 = 0 ;
4362 PyObject * obj3 = 0 ;
4363 char * kwnames[] = {
4364 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
4365 };
4366
4367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4368 ecode1 = SWIG_AsVal_int(obj0, &val1);
4369 if (!SWIG_IsOK(ecode1)) {
4370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Palette" "', expected argument " "1"" of type '" "int""'");
4371 }
4372 arg1 = static_cast< int >(val1);
4373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4374 if (!SWIG_IsOK(res2)) {
4375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Palette" "', expected argument " "2"" of type '" "unsigned char const *""'");
4376 }
4377 arg2 = reinterpret_cast< unsigned char * >(argp2);
4378 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
4379 if (!SWIG_IsOK(res3)) {
4380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Palette" "', expected argument " "3"" of type '" "unsigned char const *""'");
4381 }
4382 arg3 = reinterpret_cast< unsigned char * >(argp3);
4383 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
4384 if (!SWIG_IsOK(res4)) {
4385 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Palette" "', expected argument " "4"" of type '" "unsigned char const *""'");
4386 }
4387 arg4 = reinterpret_cast< unsigned char * >(argp4);
4388 {
4389 if (!wxPyCheckForApp()) SWIG_fail;
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
4392 wxPyEndAllowThreads(__tstate);
4393 if (PyErr_Occurred()) SWIG_fail;
4394 }
4395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, SWIG_POINTER_NEW | 0 );
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 SWIGINTERN PyObject *_wrap_delete_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4403 PyObject *resultobj = 0;
4404 wxPalette *arg1 = (wxPalette *) 0 ;
4405 void *argp1 = 0 ;
4406 int res1 = 0 ;
4407 PyObject *swig_obj[1] ;
4408
4409 if (!args) SWIG_fail;
4410 swig_obj[0] = args;
4411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, SWIG_POINTER_DISOWN | 0 );
4412 if (!SWIG_IsOK(res1)) {
4413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Palette" "', expected argument " "1"" of type '" "wxPalette *""'");
4414 }
4415 arg1 = reinterpret_cast< wxPalette * >(argp1);
4416 {
4417 PyThreadState* __tstate = wxPyBeginAllowThreads();
4418 delete arg1;
4419
4420 wxPyEndAllowThreads(__tstate);
4421 if (PyErr_Occurred()) SWIG_fail;
4422 }
4423 resultobj = SWIG_Py_Void();
4424 return resultobj;
4425 fail:
4426 return NULL;
4427 }
4428
4429
4430 SWIGINTERN PyObject *_wrap_Palette_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4431 PyObject *resultobj = 0;
4432 wxPalette *arg1 = (wxPalette *) 0 ;
4433 byte arg2 ;
4434 byte arg3 ;
4435 byte arg4 ;
4436 int result;
4437 void *argp1 = 0 ;
4438 int res1 = 0 ;
4439 unsigned char val2 ;
4440 int ecode2 = 0 ;
4441 unsigned char val3 ;
4442 int ecode3 = 0 ;
4443 unsigned char val4 ;
4444 int ecode4 = 0 ;
4445 PyObject * obj0 = 0 ;
4446 PyObject * obj1 = 0 ;
4447 PyObject * obj2 = 0 ;
4448 PyObject * obj3 = 0 ;
4449 char * kwnames[] = {
4450 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
4451 };
4452
4453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4455 if (!SWIG_IsOK(res1)) {
4456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetPixel" "', expected argument " "1"" of type '" "wxPalette *""'");
4457 }
4458 arg1 = reinterpret_cast< wxPalette * >(argp1);
4459 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4460 if (!SWIG_IsOK(ecode2)) {
4461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetPixel" "', expected argument " "2"" of type '" "byte""'");
4462 }
4463 arg2 = static_cast< byte >(val2);
4464 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4465 if (!SWIG_IsOK(ecode3)) {
4466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Palette_GetPixel" "', expected argument " "3"" of type '" "byte""'");
4467 }
4468 arg3 = static_cast< byte >(val3);
4469 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4470 if (!SWIG_IsOK(ecode4)) {
4471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Palette_GetPixel" "', expected argument " "4"" of type '" "byte""'");
4472 }
4473 arg4 = static_cast< byte >(val4);
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Palette_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4488 PyObject *resultobj = 0;
4489 wxPalette *arg1 = (wxPalette *) 0 ;
4490 int arg2 ;
4491 byte *arg3 = (byte *) 0 ;
4492 byte *arg4 = (byte *) 0 ;
4493 byte *arg5 = (byte *) 0 ;
4494 bool result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 int val2 ;
4498 int ecode2 = 0 ;
4499 byte temp3 ;
4500 int res3 = SWIG_TMPOBJ ;
4501 byte temp4 ;
4502 int res4 = SWIG_TMPOBJ ;
4503 byte temp5 ;
4504 int res5 = SWIG_TMPOBJ ;
4505 PyObject * obj0 = 0 ;
4506 PyObject * obj1 = 0 ;
4507 char * kwnames[] = {
4508 (char *) "self",(char *) "pixel", NULL
4509 };
4510
4511 arg3 = &temp3;
4512 arg4 = &temp4;
4513 arg5 = &temp5;
4514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetRGB" "', expected argument " "1"" of type '" "wxPalette *""'");
4518 }
4519 arg1 = reinterpret_cast< wxPalette * >(argp1);
4520 ecode2 = SWIG_AsVal_int(obj1, &val2);
4521 if (!SWIG_IsOK(ecode2)) {
4522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetRGB" "', expected argument " "2"" of type '" "int""'");
4523 }
4524 arg2 = static_cast< int >(val2);
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 if (SWIG_IsTmpObj(res3)) {
4535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
4536 } else {
4537 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
4539 }
4540 if (SWIG_IsTmpObj(res4)) {
4541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
4542 } else {
4543 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
4545 }
4546 if (SWIG_IsTmpObj(res5)) {
4547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)));
4548 } else {
4549 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags));
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 SWIGINTERN PyObject *_wrap_Palette_GetColoursCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4559 PyObject *resultobj = 0;
4560 wxPalette *arg1 = (wxPalette *) 0 ;
4561 int result;
4562 void *argp1 = 0 ;
4563 int res1 = 0 ;
4564 PyObject *swig_obj[1] ;
4565
4566 if (!args) SWIG_fail;
4567 swig_obj[0] = args;
4568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4569 if (!SWIG_IsOK(res1)) {
4570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetColoursCount" "', expected argument " "1"" of type '" "wxPalette const *""'");
4571 }
4572 arg1 = reinterpret_cast< wxPalette * >(argp1);
4573 {
4574 PyThreadState* __tstate = wxPyBeginAllowThreads();
4575 result = (int)((wxPalette const *)arg1)->GetColoursCount();
4576 wxPyEndAllowThreads(__tstate);
4577 if (PyErr_Occurred()) SWIG_fail;
4578 }
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_Palette_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 PyObject *resultobj = 0;
4588 wxPalette *arg1 = (wxPalette *) 0 ;
4589 bool result;
4590 void *argp1 = 0 ;
4591 int res1 = 0 ;
4592 PyObject *swig_obj[1] ;
4593
4594 if (!args) SWIG_fail;
4595 swig_obj[0] = args;
4596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4597 if (!SWIG_IsOK(res1)) {
4598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_Ok" "', expected argument " "1"" of type '" "wxPalette *""'");
4599 }
4600 arg1 = reinterpret_cast< wxPalette * >(argp1);
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (bool)(arg1)->Ok();
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 {
4608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4609 }
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 SWIGINTERN PyObject *Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *obj;
4618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4619 SWIG_TypeNewClientData(SWIGTYPE_p_wxPalette, SWIG_NewClientData(obj));
4620 return SWIG_Py_Void();
4621 }
4622
4623 SWIGINTERN PyObject *Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4624 return SWIG_Python_InitShadowInstance(args);
4625 }
4626
4627 SWIGINTERN PyObject *_wrap_new_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj = 0;
4629 wxColour *arg1 = 0 ;
4630 int arg2 = (int) 1 ;
4631 int arg3 = (int) wxSOLID ;
4632 wxPen *result = 0 ;
4633 wxColour temp1 ;
4634 int val2 ;
4635 int ecode2 = 0 ;
4636 int val3 ;
4637 int ecode3 = 0 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 PyObject * obj2 = 0 ;
4641 char * kwnames[] = {
4642 (char *) "colour",(char *) "width",(char *) "style", NULL
4643 };
4644
4645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4646 {
4647 arg1 = &temp1;
4648 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4649 }
4650 if (obj1) {
4651 ecode2 = SWIG_AsVal_int(obj1, &val2);
4652 if (!SWIG_IsOK(ecode2)) {
4653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pen" "', expected argument " "2"" of type '" "int""'");
4654 }
4655 arg2 = static_cast< int >(val2);
4656 }
4657 if (obj2) {
4658 ecode3 = SWIG_AsVal_int(obj2, &val3);
4659 if (!SWIG_IsOK(ecode3)) {
4660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pen" "', expected argument " "3"" of type '" "int""'");
4661 }
4662 arg3 = static_cast< int >(val3);
4663 }
4664 {
4665 if (!wxPyCheckForApp()) SWIG_fail;
4666 PyThreadState* __tstate = wxPyBeginAllowThreads();
4667 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
4668 wxPyEndAllowThreads(__tstate);
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, SWIG_POINTER_NEW | 0 );
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 SWIGINTERN PyObject *_wrap_delete_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4679 PyObject *resultobj = 0;
4680 wxPen *arg1 = (wxPen *) 0 ;
4681 void *argp1 = 0 ;
4682 int res1 = 0 ;
4683 PyObject *swig_obj[1] ;
4684
4685 if (!args) SWIG_fail;
4686 swig_obj[0] = args;
4687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, SWIG_POINTER_DISOWN | 0 );
4688 if (!SWIG_IsOK(res1)) {
4689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pen" "', expected argument " "1"" of type '" "wxPen *""'");
4690 }
4691 arg1 = reinterpret_cast< wxPen * >(argp1);
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 delete arg1;
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 resultobj = SWIG_Py_Void();
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 SWIGINTERN PyObject *_wrap_Pen_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4707 PyObject *resultobj = 0;
4708 wxPen *arg1 = (wxPen *) 0 ;
4709 int result;
4710 void *argp1 = 0 ;
4711 int res1 = 0 ;
4712 PyObject *swig_obj[1] ;
4713
4714 if (!args) SWIG_fail;
4715 swig_obj[0] = args;
4716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4717 if (!SWIG_IsOK(res1)) {
4718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4719 }
4720 arg1 = reinterpret_cast< wxPen * >(argp1);
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (int)(arg1)->GetCap();
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 resultobj = SWIG_From_int(static_cast< int >(result));
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 SWIGINTERN PyObject *_wrap_Pen_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4735 PyObject *resultobj = 0;
4736 wxPen *arg1 = (wxPen *) 0 ;
4737 wxColour result;
4738 void *argp1 = 0 ;
4739 int res1 = 0 ;
4740 PyObject *swig_obj[1] ;
4741
4742 if (!args) SWIG_fail;
4743 swig_obj[0] = args;
4744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4745 if (!SWIG_IsOK(res1)) {
4746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4747 }
4748 arg1 = reinterpret_cast< wxPen * >(argp1);
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->GetColour();
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Pen_GetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4763 PyObject *resultobj = 0;
4764 wxPen *arg1 = (wxPen *) 0 ;
4765 int result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 PyObject *swig_obj[1] ;
4769
4770 if (!args) SWIG_fail;
4771 swig_obj[0] = args;
4772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4773 if (!SWIG_IsOK(res1)) {
4774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4775 }
4776 arg1 = reinterpret_cast< wxPen * >(argp1);
4777 {
4778 PyThreadState* __tstate = wxPyBeginAllowThreads();
4779 result = (int)(arg1)->GetJoin();
4780 wxPyEndAllowThreads(__tstate);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 resultobj = SWIG_From_int(static_cast< int >(result));
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 SWIGINTERN PyObject *_wrap_Pen_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4791 PyObject *resultobj = 0;
4792 wxPen *arg1 = (wxPen *) 0 ;
4793 int result;
4794 void *argp1 = 0 ;
4795 int res1 = 0 ;
4796 PyObject *swig_obj[1] ;
4797
4798 if (!args) SWIG_fail;
4799 swig_obj[0] = args;
4800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4801 if (!SWIG_IsOK(res1)) {
4802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4803 }
4804 arg1 = reinterpret_cast< wxPen * >(argp1);
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 result = (int)(arg1)->GetStyle();
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_From_int(static_cast< int >(result));
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Pen_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4819 PyObject *resultobj = 0;
4820 wxPen *arg1 = (wxPen *) 0 ;
4821 int result;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 PyObject *swig_obj[1] ;
4825
4826 if (!args) SWIG_fail;
4827 swig_obj[0] = args;
4828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4831 }
4832 arg1 = reinterpret_cast< wxPen * >(argp1);
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (int)(arg1)->GetWidth();
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 resultobj = SWIG_From_int(static_cast< int >(result));
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_Pen_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4847 PyObject *resultobj = 0;
4848 wxPen *arg1 = (wxPen *) 0 ;
4849 bool result;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 PyObject *swig_obj[1] ;
4853
4854 if (!args) SWIG_fail;
4855 swig_obj[0] = args;
4856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4857 if (!SWIG_IsOK(res1)) {
4858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_Ok" "', expected argument " "1"" of type '" "wxPen *""'");
4859 }
4860 arg1 = reinterpret_cast< wxPen * >(argp1);
4861 {
4862 PyThreadState* __tstate = wxPyBeginAllowThreads();
4863 result = (bool)(arg1)->Ok();
4864 wxPyEndAllowThreads(__tstate);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 {
4868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4869 }
4870 return resultobj;
4871 fail:
4872 return NULL;
4873 }
4874
4875
4876 SWIGINTERN PyObject *_wrap_Pen_SetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4877 PyObject *resultobj = 0;
4878 wxPen *arg1 = (wxPen *) 0 ;
4879 int arg2 ;
4880 void *argp1 = 0 ;
4881 int res1 = 0 ;
4882 int val2 ;
4883 int ecode2 = 0 ;
4884 PyObject * obj0 = 0 ;
4885 PyObject * obj1 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "cap_style", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4894 }
4895 arg1 = reinterpret_cast< wxPen * >(argp1);
4896 ecode2 = SWIG_AsVal_int(obj1, &val2);
4897 if (!SWIG_IsOK(ecode2)) {
4898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetCap" "', expected argument " "2"" of type '" "int""'");
4899 }
4900 arg2 = static_cast< int >(val2);
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 (arg1)->SetCap(arg2);
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_Py_Void();
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_Pen_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4915 PyObject *resultobj = 0;
4916 wxPen *arg1 = (wxPen *) 0 ;
4917 wxColour *arg2 = 0 ;
4918 void *argp1 = 0 ;
4919 int res1 = 0 ;
4920 wxColour temp2 ;
4921 PyObject * obj0 = 0 ;
4922 PyObject * obj1 = 0 ;
4923 char * kwnames[] = {
4924 (char *) "self",(char *) "colour", NULL
4925 };
4926
4927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
4928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4929 if (!SWIG_IsOK(res1)) {
4930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4931 }
4932 arg1 = reinterpret_cast< wxPen * >(argp1);
4933 {
4934 arg2 = &temp2;
4935 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4936 }
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 (arg1)->SetColour(*arg2);
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_Py_Void();
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 SWIGINTERN PyObject *_wrap_Pen_SetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj = 0;
4952 wxPen *arg1 = (wxPen *) 0 ;
4953 int arg2 ;
4954 void *argp1 = 0 ;
4955 int res1 = 0 ;
4956 int val2 ;
4957 int ecode2 = 0 ;
4958 PyObject * obj0 = 0 ;
4959 PyObject * obj1 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "join_style", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4968 }
4969 arg1 = reinterpret_cast< wxPen * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetJoin" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 {
4976 PyThreadState* __tstate = wxPyBeginAllowThreads();
4977 (arg1)->SetJoin(arg2);
4978 wxPyEndAllowThreads(__tstate);
4979 if (PyErr_Occurred()) SWIG_fail;
4980 }
4981 resultobj = SWIG_Py_Void();
4982 return resultobj;
4983 fail:
4984 return NULL;
4985 }
4986
4987
4988 SWIGINTERN PyObject *_wrap_Pen_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj = 0;
4990 wxPen *arg1 = (wxPen *) 0 ;
4991 int arg2 ;
4992 void *argp1 = 0 ;
4993 int res1 = 0 ;
4994 int val2 ;
4995 int ecode2 = 0 ;
4996 PyObject * obj0 = 0 ;
4997 PyObject * obj1 = 0 ;
4998 char * kwnames[] = {
4999 (char *) "self",(char *) "style", NULL
5000 };
5001
5002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5004 if (!SWIG_IsOK(res1)) {
5005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
5006 }
5007 arg1 = reinterpret_cast< wxPen * >(argp1);
5008 ecode2 = SWIG_AsVal_int(obj1, &val2);
5009 if (!SWIG_IsOK(ecode2)) {
5010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetStyle" "', expected argument " "2"" of type '" "int""'");
5011 }
5012 arg2 = static_cast< int >(val2);
5013 {
5014 PyThreadState* __tstate = wxPyBeginAllowThreads();
5015 (arg1)->SetStyle(arg2);
5016 wxPyEndAllowThreads(__tstate);
5017 if (PyErr_Occurred()) SWIG_fail;
5018 }
5019 resultobj = SWIG_Py_Void();
5020 return resultobj;
5021 fail:
5022 return NULL;
5023 }
5024
5025
5026 SWIGINTERN PyObject *_wrap_Pen_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj = 0;
5028 wxPen *arg1 = (wxPen *) 0 ;
5029 int arg2 ;
5030 void *argp1 = 0 ;
5031 int res1 = 0 ;
5032 int val2 ;
5033 int ecode2 = 0 ;
5034 PyObject * obj0 = 0 ;
5035 PyObject * obj1 = 0 ;
5036 char * kwnames[] = {
5037 (char *) "self",(char *) "width", NULL
5038 };
5039
5040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5042 if (!SWIG_IsOK(res1)) {
5043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
5044 }
5045 arg1 = reinterpret_cast< wxPen * >(argp1);
5046 ecode2 = SWIG_AsVal_int(obj1, &val2);
5047 if (!SWIG_IsOK(ecode2)) {
5048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetWidth" "', expected argument " "2"" of type '" "int""'");
5049 }
5050 arg2 = static_cast< int >(val2);
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 (arg1)->SetWidth(arg2);
5054 wxPyEndAllowThreads(__tstate);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 resultobj = SWIG_Py_Void();
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 SWIGINTERN PyObject *_wrap_Pen_SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj = 0;
5066 wxPen *arg1 = (wxPen *) 0 ;
5067 int arg2 ;
5068 wxDash *arg3 = (wxDash *) 0 ;
5069 void *argp1 = 0 ;
5070 int res1 = 0 ;
5071 PyObject * obj0 = 0 ;
5072 PyObject * obj1 = 0 ;
5073 char * kwnames[] = {
5074 (char *) "self",(char *) "dashes", NULL
5075 };
5076
5077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) SWIG_fail;
5078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5081 }
5082 arg1 = reinterpret_cast< wxPen * >(argp1);
5083 {
5084 arg2 = PyList_Size(obj1);
5085 arg3 = (wxDash*)byte_LIST_helper(obj1);
5086 if (arg3 == NULL) SWIG_fail;
5087 }
5088 {
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 (arg1)->SetDashes(arg2,arg3);
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 resultobj = SWIG_Py_Void();
5095 {
5096 if (arg3) delete [] arg3;
5097 }
5098 return resultobj;
5099 fail:
5100 {
5101 if (arg3) delete [] arg3;
5102 }
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_Pen_GetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *resultobj = 0;
5109 wxPen *arg1 = (wxPen *) 0 ;
5110 PyObject *result = 0 ;
5111 void *argp1 = 0 ;
5112 int res1 = 0 ;
5113 PyObject *swig_obj[1] ;
5114
5115 if (!args) SWIG_fail;
5116 swig_obj[0] = args;
5117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5118 if (!SWIG_IsOK(res1)) {
5119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5120 }
5121 arg1 = reinterpret_cast< wxPen * >(argp1);
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (PyObject *)wxPen_GetDashes(arg1);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = result;
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_Pen__SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj = 0;
5137 wxPen *arg1 = (wxPen *) 0 ;
5138 PyObject *arg2 = (PyObject *) 0 ;
5139 PyObject *arg3 = (PyObject *) 0 ;
5140 void *argp1 = 0 ;
5141 int res1 = 0 ;
5142 PyObject * obj0 = 0 ;
5143 PyObject * obj1 = 0 ;
5144 PyObject * obj2 = 0 ;
5145 char * kwnames[] = {
5146 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
5147 };
5148
5149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5151 if (!SWIG_IsOK(res1)) {
5152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen__SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5153 }
5154 arg1 = reinterpret_cast< wxPen * >(argp1);
5155 arg2 = obj1;
5156 arg3 = obj2;
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 wxPen__SetDashes(arg1,arg2,arg3);
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = SWIG_Py_Void();
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *_wrap_Pen___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5171 PyObject *resultobj = 0;
5172 wxPen *arg1 = (wxPen *) 0 ;
5173 wxPen *arg2 = (wxPen *) 0 ;
5174 bool result;
5175 void *argp1 = 0 ;
5176 int res1 = 0 ;
5177 void *argp2 = 0 ;
5178 int res2 = 0 ;
5179 PyObject * obj0 = 0 ;
5180 PyObject * obj1 = 0 ;
5181 char * kwnames[] = {
5182 (char *) "self",(char *) "other", NULL
5183 };
5184
5185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___eq__" "', expected argument " "1"" of type '" "wxPen *""'");
5189 }
5190 arg1 = reinterpret_cast< wxPen * >(argp1);
5191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5192 if (!SWIG_IsOK(res2)) {
5193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___eq__" "', expected argument " "2"" of type '" "wxPen const *""'");
5194 }
5195 arg2 = reinterpret_cast< wxPen * >(argp2);
5196 {
5197 PyThreadState* __tstate = wxPyBeginAllowThreads();
5198 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
5199 wxPyEndAllowThreads(__tstate);
5200 if (PyErr_Occurred()) SWIG_fail;
5201 }
5202 {
5203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5204 }
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_Pen___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj = 0;
5213 wxPen *arg1 = (wxPen *) 0 ;
5214 wxPen *arg2 = (wxPen *) 0 ;
5215 bool result;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 void *argp2 = 0 ;
5219 int res2 = 0 ;
5220 PyObject * obj0 = 0 ;
5221 PyObject * obj1 = 0 ;
5222 char * kwnames[] = {
5223 (char *) "self",(char *) "other", NULL
5224 };
5225
5226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5228 if (!SWIG_IsOK(res1)) {
5229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___ne__" "', expected argument " "1"" of type '" "wxPen *""'");
5230 }
5231 arg1 = reinterpret_cast< wxPen * >(argp1);
5232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5233 if (!SWIG_IsOK(res2)) {
5234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___ne__" "', expected argument " "2"" of type '" "wxPen const *""'");
5235 }
5236 arg2 = reinterpret_cast< wxPen * >(argp2);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 {
5244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5245 }
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 SWIGINTERN PyObject *Pen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5253 PyObject *obj;
5254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5255 SWIG_TypeNewClientData(SWIGTYPE_p_wxPen, SWIG_NewClientData(obj));
5256 return SWIG_Py_Void();
5257 }
5258
5259 SWIGINTERN PyObject *Pen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5260 return SWIG_Python_InitShadowInstance(args);
5261 }
5262
5263 SWIGINTERN PyObject *_wrap_new_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 wxColour *arg1 = 0 ;
5266 int arg2 = (int) wxSOLID ;
5267 wxBrush *result = 0 ;
5268 wxColour temp1 ;
5269 int val2 ;
5270 int ecode2 = 0 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char * kwnames[] = {
5274 (char *) "colour",(char *) "style", NULL
5275 };
5276
5277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) SWIG_fail;
5278 {
5279 arg1 = &temp1;
5280 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
5281 }
5282 if (obj1) {
5283 ecode2 = SWIG_AsVal_int(obj1, &val2);
5284 if (!SWIG_IsOK(ecode2)) {
5285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Brush" "', expected argument " "2"" of type '" "int""'");
5286 }
5287 arg2 = static_cast< int >(val2);
5288 }
5289 {
5290 if (!wxPyCheckForApp()) SWIG_fail;
5291 PyThreadState* __tstate = wxPyBeginAllowThreads();
5292 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_NEW | 0 );
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 SWIGINTERN PyObject *_wrap_new_BrushFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj = 0;
5305 wxBitmap *arg1 = 0 ;
5306 wxBrush *result = 0 ;
5307 void *argp1 = 0 ;
5308 int res1 = 0 ;
5309 PyObject * obj0 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "stippleBitmap", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5318 }
5319 if (!argp1) {
5320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5321 }
5322 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5323 {
5324 if (!wxPyCheckForApp()) SWIG_fail;
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_OWN | 0 );
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_delete_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5338 PyObject *resultobj = 0;
5339 wxBrush *arg1 = (wxBrush *) 0 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 PyObject *swig_obj[1] ;
5343
5344 if (!args) SWIG_fail;
5345 swig_obj[0] = args;
5346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, SWIG_POINTER_DISOWN | 0 );
5347 if (!SWIG_IsOK(res1)) {
5348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brush" "', expected argument " "1"" of type '" "wxBrush *""'");
5349 }
5350 arg1 = reinterpret_cast< wxBrush * >(argp1);
5351 {
5352 PyThreadState* __tstate = wxPyBeginAllowThreads();
5353 delete arg1;
5354
5355 wxPyEndAllowThreads(__tstate);
5356 if (PyErr_Occurred()) SWIG_fail;
5357 }
5358 resultobj = SWIG_Py_Void();
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 SWIGINTERN PyObject *_wrap_Brush_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj = 0;
5367 wxBrush *arg1 = (wxBrush *) 0 ;
5368 wxColour *arg2 = 0 ;
5369 void *argp1 = 0 ;
5370 int res1 = 0 ;
5371 wxColour temp2 ;
5372 PyObject * obj0 = 0 ;
5373 PyObject * obj1 = 0 ;
5374 char * kwnames[] = {
5375 (char *) "self",(char *) "col", NULL
5376 };
5377
5378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
5379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5380 if (!SWIG_IsOK(res1)) {
5381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetColour" "', expected argument " "1"" of type '" "wxBrush *""'");
5382 }
5383 arg1 = reinterpret_cast< wxBrush * >(argp1);
5384 {
5385 arg2 = &temp2;
5386 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5387 }
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 (arg1)->SetColour((wxColour const &)*arg2);
5391 wxPyEndAllowThreads(__tstate);
5392 if (PyErr_Occurred()) SWIG_fail;
5393 }
5394 resultobj = SWIG_Py_Void();
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 SWIGINTERN PyObject *_wrap_Brush_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5402 PyObject *resultobj = 0;
5403 wxBrush *arg1 = (wxBrush *) 0 ;
5404 int arg2 ;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 int val2 ;
5408 int ecode2 = 0 ;
5409 PyObject * obj0 = 0 ;
5410 PyObject * obj1 = 0 ;
5411 char * kwnames[] = {
5412 (char *) "self",(char *) "style", NULL
5413 };
5414
5415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5417 if (!SWIG_IsOK(res1)) {
5418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStyle" "', expected argument " "1"" of type '" "wxBrush *""'");
5419 }
5420 arg1 = reinterpret_cast< wxBrush * >(argp1);
5421 ecode2 = SWIG_AsVal_int(obj1, &val2);
5422 if (!SWIG_IsOK(ecode2)) {
5423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_SetStyle" "', expected argument " "2"" of type '" "int""'");
5424 }
5425 arg2 = static_cast< int >(val2);
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 (arg1)->SetStyle(arg2);
5429 wxPyEndAllowThreads(__tstate);
5430 if (PyErr_Occurred()) SWIG_fail;
5431 }
5432 resultobj = SWIG_Py_Void();
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_Brush_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 wxBrush *arg1 = (wxBrush *) 0 ;
5442 wxBitmap *arg2 = 0 ;
5443 void *argp1 = 0 ;
5444 int res1 = 0 ;
5445 void *argp2 = 0 ;
5446 int res2 = 0 ;
5447 PyObject * obj0 = 0 ;
5448 PyObject * obj1 = 0 ;
5449 char * kwnames[] = {
5450 (char *) "self",(char *) "stipple", NULL
5451 };
5452
5453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStipple" "', expected argument " "1"" of type '" "wxBrush *""'");
5457 }
5458 arg1 = reinterpret_cast< wxBrush * >(argp1);
5459 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
5460 if (!SWIG_IsOK(res2)) {
5461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5462 }
5463 if (!argp2) {
5464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5465 }
5466 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 (arg1)->SetStipple((wxBitmap const &)*arg2);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_Py_Void();
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_Brush_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxBrush *arg1 = (wxBrush *) 0 ;
5483 wxColour result;
5484 void *argp1 = 0 ;
5485 int res1 = 0 ;
5486 PyObject *swig_obj[1] ;
5487
5488 if (!args) SWIG_fail;
5489 swig_obj[0] = args;
5490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5491 if (!SWIG_IsOK(res1)) {
5492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetColour" "', expected argument " "1"" of type '" "wxBrush const *""'");
5493 }
5494 arg1 = reinterpret_cast< wxBrush * >(argp1);
5495 {
5496 PyThreadState* __tstate = wxPyBeginAllowThreads();
5497 result = ((wxBrush const *)arg1)->GetColour();
5498 wxPyEndAllowThreads(__tstate);
5499 if (PyErr_Occurred()) SWIG_fail;
5500 }
5501 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 SWIGINTERN PyObject *_wrap_Brush_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5509 PyObject *resultobj = 0;
5510 wxBrush *arg1 = (wxBrush *) 0 ;
5511 int result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject *swig_obj[1] ;
5515
5516 if (!args) SWIG_fail;
5517 swig_obj[0] = args;
5518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5519 if (!SWIG_IsOK(res1)) {
5520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStyle" "', expected argument " "1"" of type '" "wxBrush const *""'");
5521 }
5522 arg1 = reinterpret_cast< wxBrush * >(argp1);
5523 {
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 result = (int)((wxBrush const *)arg1)->GetStyle();
5526 wxPyEndAllowThreads(__tstate);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 resultobj = SWIG_From_int(static_cast< int >(result));
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_Brush_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537 PyObject *resultobj = 0;
5538 wxBrush *arg1 = (wxBrush *) 0 ;
5539 wxBitmap *result = 0 ;
5540 void *argp1 = 0 ;
5541 int res1 = 0 ;
5542 PyObject *swig_obj[1] ;
5543
5544 if (!args) SWIG_fail;
5545 swig_obj[0] = args;
5546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5547 if (!SWIG_IsOK(res1)) {
5548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStipple" "', expected argument " "1"" of type '" "wxBrush const *""'");
5549 }
5550 arg1 = reinterpret_cast< wxBrush * >(argp1);
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_Brush_IsHatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxBrush *arg1 = (wxBrush *) 0 ;
5567 bool result;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 PyObject *swig_obj[1] ;
5571
5572 if (!args) SWIG_fail;
5573 swig_obj[0] = args;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_IsHatch" "', expected argument " "1"" of type '" "wxBrush const *""'");
5577 }
5578 arg1 = reinterpret_cast< wxBrush * >(argp1);
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (bool)((wxBrush const *)arg1)->IsHatch();
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 {
5586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5587 }
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 SWIGINTERN PyObject *_wrap_Brush_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5595 PyObject *resultobj = 0;
5596 wxBrush *arg1 = (wxBrush *) 0 ;
5597 bool result;
5598 void *argp1 = 0 ;
5599 int res1 = 0 ;
5600 PyObject *swig_obj[1] ;
5601
5602 if (!args) SWIG_fail;
5603 swig_obj[0] = args;
5604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5605 if (!SWIG_IsOK(res1)) {
5606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_Ok" "', expected argument " "1"" of type '" "wxBrush *""'");
5607 }
5608 arg1 = reinterpret_cast< wxBrush * >(argp1);
5609 {
5610 PyThreadState* __tstate = wxPyBeginAllowThreads();
5611 result = (bool)(arg1)->Ok();
5612 wxPyEndAllowThreads(__tstate);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 {
5616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5617 }
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 SWIGINTERN PyObject *_wrap_Brush_MacGetTheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5625 PyObject *resultobj = 0;
5626 wxBrush *arg1 = (wxBrush *) 0 ;
5627 short result;
5628 void *argp1 = 0 ;
5629 int res1 = 0 ;
5630 PyObject *swig_obj[1] ;
5631
5632 if (!args) SWIG_fail;
5633 swig_obj[0] = args;
5634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5635 if (!SWIG_IsOK(res1)) {
5636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_MacGetTheme" "', expected argument " "1"" of type '" "wxBrush *""'");
5637 }
5638 arg1 = reinterpret_cast< wxBrush * >(argp1);
5639 {
5640 PyThreadState* __tstate = wxPyBeginAllowThreads();
5641 result = (short)(arg1)->MacGetTheme();
5642 wxPyEndAllowThreads(__tstate);
5643 if (PyErr_Occurred()) SWIG_fail;
5644 }
5645 resultobj = SWIG_From_short(static_cast< short >(result));
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 SWIGINTERN PyObject *_wrap_Brush_MacSetTheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj = 0;
5654 wxBrush *arg1 = (wxBrush *) 0 ;
5655 short arg2 ;
5656 void *argp1 = 0 ;
5657 int res1 = 0 ;
5658 short val2 ;
5659 int ecode2 = 0 ;
5660 PyObject * obj0 = 0 ;
5661 PyObject * obj1 = 0 ;
5662 char * kwnames[] = {
5663 (char *) "self",(char *) "macThemeBrush", NULL
5664 };
5665
5666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) SWIG_fail;
5667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_MacSetTheme" "', expected argument " "1"" of type '" "wxBrush *""'");
5670 }
5671 arg1 = reinterpret_cast< wxBrush * >(argp1);
5672 ecode2 = SWIG_AsVal_short(obj1, &val2);
5673 if (!SWIG_IsOK(ecode2)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_MacSetTheme" "', expected argument " "2"" of type '" "short""'");
5675 }
5676 arg2 = static_cast< short >(val2);
5677 {
5678 PyThreadState* __tstate = wxPyBeginAllowThreads();
5679 (arg1)->MacSetTheme(arg2);
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 resultobj = SWIG_Py_Void();
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 SWIGINTERN PyObject *Brush_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5691 PyObject *obj;
5692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5693 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrush, SWIG_NewClientData(obj));
5694 return SWIG_Py_Void();
5695 }
5696
5697 SWIGINTERN PyObject *Brush_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5698 return SWIG_Python_InitShadowInstance(args);
5699 }
5700
5701 SWIGINTERN PyObject *_wrap_new_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5702 PyObject *resultobj = 0;
5703 wxString *arg1 = 0 ;
5704 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
5705 wxBitmap *result = 0 ;
5706 bool temp1 = false ;
5707 int val2 ;
5708 int ecode2 = 0 ;
5709 PyObject * obj0 = 0 ;
5710 PyObject * obj1 = 0 ;
5711 char * kwnames[] = {
5712 (char *) "name",(char *) "type", NULL
5713 };
5714
5715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5716 {
5717 arg1 = wxString_in_helper(obj0);
5718 if (arg1 == NULL) SWIG_fail;
5719 temp1 = true;
5720 }
5721 if (obj1) {
5722 ecode2 = SWIG_AsVal_int(obj1, &val2);
5723 if (!SWIG_IsOK(ecode2)) {
5724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Bitmap" "', expected argument " "2"" of type '" "wxBitmapType""'");
5725 }
5726 arg2 = static_cast< wxBitmapType >(val2);
5727 }
5728 {
5729 if (!wxPyCheckForApp()) SWIG_fail;
5730 PyThreadState* __tstate = wxPyBeginAllowThreads();
5731 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,arg2);
5732 wxPyEndAllowThreads(__tstate);
5733 if (PyErr_Occurred()) SWIG_fail;
5734 }
5735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_NEW | 0 );
5736 {
5737 if (temp1)
5738 delete arg1;
5739 }
5740 return resultobj;
5741 fail:
5742 {
5743 if (temp1)
5744 delete arg1;
5745 }
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_delete_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5751 PyObject *resultobj = 0;
5752 wxBitmap *arg1 = (wxBitmap *) 0 ;
5753 void *argp1 = 0 ;
5754 int res1 = 0 ;
5755 PyObject *swig_obj[1] ;
5756
5757 if (!args) SWIG_fail;
5758 swig_obj[0] = args;
5759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, SWIG_POINTER_DISOWN | 0 );
5760 if (!SWIG_IsOK(res1)) {
5761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bitmap" "', expected argument " "1"" of type '" "wxBitmap *""'");
5762 }
5763 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5764 {
5765 delete arg1;
5766
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 resultobj = SWIG_Py_Void();
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_new_EmptyBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 int arg1 ;
5779 int arg2 ;
5780 int arg3 = (int) -1 ;
5781 wxBitmap *result = 0 ;
5782 int val1 ;
5783 int ecode1 = 0 ;
5784 int val2 ;
5785 int ecode2 = 0 ;
5786 int val3 ;
5787 int ecode3 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 PyObject * obj2 = 0 ;
5791 char * kwnames[] = {
5792 (char *) "width",(char *) "height",(char *) "depth", NULL
5793 };
5794
5795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5796 ecode1 = SWIG_AsVal_int(obj0, &val1);
5797 if (!SWIG_IsOK(ecode1)) {
5798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyBitmap" "', expected argument " "1"" of type '" "int""'");
5799 }
5800 arg1 = static_cast< int >(val1);
5801 ecode2 = SWIG_AsVal_int(obj1, &val2);
5802 if (!SWIG_IsOK(ecode2)) {
5803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyBitmap" "', expected argument " "2"" of type '" "int""'");
5804 }
5805 arg2 = static_cast< int >(val2);
5806 if (obj2) {
5807 ecode3 = SWIG_AsVal_int(obj2, &val3);
5808 if (!SWIG_IsOK(ecode3)) {
5809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyBitmap" "', expected argument " "3"" of type '" "int""'");
5810 }
5811 arg3 = static_cast< int >(val3);
5812 }
5813 {
5814 if (!wxPyCheckForApp()) SWIG_fail;
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_new_BitmapFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = 0;
5829 wxIcon *arg1 = 0 ;
5830 wxBitmap *result = 0 ;
5831 void *argp1 = 0 ;
5832 int res1 = 0 ;
5833 PyObject * obj0 = 0 ;
5834 char * kwnames[] = {
5835 (char *) "icon", NULL
5836 };
5837
5838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) SWIG_fail;
5839 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
5840 if (!SWIG_IsOK(res1)) {
5841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5842 }
5843 if (!argp1) {
5844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5845 }
5846 arg1 = reinterpret_cast< wxIcon * >(argp1);
5847 {
5848 if (!wxPyCheckForApp()) SWIG_fail;
5849 PyThreadState* __tstate = wxPyBeginAllowThreads();
5850 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_new_BitmapFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj = 0;
5863 wxImage *arg1 = 0 ;
5864 int arg2 = (int) -1 ;
5865 wxBitmap *result = 0 ;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 int val2 ;
5869 int ecode2 = 0 ;
5870 PyObject * obj0 = 0 ;
5871 PyObject * obj1 = 0 ;
5872 char * kwnames[] = {
5873 (char *) "image",(char *) "depth", NULL
5874 };
5875
5876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) SWIG_fail;
5877 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
5878 if (!SWIG_IsOK(res1)) {
5879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5880 }
5881 if (!argp1) {
5882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5883 }
5884 arg1 = reinterpret_cast< wxImage * >(argp1);
5885 if (obj1) {
5886 ecode2 = SWIG_AsVal_int(obj1, &val2);
5887 if (!SWIG_IsOK(ecode2)) {
5888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromImage" "', expected argument " "2"" of type '" "int""'");
5889 }
5890 arg2 = static_cast< int >(val2);
5891 }
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_new_BitmapFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj = 0;
5908 PyObject *arg1 = (PyObject *) 0 ;
5909 wxBitmap *result = 0 ;
5910 PyObject * obj0 = 0 ;
5911 char * kwnames[] = {
5912 (char *) "listOfStrings", NULL
5913 };
5914
5915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) SWIG_fail;
5916 arg1 = obj0;
5917 {
5918 if (!wxPyCheckForApp()) SWIG_fail;
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 result = (wxBitmap *)new_wxBitmap(arg1);
5921 wxPyEndAllowThreads(__tstate);
5922 if (PyErr_Occurred()) SWIG_fail;
5923 }
5924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 SWIGINTERN PyObject *_wrap_new_BitmapFromBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj = 0;
5933 PyObject *arg1 = (PyObject *) 0 ;
5934 int arg2 ;
5935 int arg3 ;
5936 int arg4 = (int) 1 ;
5937 wxBitmap *result = 0 ;
5938 int val2 ;
5939 int ecode2 = 0 ;
5940 int val3 ;
5941 int ecode3 = 0 ;
5942 int val4 ;
5943 int ecode4 = 0 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 PyObject * obj2 = 0 ;
5947 PyObject * obj3 = 0 ;
5948 char * kwnames[] = {
5949 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
5950 };
5951
5952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5953 arg1 = obj0;
5954 ecode2 = SWIG_AsVal_int(obj1, &val2);
5955 if (!SWIG_IsOK(ecode2)) {
5956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromBits" "', expected argument " "2"" of type '" "int""'");
5957 }
5958 arg2 = static_cast< int >(val2);
5959 ecode3 = SWIG_AsVal_int(obj2, &val3);
5960 if (!SWIG_IsOK(ecode3)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BitmapFromBits" "', expected argument " "3"" of type '" "int""'");
5962 }
5963 arg3 = static_cast< int >(val3);
5964 if (obj3) {
5965 ecode4 = SWIG_AsVal_int(obj3, &val4);
5966 if (!SWIG_IsOK(ecode4)) {
5967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BitmapFromBits" "', expected argument " "4"" of type '" "int""'");
5968 }
5969 arg4 = static_cast< int >(val4);
5970 }
5971 {
5972 if (!wxPyCheckForApp()) SWIG_fail;
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Bitmap_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5986 PyObject *resultobj = 0;
5987 wxBitmap *arg1 = (wxBitmap *) 0 ;
5988 bool result;
5989 void *argp1 = 0 ;
5990 int res1 = 0 ;
5991 PyObject *swig_obj[1] ;
5992
5993 if (!args) SWIG_fail;
5994 swig_obj[0] = args;
5995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5996 if (!SWIG_IsOK(res1)) {
5997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_Ok" "', expected argument " "1"" of type '" "wxBitmap *""'");
5998 }
5999 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6000 {
6001 result = (bool)(arg1)->Ok();
6002 if (PyErr_Occurred()) SWIG_fail;
6003 }
6004 {
6005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6006 }
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_Bitmap_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6014 PyObject *resultobj = 0;
6015 wxBitmap *arg1 = (wxBitmap *) 0 ;
6016 int result;
6017 void *argp1 = 0 ;
6018 int res1 = 0 ;
6019 PyObject *swig_obj[1] ;
6020
6021 if (!args) SWIG_fail;
6022 swig_obj[0] = args;
6023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6024 if (!SWIG_IsOK(res1)) {
6025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6026 }
6027 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6028 {
6029 result = (int)(arg1)->GetWidth();
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 resultobj = SWIG_From_int(static_cast< int >(result));
6033 return resultobj;
6034 fail:
6035 return NULL;
6036 }
6037
6038
6039 SWIGINTERN PyObject *_wrap_Bitmap_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6040 PyObject *resultobj = 0;
6041 wxBitmap *arg1 = (wxBitmap *) 0 ;
6042 int result;
6043 void *argp1 = 0 ;
6044 int res1 = 0 ;
6045 PyObject *swig_obj[1] ;
6046
6047 if (!args) SWIG_fail;
6048 swig_obj[0] = args;
6049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6050 if (!SWIG_IsOK(res1)) {
6051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6052 }
6053 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6054 {
6055 result = (int)(arg1)->GetHeight();
6056 if (PyErr_Occurred()) SWIG_fail;
6057 }
6058 resultobj = SWIG_From_int(static_cast< int >(result));
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 SWIGINTERN PyObject *_wrap_Bitmap_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6066 PyObject *resultobj = 0;
6067 wxBitmap *arg1 = (wxBitmap *) 0 ;
6068 int result;
6069 void *argp1 = 0 ;
6070 int res1 = 0 ;
6071 PyObject *swig_obj[1] ;
6072
6073 if (!args) SWIG_fail;
6074 swig_obj[0] = args;
6075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6076 if (!SWIG_IsOK(res1)) {
6077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6078 }
6079 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6080 {
6081 result = (int)(arg1)->GetDepth();
6082 if (PyErr_Occurred()) SWIG_fail;
6083 }
6084 resultobj = SWIG_From_int(static_cast< int >(result));
6085 return resultobj;
6086 fail:
6087 return NULL;
6088 }
6089
6090
6091 SWIGINTERN PyObject *_wrap_Bitmap_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6092 PyObject *resultobj = 0;
6093 wxBitmap *arg1 = (wxBitmap *) 0 ;
6094 wxSize result;
6095 void *argp1 = 0 ;
6096 int res1 = 0 ;
6097 PyObject *swig_obj[1] ;
6098
6099 if (!args) SWIG_fail;
6100 swig_obj[0] = args;
6101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6104 }
6105 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6106 {
6107 result = wxBitmap_GetSize(arg1);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 SWIGINTERN PyObject *_wrap_Bitmap_ConvertToImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6118 PyObject *resultobj = 0;
6119 wxBitmap *arg1 = (wxBitmap *) 0 ;
6120 SwigValueWrapper<wxImage > result;
6121 void *argp1 = 0 ;
6122 int res1 = 0 ;
6123 PyObject *swig_obj[1] ;
6124
6125 if (!args) SWIG_fail;
6126 swig_obj[0] = args;
6127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6128 if (!SWIG_IsOK(res1)) {
6129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_ConvertToImage" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6130 }
6131 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6132 {
6133 result = ((wxBitmap const *)arg1)->ConvertToImage();
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 SWIGINTERN PyObject *_wrap_Bitmap_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6144 PyObject *resultobj = 0;
6145 wxBitmap *arg1 = (wxBitmap *) 0 ;
6146 wxMask *result = 0 ;
6147 void *argp1 = 0 ;
6148 int res1 = 0 ;
6149 PyObject *swig_obj[1] ;
6150
6151 if (!args) SWIG_fail;
6152 swig_obj[0] = args;
6153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6154 if (!SWIG_IsOK(res1)) {
6155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetMask" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6156 }
6157 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6158 {
6159 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, 0 | 0 );
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_Bitmap_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj = 0;
6171 wxBitmap *arg1 = (wxBitmap *) 0 ;
6172 wxMask *arg2 = (wxMask *) 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 int res2 = 0 ;
6176 PyObject * obj0 = 0 ;
6177 PyObject * obj1 = 0 ;
6178 char * kwnames[] = {
6179 (char *) "self",(char *) "mask", NULL
6180 };
6181
6182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
6183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMask" "', expected argument " "1"" of type '" "wxBitmap *""'");
6186 }
6187 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6188 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
6189 if (!SWIG_IsOK(res2)) {
6190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetMask" "', expected argument " "2"" of type '" "wxMask *""'");
6191 }
6192 {
6193 (arg1)->SetMask(arg2);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_Py_Void();
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_Bitmap_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxBitmap *arg1 = (wxBitmap *) 0 ;
6206 wxColour *arg2 = 0 ;
6207 void *argp1 = 0 ;
6208 int res1 = 0 ;
6209 wxColour temp2 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "self",(char *) "colour", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) SWIG_fail;
6217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMaskColour" "', expected argument " "1"" of type '" "wxBitmap *""'");
6220 }
6221 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6222 {
6223 arg2 = &temp2;
6224 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6225 }
6226 {
6227 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
6228 if (PyErr_Occurred()) SWIG_fail;
6229 }
6230 resultobj = SWIG_Py_Void();
6231 return resultobj;
6232 fail:
6233 return NULL;
6234 }
6235
6236
6237 SWIGINTERN PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6238 PyObject *resultobj = 0;
6239 wxBitmap *arg1 = (wxBitmap *) 0 ;
6240 wxRect *arg2 = 0 ;
6241 SwigValueWrapper<wxBitmap > result;
6242 void *argp1 = 0 ;
6243 int res1 = 0 ;
6244 wxRect temp2 ;
6245 PyObject * obj0 = 0 ;
6246 PyObject * obj1 = 0 ;
6247 char * kwnames[] = {
6248 (char *) "self",(char *) "rect", NULL
6249 };
6250
6251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
6252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6253 if (!SWIG_IsOK(res1)) {
6254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSubBitmap" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6255 }
6256 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6257 {
6258 arg2 = &temp2;
6259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6260 }
6261 {
6262 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
6263 if (PyErr_Occurred()) SWIG_fail;
6264 }
6265 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 SWIGINTERN PyObject *_wrap_Bitmap_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6273 PyObject *resultobj = 0;
6274 wxBitmap *arg1 = (wxBitmap *) 0 ;
6275 wxString *arg2 = 0 ;
6276 wxBitmapType arg3 ;
6277 wxPalette *arg4 = (wxPalette *) NULL ;
6278 bool result;
6279 void *argp1 = 0 ;
6280 int res1 = 0 ;
6281 bool temp2 = false ;
6282 int val3 ;
6283 int ecode3 = 0 ;
6284 void *argp4 = 0 ;
6285 int res4 = 0 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 PyObject * obj2 = 0 ;
6289 PyObject * obj3 = 0 ;
6290 char * kwnames[] = {
6291 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
6292 };
6293
6294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6296 if (!SWIG_IsOK(res1)) {
6297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SaveFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6298 }
6299 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6300 {
6301 arg2 = wxString_in_helper(obj1);
6302 if (arg2 == NULL) SWIG_fail;
6303 temp2 = true;
6304 }
6305 ecode3 = SWIG_AsVal_int(obj2, &val3);
6306 if (!SWIG_IsOK(ecode3)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_SaveFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6308 }
6309 arg3 = static_cast< wxBitmapType >(val3);
6310 if (obj3) {
6311 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxPalette, 0 | 0 );
6312 if (!SWIG_IsOK(res4)) {
6313 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Bitmap_SaveFile" "', expected argument " "4"" of type '" "wxPalette *""'");
6314 }
6315 arg4 = reinterpret_cast< wxPalette * >(argp4);
6316 }
6317 {
6318 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3,arg4);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 {
6322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6323 }
6324 {
6325 if (temp2)
6326 delete arg2;
6327 }
6328 return resultobj;
6329 fail:
6330 {
6331 if (temp2)
6332 delete arg2;
6333 }
6334 return NULL;
6335 }
6336
6337
6338 SWIGINTERN PyObject *_wrap_Bitmap_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6339 PyObject *resultobj = 0;
6340 wxBitmap *arg1 = (wxBitmap *) 0 ;
6341 wxString *arg2 = 0 ;
6342 wxBitmapType arg3 ;
6343 bool result;
6344 void *argp1 = 0 ;
6345 int res1 = 0 ;
6346 bool temp2 = false ;
6347 int val3 ;
6348 int ecode3 = 0 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 PyObject * obj2 = 0 ;
6352 char * kwnames[] = {
6353 (char *) "self",(char *) "name",(char *) "type", NULL
6354 };
6355
6356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6358 if (!SWIG_IsOK(res1)) {
6359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_LoadFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6360 }
6361 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6362 {
6363 arg2 = wxString_in_helper(obj1);
6364 if (arg2 == NULL) SWIG_fail;
6365 temp2 = true;
6366 }
6367 ecode3 = SWIG_AsVal_int(obj2, &val3);
6368 if (!SWIG_IsOK(ecode3)) {
6369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6370 }
6371 arg3 = static_cast< wxBitmapType >(val3);
6372 {
6373 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 {
6377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6378 }
6379 {
6380 if (temp2)
6381 delete arg2;
6382 }
6383 return resultobj;
6384 fail:
6385 {
6386 if (temp2)
6387 delete arg2;
6388 }
6389 return NULL;
6390 }
6391
6392
6393 SWIGINTERN PyObject *_wrap_Bitmap_GetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6394 PyObject *resultobj = 0;
6395 wxBitmap *arg1 = (wxBitmap *) 0 ;
6396 wxPalette *result = 0 ;
6397 void *argp1 = 0 ;
6398 int res1 = 0 ;
6399 PyObject *swig_obj[1] ;
6400
6401 if (!args) SWIG_fail;
6402 swig_obj[0] = args;
6403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6404 if (!SWIG_IsOK(res1)) {
6405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetPalette" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6406 }
6407 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6408 {
6409 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
6410 if (PyErr_Occurred()) SWIG_fail;
6411 }
6412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, 0 | 0 );
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj = 0;
6421 wxBitmap *arg1 = (wxBitmap *) 0 ;
6422 wxIcon *arg2 = 0 ;
6423 bool result;
6424 void *argp1 = 0 ;
6425 int res1 = 0 ;
6426 void *argp2 = 0 ;
6427 int res2 = 0 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char * kwnames[] = {
6431 (char *) "self",(char *) "icon", NULL
6432 };
6433
6434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) SWIG_fail;
6435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6436 if (!SWIG_IsOK(res1)) {
6437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "1"" of type '" "wxBitmap *""'");
6438 }
6439 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
6441 if (!SWIG_IsOK(res2)) {
6442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6443 }
6444 if (!argp2) {
6445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6446 }
6447 arg2 = reinterpret_cast< wxIcon * >(argp2);
6448 {
6449 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 {
6453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6454 }
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Bitmap_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj = 0;
6463 wxBitmap *arg1 = (wxBitmap *) 0 ;
6464 int arg2 ;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 int val2 ;
6468 int ecode2 = 0 ;
6469 PyObject * obj0 = 0 ;
6470 PyObject * obj1 = 0 ;
6471 char * kwnames[] = {
6472 (char *) "self",(char *) "height", NULL
6473 };
6474
6475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6477 if (!SWIG_IsOK(res1)) {
6478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6479 }
6480 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6481 ecode2 = SWIG_AsVal_int(obj1, &val2);
6482 if (!SWIG_IsOK(ecode2)) {
6483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHeight" "', expected argument " "2"" of type '" "int""'");
6484 }
6485 arg2 = static_cast< int >(val2);
6486 {
6487 (arg1)->SetHeight(arg2);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = SWIG_Py_Void();
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 SWIGINTERN PyObject *_wrap_Bitmap_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj = 0;
6499 wxBitmap *arg1 = (wxBitmap *) 0 ;
6500 int arg2 ;
6501 void *argp1 = 0 ;
6502 int res1 = 0 ;
6503 int val2 ;
6504 int ecode2 = 0 ;
6505 PyObject * obj0 = 0 ;
6506 PyObject * obj1 = 0 ;
6507 char * kwnames[] = {
6508 (char *) "self",(char *) "width", NULL
6509 };
6510
6511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6513 if (!SWIG_IsOK(res1)) {
6514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6515 }
6516 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6517 ecode2 = SWIG_AsVal_int(obj1, &val2);
6518 if (!SWIG_IsOK(ecode2)) {
6519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetWidth" "', expected argument " "2"" of type '" "int""'");
6520 }
6521 arg2 = static_cast< int >(val2);
6522 {
6523 (arg1)->SetWidth(arg2);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_Py_Void();
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_Bitmap_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj = 0;
6535 wxBitmap *arg1 = (wxBitmap *) 0 ;
6536 int arg2 ;
6537 void *argp1 = 0 ;
6538 int res1 = 0 ;
6539 int val2 ;
6540 int ecode2 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "depth", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6551 }
6552 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6553 ecode2 = SWIG_AsVal_int(obj1, &val2);
6554 if (!SWIG_IsOK(ecode2)) {
6555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetDepth" "', expected argument " "2"" of type '" "int""'");
6556 }
6557 arg2 = static_cast< int >(val2);
6558 {
6559 (arg1)->SetDepth(arg2);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_Py_Void();
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Bitmap_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxBitmap *arg1 = (wxBitmap *) 0 ;
6572 wxSize *arg2 = 0 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 wxSize temp2 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "size", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6586 }
6587 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6588 {
6589 arg2 = &temp2;
6590 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6591 }
6592 {
6593 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_Py_Void();
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 SWIGINTERN PyObject *_wrap_Bitmap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6604 PyObject *resultobj = 0;
6605 wxBitmap *arg1 = (wxBitmap *) 0 ;
6606 wxBitmap *arg2 = (wxBitmap *) 0 ;
6607 bool result;
6608 void *argp1 = 0 ;
6609 int res1 = 0 ;
6610 void *argp2 = 0 ;
6611 int res2 = 0 ;
6612 PyObject * obj0 = 0 ;
6613 PyObject * obj1 = 0 ;
6614 char * kwnames[] = {
6615 (char *) "self",(char *) "other", NULL
6616 };
6617
6618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6620 if (!SWIG_IsOK(res1)) {
6621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___eq__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6622 }
6623 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6625 if (!SWIG_IsOK(res2)) {
6626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___eq__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6627 }
6628 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6629 {
6630 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 {
6634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6635 }
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_Bitmap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj = 0;
6644 wxBitmap *arg1 = (wxBitmap *) 0 ;
6645 wxBitmap *arg2 = (wxBitmap *) 0 ;
6646 bool result;
6647 void *argp1 = 0 ;
6648 int res1 = 0 ;
6649 void *argp2 = 0 ;
6650 int res2 = 0 ;
6651 PyObject * obj0 = 0 ;
6652 PyObject * obj1 = 0 ;
6653 char * kwnames[] = {
6654 (char *) "self",(char *) "other", NULL
6655 };
6656
6657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6659 if (!SWIG_IsOK(res1)) {
6660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___ne__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6661 }
6662 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6663 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6664 if (!SWIG_IsOK(res2)) {
6665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___ne__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6666 }
6667 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6668 {
6669 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 {
6673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6674 }
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *Bitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *obj;
6683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6684 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmap, SWIG_NewClientData(obj));
6685 return SWIG_Py_Void();
6686 }
6687
6688 SWIGINTERN PyObject *Bitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6689 return SWIG_Python_InitShadowInstance(args);
6690 }
6691
6692 SWIGINTERN PyObject *_wrap__BitmapFromBufferAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj = 0;
6694 int arg1 ;
6695 int arg2 ;
6696 buffer arg3 ;
6697 int arg4 ;
6698 buffer arg5 ;
6699 int arg6 ;
6700 wxBitmap *result = 0 ;
6701 int val1 ;
6702 int ecode1 = 0 ;
6703 int val2 ;
6704 int ecode2 = 0 ;
6705 Py_ssize_t temp3 ;
6706 Py_ssize_t temp5 ;
6707 PyObject * obj0 = 0 ;
6708 PyObject * obj1 = 0 ;
6709 PyObject * obj2 = 0 ;
6710 PyObject * obj3 = 0 ;
6711 char * kwnames[] = {
6712 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
6713 };
6714
6715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:_BitmapFromBufferAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6716 ecode1 = SWIG_AsVal_int(obj0, &val1);
6717 if (!SWIG_IsOK(ecode1)) {
6718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "1"" of type '" "int""'");
6719 }
6720 arg1 = static_cast< int >(val1);
6721 ecode2 = SWIG_AsVal_int(obj1, &val2);
6722 if (!SWIG_IsOK(ecode2)) {
6723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "2"" of type '" "int""'");
6724 }
6725 arg2 = static_cast< int >(val2);
6726 {
6727 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
6728 arg4 = (int)temp3;
6729 }
6730 {
6731 if (obj3 != Py_None) {
6732 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
6733 arg6 = (int)temp5;
6734 }
6735 }
6736 {
6737 result = (wxBitmap *)_BitmapFromBufferAlpha(arg1,arg2,arg3,arg4,arg5,arg6);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 SWIGINTERN PyObject *_wrap__BitmapFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6748 PyObject *resultobj = 0;
6749 int arg1 ;
6750 int arg2 ;
6751 buffer arg3 ;
6752 int arg4 ;
6753 wxBitmap *result = 0 ;
6754 int val1 ;
6755 int ecode1 = 0 ;
6756 int val2 ;
6757 int ecode2 = 0 ;
6758 Py_ssize_t temp3 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 PyObject * obj2 = 0 ;
6762 char * kwnames[] = {
6763 (char *) "width",(char *) "height",(char *) "data", NULL
6764 };
6765
6766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBuffer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6767 ecode1 = SWIG_AsVal_int(obj0, &val1);
6768 if (!SWIG_IsOK(ecode1)) {
6769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBuffer" "', expected argument " "1"" of type '" "int""'");
6770 }
6771 arg1 = static_cast< int >(val1);
6772 ecode2 = SWIG_AsVal_int(obj1, &val2);
6773 if (!SWIG_IsOK(ecode2)) {
6774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBuffer" "', expected argument " "2"" of type '" "int""'");
6775 }
6776 arg2 = static_cast< int >(val2);
6777 {
6778 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
6779 arg4 = (int)temp3;
6780 }
6781 {
6782 result = (wxBitmap *)_BitmapFromBuffer(arg1,arg2,arg3,arg4);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap__BitmapFromBufferRGBA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 int arg1 ;
6795 int arg2 ;
6796 buffer arg3 ;
6797 int arg4 ;
6798 wxBitmap *result = 0 ;
6799 int val1 ;
6800 int ecode1 = 0 ;
6801 int val2 ;
6802 int ecode2 = 0 ;
6803 Py_ssize_t temp3 ;
6804 PyObject * obj0 = 0 ;
6805 PyObject * obj1 = 0 ;
6806 PyObject * obj2 = 0 ;
6807 char * kwnames[] = {
6808 (char *) "width",(char *) "height",(char *) "data", NULL
6809 };
6810
6811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBufferRGBA",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6812 ecode1 = SWIG_AsVal_int(obj0, &val1);
6813 if (!SWIG_IsOK(ecode1)) {
6814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "1"" of type '" "int""'");
6815 }
6816 arg1 = static_cast< int >(val1);
6817 ecode2 = SWIG_AsVal_int(obj1, &val2);
6818 if (!SWIG_IsOK(ecode2)) {
6819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "2"" of type '" "int""'");
6820 }
6821 arg2 = static_cast< int >(val2);
6822 {
6823 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
6824 arg4 = (int)temp3;
6825 }
6826 {
6827 result = (wxBitmap *)_BitmapFromBufferRGBA(arg1,arg2,arg3,arg4);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_PixelDataBase_GetOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6840 wxPoint result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetOrigin" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6852 {
6853 result = ((wxPixelDataBase const *)arg1)->GetOrigin();
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_PixelDataBase_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6866 int result;
6867 void *argp1 = 0 ;
6868 int res1 = 0 ;
6869 PyObject *swig_obj[1] ;
6870
6871 if (!args) SWIG_fail;
6872 swig_obj[0] = args;
6873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6874 if (!SWIG_IsOK(res1)) {
6875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetWidth" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6876 }
6877 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6878 {
6879 result = (int)((wxPixelDataBase const *)arg1)->GetWidth();
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 resultobj = SWIG_From_int(static_cast< int >(result));
6883 return resultobj;
6884 fail:
6885 return NULL;
6886 }
6887
6888
6889 SWIGINTERN PyObject *_wrap_PixelDataBase_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6890 PyObject *resultobj = 0;
6891 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6892 int result;
6893 void *argp1 = 0 ;
6894 int res1 = 0 ;
6895 PyObject *swig_obj[1] ;
6896
6897 if (!args) SWIG_fail;
6898 swig_obj[0] = args;
6899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6900 if (!SWIG_IsOK(res1)) {
6901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetHeight" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6902 }
6903 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6904 {
6905 result = (int)((wxPixelDataBase const *)arg1)->GetHeight();
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 resultobj = SWIG_From_int(static_cast< int >(result));
6909 return resultobj;
6910 fail:
6911 return NULL;
6912 }
6913
6914
6915 SWIGINTERN PyObject *_wrap_PixelDataBase_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6916 PyObject *resultobj = 0;
6917 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6918 wxSize result;
6919 void *argp1 = 0 ;
6920 int res1 = 0 ;
6921 PyObject *swig_obj[1] ;
6922
6923 if (!args) SWIG_fail;
6924 swig_obj[0] = args;
6925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6926 if (!SWIG_IsOK(res1)) {
6927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetSize" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6928 }
6929 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6930 {
6931 result = ((wxPixelDataBase const *)arg1)->GetSize();
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 SWIGINTERN PyObject *_wrap_PixelDataBase_GetRowStride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6942 PyObject *resultobj = 0;
6943 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6944 int result;
6945 void *argp1 = 0 ;
6946 int res1 = 0 ;
6947 PyObject *swig_obj[1] ;
6948
6949 if (!args) SWIG_fail;
6950 swig_obj[0] = args;
6951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6952 if (!SWIG_IsOK(res1)) {
6953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetRowStride" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6954 }
6955 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6956 {
6957 result = (int)((wxPixelDataBase const *)arg1)->GetRowStride();
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_From_int(static_cast< int >(result));
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *PixelDataBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6968 PyObject *obj;
6969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6970 SWIG_TypeNewClientData(SWIGTYPE_p_wxPixelDataBase, SWIG_NewClientData(obj));
6971 return SWIG_Py_Void();
6972 }
6973
6974 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
6975 PyObject *resultobj = 0;
6976 wxBitmap *arg1 = 0 ;
6977 wxNativePixelData *result = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980
6981 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
6982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6985 }
6986 if (!argp1) {
6987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6988 }
6989 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6990 {
6991 result = (wxNativePixelData *)new wxNativePixelData(*arg1);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7002 PyObject *resultobj = 0;
7003 wxBitmap *arg1 = 0 ;
7004 wxRect *arg2 = 0 ;
7005 wxNativePixelData *result = 0 ;
7006 void *argp1 = 0 ;
7007 int res1 = 0 ;
7008 wxRect temp2 ;
7009
7010 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7014 }
7015 if (!argp1) {
7016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7017 }
7018 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7019 {
7020 arg2 = &temp2;
7021 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
7022 }
7023 {
7024 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxRect const &)*arg2);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7035 PyObject *resultobj = 0;
7036 wxBitmap *arg1 = 0 ;
7037 wxPoint *arg2 = 0 ;
7038 wxSize *arg3 = 0 ;
7039 wxNativePixelData *result = 0 ;
7040 void *argp1 = 0 ;
7041 int res1 = 0 ;
7042 wxPoint temp2 ;
7043 wxSize temp3 ;
7044
7045 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7047 if (!SWIG_IsOK(res1)) {
7048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7049 }
7050 if (!argp1) {
7051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7052 }
7053 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7054 {
7055 arg2 = &temp2;
7056 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7057 }
7058 {
7059 arg3 = &temp3;
7060 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7061 }
7062 {
7063 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 SWIGINTERN PyObject *_wrap_new_NativePixelData(PyObject *self, PyObject *args) {
7074 int argc;
7075 PyObject *argv[4];
7076
7077 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData",0,3,argv))) SWIG_fail;
7078 --argc;
7079 if (argc == 1) {
7080 return _wrap_new_NativePixelData__SWIG_0(self, argc, argv);
7081 }
7082 if (argc == 2) {
7083 return _wrap_new_NativePixelData__SWIG_1(self, argc, argv);
7084 }
7085 if (argc == 3) {
7086 return _wrap_new_NativePixelData__SWIG_2(self, argc, argv);
7087 }
7088
7089 fail:
7090 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData'");
7091 return NULL;
7092 }
7093
7094
7095 SWIGINTERN PyObject *_wrap_delete_NativePixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7096 PyObject *resultobj = 0;
7097 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 PyObject *swig_obj[1] ;
7101
7102 if (!args) SWIG_fail;
7103 swig_obj[0] = args;
7104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_DISOWN | 0 );
7105 if (!SWIG_IsOK(res1)) {
7106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7107 }
7108 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7109 {
7110 delete arg1;
7111
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 resultobj = SWIG_Py_Void();
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_NativePixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7122 PyObject *resultobj = 0;
7123 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7124 wxNativePixelData_Accessor result;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 PyObject *swig_obj[1] ;
7128
7129 if (!args) SWIG_fail;
7130 swig_obj[0] = args;
7131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7132 if (!SWIG_IsOK(res1)) {
7133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_GetPixels" "', expected argument " "1"" of type '" "wxNativePixelData const *""'");
7134 }
7135 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7136 {
7137 result = ((wxNativePixelData const *)arg1)->GetPixels();
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_NewPointerObj((new wxNativePixelData_Accessor(static_cast< const wxNativePixelData_Accessor& >(result))), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_OWN | 0 );
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_NativePixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7148 PyObject *resultobj = 0;
7149 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 PyObject *swig_obj[1] ;
7153
7154 if (!args) SWIG_fail;
7155 swig_obj[0] = args;
7156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7157 if (!SWIG_IsOK(res1)) {
7158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_UseAlpha" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7159 }
7160 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7161 {
7162 (arg1)->UseAlpha();
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 resultobj = SWIG_Py_Void();
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_NativePixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7173 PyObject *resultobj = 0;
7174 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7175 bool result;
7176 void *argp1 = 0 ;
7177 int res1 = 0 ;
7178 PyObject *swig_obj[1] ;
7179
7180 if (!args) SWIG_fail;
7181 swig_obj[0] = args;
7182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData___nonzero__" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7185 }
7186 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7187 {
7188 result = (bool)wxNativePixelData___nonzero__(arg1);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 {
7192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7193 }
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *NativePixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7201 PyObject *obj;
7202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7203 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData, SWIG_NewClientData(obj));
7204 return SWIG_Py_Void();
7205 }
7206
7207 SWIGINTERN PyObject *NativePixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7208 return SWIG_Python_InitShadowInstance(args);
7209 }
7210
7211 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7212 PyObject *resultobj = 0;
7213 wxNativePixelData *arg1 = 0 ;
7214 wxNativePixelData_Accessor *result = 0 ;
7215 void *argp1 = 0 ;
7216 int res1 = 0 ;
7217
7218 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxNativePixelData, 0 );
7220 if (!SWIG_IsOK(res1)) {
7221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7222 }
7223 if (!argp1) {
7224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7225 }
7226 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7227 {
7228 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7239 PyObject *resultobj = 0;
7240 wxBitmap *arg1 = 0 ;
7241 wxNativePixelData *arg2 = 0 ;
7242 wxNativePixelData_Accessor *result = 0 ;
7243 void *argp1 = 0 ;
7244 int res1 = 0 ;
7245 void *argp2 = 0 ;
7246 int res2 = 0 ;
7247
7248 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7250 if (!SWIG_IsOK(res1)) {
7251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7252 }
7253 if (!argp1) {
7254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7255 }
7256 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7257 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxNativePixelData, 0 );
7258 if (!SWIG_IsOK(res2)) {
7259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7260 }
7261 if (!argp2) {
7262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7263 }
7264 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7265 {
7266 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1,*arg2);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
7277 PyObject *resultobj = 0;
7278 wxNativePixelData_Accessor *result = 0 ;
7279
7280 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
7281 {
7282 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor();
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor(PyObject *self, PyObject *args) {
7293 int argc;
7294 PyObject *argv[3];
7295
7296 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData_Accessor",0,2,argv))) SWIG_fail;
7297 --argc;
7298 if (argc == 0) {
7299 return _wrap_new_NativePixelData_Accessor__SWIG_2(self, argc, argv);
7300 }
7301 if (argc == 1) {
7302 return _wrap_new_NativePixelData_Accessor__SWIG_0(self, argc, argv);
7303 }
7304 if (argc == 2) {
7305 return _wrap_new_NativePixelData_Accessor__SWIG_1(self, argc, argv);
7306 }
7307
7308 fail:
7309 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData_Accessor'");
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_delete_NativePixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7315 PyObject *resultobj = 0;
7316 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7317 void *argp1 = 0 ;
7318 int res1 = 0 ;
7319 PyObject *swig_obj[1] ;
7320
7321 if (!args) SWIG_fail;
7322 swig_obj[0] = args;
7323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
7324 if (!SWIG_IsOK(res1)) {
7325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7326 }
7327 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7328 {
7329 delete arg1;
7330
7331 if (PyErr_Occurred()) SWIG_fail;
7332 }
7333 resultobj = SWIG_Py_Void();
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7341 PyObject *resultobj = 0;
7342 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7343 wxNativePixelData *arg2 = 0 ;
7344 void *argp1 = 0 ;
7345 int res1 = 0 ;
7346 void *argp2 = 0 ;
7347 int res2 = 0 ;
7348 PyObject * obj0 = 0 ;
7349 PyObject * obj1 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "data", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativePixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7358 }
7359 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7360 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7361 if (!SWIG_IsOK(res2)) {
7362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7363 }
7364 if (!argp2) {
7365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7366 }
7367 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7368 {
7369 (arg1)->Reset((wxNativePixelData const &)*arg2);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 resultobj = SWIG_Py_Void();
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380 PyObject *resultobj = 0;
7381 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7382 bool result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject *swig_obj[1] ;
7386
7387 if (!args) SWIG_fail;
7388 swig_obj[0] = args;
7389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor const *""'");
7392 }
7393 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7394 {
7395 result = (bool)((wxNativePixelData_Accessor const *)arg1)->IsOk();
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 {
7399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7400 }
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7408 PyObject *resultobj = 0;
7409 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7419 }
7420 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7421 {
7422 wxNativePixelData_Accessor_nextPixel(arg1);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 resultobj = SWIG_Py_Void();
7426 return resultobj;
7427 fail:
7428 return NULL;
7429 }
7430
7431
7432 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj = 0;
7434 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7435 wxNativePixelData *arg2 = 0 ;
7436 int arg3 ;
7437 int arg4 ;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 void *argp2 = 0 ;
7441 int res2 = 0 ;
7442 int val3 ;
7443 int ecode3 = 0 ;
7444 int val4 ;
7445 int ecode4 = 0 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 PyObject * obj2 = 0 ;
7449 PyObject * obj3 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7458 }
7459 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7460 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7461 if (!SWIG_IsOK(res2)) {
7462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7463 }
7464 if (!argp2) {
7465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7466 }
7467 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7468 ecode3 = SWIG_AsVal_int(obj2, &val3);
7469 if (!SWIG_IsOK(ecode3)) {
7470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
7471 }
7472 arg3 = static_cast< int >(val3);
7473 ecode4 = SWIG_AsVal_int(obj3, &val4);
7474 if (!SWIG_IsOK(ecode4)) {
7475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
7476 }
7477 arg4 = static_cast< int >(val4);
7478 {
7479 (arg1)->Offset((wxNativePixelData const &)*arg2,arg3,arg4);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 resultobj = SWIG_Py_Void();
7483 return resultobj;
7484 fail:
7485 return NULL;
7486 }
7487
7488
7489 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7490 PyObject *resultobj = 0;
7491 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7492 wxNativePixelData *arg2 = 0 ;
7493 int arg3 ;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 void *argp2 = 0 ;
7497 int res2 = 0 ;
7498 int val3 ;
7499 int ecode3 = 0 ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 PyObject * obj2 = 0 ;
7503 char * kwnames[] = {
7504 (char *) "self",(char *) "data",(char *) "x", NULL
7505 };
7506
7507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7509 if (!SWIG_IsOK(res1)) {
7510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7511 }
7512 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7513 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7514 if (!SWIG_IsOK(res2)) {
7515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7516 }
7517 if (!argp2) {
7518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7519 }
7520 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7521 ecode3 = SWIG_AsVal_int(obj2, &val3);
7522 if (!SWIG_IsOK(ecode3)) {
7523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
7524 }
7525 arg3 = static_cast< int >(val3);
7526 {
7527 (arg1)->OffsetX((wxNativePixelData const &)*arg2,arg3);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = SWIG_Py_Void();
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj = 0;
7539 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7540 wxNativePixelData *arg2 = 0 ;
7541 int arg3 ;
7542 void *argp1 = 0 ;
7543 int res1 = 0 ;
7544 void *argp2 = 0 ;
7545 int res2 = 0 ;
7546 int val3 ;
7547 int ecode3 = 0 ;
7548 PyObject * obj0 = 0 ;
7549 PyObject * obj1 = 0 ;
7550 PyObject * obj2 = 0 ;
7551 char * kwnames[] = {
7552 (char *) "self",(char *) "data",(char *) "y", NULL
7553 };
7554
7555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7557 if (!SWIG_IsOK(res1)) {
7558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7559 }
7560 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7562 if (!SWIG_IsOK(res2)) {
7563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7564 }
7565 if (!argp2) {
7566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7567 }
7568 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7569 ecode3 = SWIG_AsVal_int(obj2, &val3);
7570 if (!SWIG_IsOK(ecode3)) {
7571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
7572 }
7573 arg3 = static_cast< int >(val3);
7574 {
7575 (arg1)->OffsetY((wxNativePixelData const &)*arg2,arg3);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 resultobj = SWIG_Py_Void();
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj = 0;
7587 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7588 wxNativePixelData *arg2 = 0 ;
7589 int arg3 ;
7590 int arg4 ;
7591 void *argp1 = 0 ;
7592 int res1 = 0 ;
7593 void *argp2 = 0 ;
7594 int res2 = 0 ;
7595 int val3 ;
7596 int ecode3 = 0 ;
7597 int val4 ;
7598 int ecode4 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 PyObject * obj2 = 0 ;
7602 PyObject * obj3 = 0 ;
7603 char * kwnames[] = {
7604 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7605 };
7606
7607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7609 if (!SWIG_IsOK(res1)) {
7610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7611 }
7612 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7614 if (!SWIG_IsOK(res2)) {
7615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7616 }
7617 if (!argp2) {
7618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7619 }
7620 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7621 ecode3 = SWIG_AsVal_int(obj2, &val3);
7622 if (!SWIG_IsOK(ecode3)) {
7623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
7624 }
7625 arg3 = static_cast< int >(val3);
7626 ecode4 = SWIG_AsVal_int(obj3, &val4);
7627 if (!SWIG_IsOK(ecode4)) {
7628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
7629 }
7630 arg4 = static_cast< int >(val4);
7631 {
7632 (arg1)->MoveTo((wxNativePixelData const &)*arg2,arg3,arg4);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 resultobj = SWIG_Py_Void();
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7645 byte arg2 ;
7646 byte arg3 ;
7647 byte arg4 ;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 unsigned char val2 ;
7651 int ecode2 = 0 ;
7652 unsigned char val3 ;
7653 int ecode3 = 0 ;
7654 unsigned char val4 ;
7655 int ecode4 = 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 PyObject * obj2 = 0 ;
7659 PyObject * obj3 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7668 }
7669 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7670 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
7671 if (!SWIG_IsOK(ecode2)) {
7672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
7673 }
7674 arg2 = static_cast< byte >(val2);
7675 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7676 if (!SWIG_IsOK(ecode3)) {
7677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
7678 }
7679 arg3 = static_cast< byte >(val3);
7680 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
7681 if (!SWIG_IsOK(ecode4)) {
7682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
7683 }
7684 arg4 = static_cast< byte >(val4);
7685 {
7686 wxNativePixelData_Accessor_Set(arg1,arg2,arg3,arg4);
7687 if (PyErr_Occurred()) SWIG_fail;
7688 }
7689 resultobj = SWIG_Py_Void();
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7697 PyObject *resultobj = 0;
7698 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7699 PyObject *result = 0 ;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 PyObject *swig_obj[1] ;
7703
7704 if (!args) SWIG_fail;
7705 swig_obj[0] = args;
7706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7707 if (!SWIG_IsOK(res1)) {
7708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7709 }
7710 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7711 {
7712 result = (PyObject *)wxNativePixelData_Accessor_Get(arg1);
7713 if (PyErr_Occurred()) SWIG_fail;
7714 }
7715 resultobj = result;
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 SWIGINTERN PyObject *NativePixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7723 PyObject *obj;
7724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7725 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_NewClientData(obj));
7726 return SWIG_Py_Void();
7727 }
7728
7729 SWIGINTERN PyObject *NativePixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7730 return SWIG_Python_InitShadowInstance(args);
7731 }
7732
7733 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7734 PyObject *resultobj = 0;
7735 wxBitmap *arg1 = 0 ;
7736 wxAlphaPixelData *result = 0 ;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739
7740 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7742 if (!SWIG_IsOK(res1)) {
7743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7744 }
7745 if (!argp1) {
7746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7747 }
7748 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7749 {
7750 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7761 PyObject *resultobj = 0;
7762 wxBitmap *arg1 = 0 ;
7763 wxRect *arg2 = 0 ;
7764 wxAlphaPixelData *result = 0 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 wxRect temp2 ;
7768
7769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7771 if (!SWIG_IsOK(res1)) {
7772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7773 }
7774 if (!argp1) {
7775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7776 }
7777 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7778 {
7779 arg2 = &temp2;
7780 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
7781 }
7782 {
7783 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxRect const &)*arg2);
7784 if (PyErr_Occurred()) SWIG_fail;
7785 }
7786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7794 PyObject *resultobj = 0;
7795 wxBitmap *arg1 = 0 ;
7796 wxPoint *arg2 = 0 ;
7797 wxSize *arg3 = 0 ;
7798 wxAlphaPixelData *result = 0 ;
7799 void *argp1 = 0 ;
7800 int res1 = 0 ;
7801 wxPoint temp2 ;
7802 wxSize temp3 ;
7803
7804 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7806 if (!SWIG_IsOK(res1)) {
7807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7808 }
7809 if (!argp1) {
7810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7811 }
7812 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7813 {
7814 arg2 = &temp2;
7815 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7816 }
7817 {
7818 arg3 = &temp3;
7819 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7820 }
7821 {
7822 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7823 if (PyErr_Occurred()) SWIG_fail;
7824 }
7825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7826 return resultobj;
7827 fail:
7828 return NULL;
7829 }
7830
7831
7832 SWIGINTERN PyObject *_wrap_new_AlphaPixelData(PyObject *self, PyObject *args) {
7833 int argc;
7834 PyObject *argv[4];
7835
7836 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData",0,3,argv))) SWIG_fail;
7837 --argc;
7838 if (argc == 1) {
7839 return _wrap_new_AlphaPixelData__SWIG_0(self, argc, argv);
7840 }
7841 if (argc == 2) {
7842 return _wrap_new_AlphaPixelData__SWIG_1(self, argc, argv);
7843 }
7844 if (argc == 3) {
7845 return _wrap_new_AlphaPixelData__SWIG_2(self, argc, argv);
7846 }
7847
7848 fail:
7849 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData'");
7850 return NULL;
7851 }
7852
7853
7854 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7855 PyObject *resultobj = 0;
7856 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7857 void *argp1 = 0 ;
7858 int res1 = 0 ;
7859 PyObject *swig_obj[1] ;
7860
7861 if (!args) SWIG_fail;
7862 swig_obj[0] = args;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_DISOWN | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7866 }
7867 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7868 {
7869 delete arg1;
7870
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 resultobj = SWIG_Py_Void();
7874 return resultobj;
7875 fail:
7876 return NULL;
7877 }
7878
7879
7880 SWIGINTERN PyObject *_wrap_AlphaPixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7881 PyObject *resultobj = 0;
7882 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7883 wxAlphaPixelData_Accessor result;
7884 void *argp1 = 0 ;
7885 int res1 = 0 ;
7886 PyObject *swig_obj[1] ;
7887
7888 if (!args) SWIG_fail;
7889 swig_obj[0] = args;
7890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7891 if (!SWIG_IsOK(res1)) {
7892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_GetPixels" "', expected argument " "1"" of type '" "wxAlphaPixelData const *""'");
7893 }
7894 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7895 {
7896 result = ((wxAlphaPixelData const *)arg1)->GetPixels();
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 resultobj = SWIG_NewPointerObj((new wxAlphaPixelData_Accessor(static_cast< const wxAlphaPixelData_Accessor& >(result))), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_OWN | 0 );
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *_wrap_AlphaPixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7907 PyObject *resultobj = 0;
7908 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7909 void *argp1 = 0 ;
7910 int res1 = 0 ;
7911 PyObject *swig_obj[1] ;
7912
7913 if (!args) SWIG_fail;
7914 swig_obj[0] = args;
7915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7916 if (!SWIG_IsOK(res1)) {
7917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_UseAlpha" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7918 }
7919 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7920 {
7921 (arg1)->UseAlpha();
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 resultobj = SWIG_Py_Void();
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 SWIGINTERN PyObject *_wrap_AlphaPixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7932 PyObject *resultobj = 0;
7933 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7934 bool result;
7935 void *argp1 = 0 ;
7936 int res1 = 0 ;
7937 PyObject *swig_obj[1] ;
7938
7939 if (!args) SWIG_fail;
7940 swig_obj[0] = args;
7941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7942 if (!SWIG_IsOK(res1)) {
7943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData___nonzero__" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7944 }
7945 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7946 {
7947 result = (bool)wxAlphaPixelData___nonzero__(arg1);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 {
7951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7952 }
7953 return resultobj;
7954 fail:
7955 return NULL;
7956 }
7957
7958
7959 SWIGINTERN PyObject *AlphaPixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7960 PyObject *obj;
7961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7962 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData, SWIG_NewClientData(obj));
7963 return SWIG_Py_Void();
7964 }
7965
7966 SWIGINTERN PyObject *AlphaPixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7967 return SWIG_Python_InitShadowInstance(args);
7968 }
7969
7970 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7971 PyObject *resultobj = 0;
7972 wxAlphaPixelData *arg1 = 0 ;
7973 wxAlphaPixelData_Accessor *result = 0 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976
7977 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxAlphaPixelData, 0 );
7979 if (!SWIG_IsOK(res1)) {
7980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
7981 }
7982 if (!argp1) {
7983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
7984 }
7985 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7986 {
7987 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
7991 return resultobj;
7992 fail:
7993 return NULL;
7994 }
7995
7996
7997 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7998 PyObject *resultobj = 0;
7999 wxBitmap *arg1 = 0 ;
8000 wxAlphaPixelData *arg2 = 0 ;
8001 wxAlphaPixelData_Accessor *result = 0 ;
8002 void *argp1 = 0 ;
8003 int res1 = 0 ;
8004 void *argp2 = 0 ;
8005 int res2 = 0 ;
8006
8007 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
8009 if (!SWIG_IsOK(res1)) {
8010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
8011 }
8012 if (!argp1) {
8013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
8014 }
8015 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8016 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 );
8017 if (!SWIG_IsOK(res2)) {
8018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
8019 }
8020 if (!argp2) {
8021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
8022 }
8023 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8024 {
8025 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1,*arg2);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8029 return resultobj;
8030 fail:
8031 return NULL;
8032 }
8033
8034
8035 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
8036 PyObject *resultobj = 0;
8037 wxAlphaPixelData_Accessor *result = 0 ;
8038
8039 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
8040 {
8041 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor();
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor(PyObject *self, PyObject *args) {
8052 int argc;
8053 PyObject *argv[3];
8054
8055 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData_Accessor",0,2,argv))) SWIG_fail;
8056 --argc;
8057 if (argc == 0) {
8058 return _wrap_new_AlphaPixelData_Accessor__SWIG_2(self, argc, argv);
8059 }
8060 if (argc == 1) {
8061 return _wrap_new_AlphaPixelData_Accessor__SWIG_0(self, argc, argv);
8062 }
8063 if (argc == 2) {
8064 return _wrap_new_AlphaPixelData_Accessor__SWIG_1(self, argc, argv);
8065 }
8066
8067 fail:
8068 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData_Accessor'");
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8074 PyObject *resultobj = 0;
8075 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8076 void *argp1 = 0 ;
8077 int res1 = 0 ;
8078 PyObject *swig_obj[1] ;
8079
8080 if (!args) SWIG_fail;
8081 swig_obj[0] = args;
8082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
8083 if (!SWIG_IsOK(res1)) {
8084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8085 }
8086 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8087 {
8088 delete arg1;
8089
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 resultobj = SWIG_Py_Void();
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8100 PyObject *resultobj = 0;
8101 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8102 wxAlphaPixelData *arg2 = 0 ;
8103 void *argp1 = 0 ;
8104 int res1 = 0 ;
8105 void *argp2 = 0 ;
8106 int res2 = 0 ;
8107 PyObject * obj0 = 0 ;
8108 PyObject * obj1 = 0 ;
8109 char * kwnames[] = {
8110 (char *) "self",(char *) "data", NULL
8111 };
8112
8113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AlphaPixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
8114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8117 }
8118 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8120 if (!SWIG_IsOK(res2)) {
8121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8122 }
8123 if (!argp2) {
8124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8125 }
8126 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8127 {
8128 (arg1)->Reset((wxAlphaPixelData const &)*arg2);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139 PyObject *resultobj = 0;
8140 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8141 bool result;
8142 void *argp1 = 0 ;
8143 int res1 = 0 ;
8144 PyObject *swig_obj[1] ;
8145
8146 if (!args) SWIG_fail;
8147 swig_obj[0] = args;
8148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8149 if (!SWIG_IsOK(res1)) {
8150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor const *""'");
8151 }
8152 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8153 {
8154 result = (bool)((wxAlphaPixelData_Accessor const *)arg1)->IsOk();
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 {
8158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8159 }
8160 return resultobj;
8161 fail:
8162 return NULL;
8163 }
8164
8165
8166 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8167 PyObject *resultobj = 0;
8168 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8169 void *argp1 = 0 ;
8170 int res1 = 0 ;
8171 PyObject *swig_obj[1] ;
8172
8173 if (!args) SWIG_fail;
8174 swig_obj[0] = args;
8175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8176 if (!SWIG_IsOK(res1)) {
8177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8178 }
8179 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8180 {
8181 wxAlphaPixelData_Accessor_nextPixel(arg1);
8182 if (PyErr_Occurred()) SWIG_fail;
8183 }
8184 resultobj = SWIG_Py_Void();
8185 return resultobj;
8186 fail:
8187 return NULL;
8188 }
8189
8190
8191 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8192 PyObject *resultobj = 0;
8193 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8194 wxAlphaPixelData *arg2 = 0 ;
8195 int arg3 ;
8196 int arg4 ;
8197 void *argp1 = 0 ;
8198 int res1 = 0 ;
8199 void *argp2 = 0 ;
8200 int res2 = 0 ;
8201 int val3 ;
8202 int ecode3 = 0 ;
8203 int val4 ;
8204 int ecode4 = 0 ;
8205 PyObject * obj0 = 0 ;
8206 PyObject * obj1 = 0 ;
8207 PyObject * obj2 = 0 ;
8208 PyObject * obj3 = 0 ;
8209 char * kwnames[] = {
8210 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8211 };
8212
8213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8215 if (!SWIG_IsOK(res1)) {
8216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8217 }
8218 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8220 if (!SWIG_IsOK(res2)) {
8221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8222 }
8223 if (!argp2) {
8224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8225 }
8226 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8227 ecode3 = SWIG_AsVal_int(obj2, &val3);
8228 if (!SWIG_IsOK(ecode3)) {
8229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
8230 }
8231 arg3 = static_cast< int >(val3);
8232 ecode4 = SWIG_AsVal_int(obj3, &val4);
8233 if (!SWIG_IsOK(ecode4)) {
8234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
8235 }
8236 arg4 = static_cast< int >(val4);
8237 {
8238 (arg1)->Offset((wxAlphaPixelData const &)*arg2,arg3,arg4);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_Py_Void();
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8251 wxAlphaPixelData *arg2 = 0 ;
8252 int arg3 ;
8253 void *argp1 = 0 ;
8254 int res1 = 0 ;
8255 void *argp2 = 0 ;
8256 int res2 = 0 ;
8257 int val3 ;
8258 int ecode3 = 0 ;
8259 PyObject * obj0 = 0 ;
8260 PyObject * obj1 = 0 ;
8261 PyObject * obj2 = 0 ;
8262 char * kwnames[] = {
8263 (char *) "self",(char *) "data",(char *) "x", NULL
8264 };
8265
8266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8268 if (!SWIG_IsOK(res1)) {
8269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8270 }
8271 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8273 if (!SWIG_IsOK(res2)) {
8274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8275 }
8276 if (!argp2) {
8277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8278 }
8279 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8280 ecode3 = SWIG_AsVal_int(obj2, &val3);
8281 if (!SWIG_IsOK(ecode3)) {
8282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
8283 }
8284 arg3 = static_cast< int >(val3);
8285 {
8286 (arg1)->OffsetX((wxAlphaPixelData const &)*arg2,arg3);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = SWIG_Py_Void();
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj = 0;
8298 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8299 wxAlphaPixelData *arg2 = 0 ;
8300 int arg3 ;
8301 void *argp1 = 0 ;
8302 int res1 = 0 ;
8303 void *argp2 = 0 ;
8304 int res2 = 0 ;
8305 int val3 ;
8306 int ecode3 = 0 ;
8307 PyObject * obj0 = 0 ;
8308 PyObject * obj1 = 0 ;
8309 PyObject * obj2 = 0 ;
8310 char * kwnames[] = {
8311 (char *) "self",(char *) "data",(char *) "y", NULL
8312 };
8313
8314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8316 if (!SWIG_IsOK(res1)) {
8317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8318 }
8319 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8321 if (!SWIG_IsOK(res2)) {
8322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8323 }
8324 if (!argp2) {
8325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8326 }
8327 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8328 ecode3 = SWIG_AsVal_int(obj2, &val3);
8329 if (!SWIG_IsOK(ecode3)) {
8330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
8331 }
8332 arg3 = static_cast< int >(val3);
8333 {
8334 (arg1)->OffsetY((wxAlphaPixelData const &)*arg2,arg3);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 resultobj = SWIG_Py_Void();
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8347 wxAlphaPixelData *arg2 = 0 ;
8348 int arg3 ;
8349 int arg4 ;
8350 void *argp1 = 0 ;
8351 int res1 = 0 ;
8352 void *argp2 = 0 ;
8353 int res2 = 0 ;
8354 int val3 ;
8355 int ecode3 = 0 ;
8356 int val4 ;
8357 int ecode4 = 0 ;
8358 PyObject * obj0 = 0 ;
8359 PyObject * obj1 = 0 ;
8360 PyObject * obj2 = 0 ;
8361 PyObject * obj3 = 0 ;
8362 char * kwnames[] = {
8363 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8364 };
8365
8366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8368 if (!SWIG_IsOK(res1)) {
8369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8370 }
8371 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8373 if (!SWIG_IsOK(res2)) {
8374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8375 }
8376 if (!argp2) {
8377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8378 }
8379 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8380 ecode3 = SWIG_AsVal_int(obj2, &val3);
8381 if (!SWIG_IsOK(ecode3)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
8383 }
8384 arg3 = static_cast< int >(val3);
8385 ecode4 = SWIG_AsVal_int(obj3, &val4);
8386 if (!SWIG_IsOK(ecode4)) {
8387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
8388 }
8389 arg4 = static_cast< int >(val4);
8390 {
8391 (arg1)->MoveTo((wxAlphaPixelData const &)*arg2,arg3,arg4);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_Py_Void();
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj = 0;
8403 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8404 byte arg2 ;
8405 byte arg3 ;
8406 byte arg4 ;
8407 byte arg5 ;
8408 void *argp1 = 0 ;
8409 int res1 = 0 ;
8410 unsigned char val2 ;
8411 int ecode2 = 0 ;
8412 unsigned char val3 ;
8413 int ecode3 = 0 ;
8414 unsigned char val4 ;
8415 int ecode4 = 0 ;
8416 unsigned char val5 ;
8417 int ecode5 = 0 ;
8418 PyObject * obj0 = 0 ;
8419 PyObject * obj1 = 0 ;
8420 PyObject * obj2 = 0 ;
8421 PyObject * obj3 = 0 ;
8422 PyObject * obj4 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:AlphaPixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8431 }
8432 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8433 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8434 if (!SWIG_IsOK(ecode2)) {
8435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
8436 }
8437 arg2 = static_cast< byte >(val2);
8438 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
8439 if (!SWIG_IsOK(ecode3)) {
8440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
8441 }
8442 arg3 = static_cast< byte >(val3);
8443 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
8444 if (!SWIG_IsOK(ecode4)) {
8445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
8446 }
8447 arg4 = static_cast< byte >(val4);
8448 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
8449 if (!SWIG_IsOK(ecode5)) {
8450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "5"" of type '" "byte""'");
8451 }
8452 arg5 = static_cast< byte >(val5);
8453 {
8454 wxAlphaPixelData_Accessor_Set(arg1,arg2,arg3,arg4,arg5);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_Py_Void();
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8465 PyObject *resultobj = 0;
8466 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8467 PyObject *result = 0 ;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 PyObject *swig_obj[1] ;
8471
8472 if (!args) SWIG_fail;
8473 swig_obj[0] = args;
8474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8475 if (!SWIG_IsOK(res1)) {
8476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8477 }
8478 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8479 {
8480 result = (PyObject *)wxAlphaPixelData_Accessor_Get(arg1);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = result;
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 SWIGINTERN PyObject *AlphaPixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8491 PyObject *obj;
8492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8493 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_NewClientData(obj));
8494 return SWIG_Py_Void();
8495 }
8496
8497 SWIGINTERN PyObject *AlphaPixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8498 return SWIG_Python_InitShadowInstance(args);
8499 }
8500
8501 SWIGINTERN PyObject *_wrap_new_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8502 PyObject *resultobj = 0;
8503 wxBitmap *arg1 = 0 ;
8504 wxColour const &arg2_defvalue = wxNullColour ;
8505 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
8506 wxMask *result = 0 ;
8507 void *argp1 = 0 ;
8508 int res1 = 0 ;
8509 wxColour temp2 ;
8510 PyObject * obj0 = 0 ;
8511 PyObject * obj1 = 0 ;
8512 char * kwnames[] = {
8513 (char *) "bitmap",(char *) "colour", NULL
8514 };
8515
8516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) SWIG_fail;
8517 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8518 if (!SWIG_IsOK(res1)) {
8519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8520 }
8521 if (!argp1) {
8522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8523 }
8524 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8525 if (obj1) {
8526 {
8527 arg2 = &temp2;
8528 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8529 }
8530 }
8531 {
8532 if (!wxPyCheckForApp()) SWIG_fail;
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, SWIG_POINTER_NEW | 0 );
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_delete_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxMask *arg1 = (wxMask *) 0 ;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 PyObject *swig_obj[1] ;
8551
8552 if (!args) SWIG_fail;
8553 swig_obj[0] = args;
8554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mask" "', expected argument " "1"" of type '" "wxMask *""'");
8557 }
8558 arg1 = reinterpret_cast< wxMask * >(argp1);
8559 {
8560 delete arg1;
8561
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 resultobj = SWIG_Py_Void();
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 SWIGINTERN PyObject *Mask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8572 PyObject *obj;
8573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8574 SWIG_TypeNewClientData(SWIGTYPE_p_wxMask, SWIG_NewClientData(obj));
8575 return SWIG_Py_Void();
8576 }
8577
8578 SWIGINTERN PyObject *Mask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8579 return SWIG_Python_InitShadowInstance(args);
8580 }
8581
8582 SWIGINTERN PyObject *_wrap_new_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj = 0;
8584 wxString *arg1 = 0 ;
8585 wxBitmapType arg2 ;
8586 int arg3 = (int) -1 ;
8587 int arg4 = (int) -1 ;
8588 wxIcon *result = 0 ;
8589 bool temp1 = false ;
8590 int val2 ;
8591 int ecode2 = 0 ;
8592 int val3 ;
8593 int ecode3 = 0 ;
8594 int val4 ;
8595 int ecode4 = 0 ;
8596 PyObject * obj0 = 0 ;
8597 PyObject * obj1 = 0 ;
8598 PyObject * obj2 = 0 ;
8599 PyObject * obj3 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8605 {
8606 arg1 = wxString_in_helper(obj0);
8607 if (arg1 == NULL) SWIG_fail;
8608 temp1 = true;
8609 }
8610 ecode2 = SWIG_AsVal_int(obj1, &val2);
8611 if (!SWIG_IsOK(ecode2)) {
8612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Icon" "', expected argument " "2"" of type '" "wxBitmapType""'");
8613 }
8614 arg2 = static_cast< wxBitmapType >(val2);
8615 if (obj2) {
8616 ecode3 = SWIG_AsVal_int(obj2, &val3);
8617 if (!SWIG_IsOK(ecode3)) {
8618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Icon" "', expected argument " "3"" of type '" "int""'");
8619 }
8620 arg3 = static_cast< int >(val3);
8621 }
8622 if (obj3) {
8623 ecode4 = SWIG_AsVal_int(obj3, &val4);
8624 if (!SWIG_IsOK(ecode4)) {
8625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Icon" "', expected argument " "4"" of type '" "int""'");
8626 }
8627 arg4 = static_cast< int >(val4);
8628 }
8629 {
8630 if (!wxPyCheckForApp()) SWIG_fail;
8631 PyThreadState* __tstate = wxPyBeginAllowThreads();
8632 result = (wxIcon *)new wxIcon((wxString const &)*arg1,arg2,arg3,arg4);
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_NEW | 0 );
8637 {
8638 if (temp1)
8639 delete arg1;
8640 }
8641 return resultobj;
8642 fail:
8643 {
8644 if (temp1)
8645 delete arg1;
8646 }
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_delete_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8652 PyObject *resultobj = 0;
8653 wxIcon *arg1 = (wxIcon *) 0 ;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 PyObject *swig_obj[1] ;
8657
8658 if (!args) SWIG_fail;
8659 swig_obj[0] = args;
8660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, SWIG_POINTER_DISOWN | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Icon" "', expected argument " "1"" of type '" "wxIcon *""'");
8663 }
8664 arg1 = reinterpret_cast< wxIcon * >(argp1);
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 delete arg1;
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_Py_Void();
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_new_EmptyIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8680 PyObject *resultobj = 0;
8681 wxIcon *result = 0 ;
8682
8683 if (!SWIG_Python_UnpackTuple(args,"new_EmptyIcon",0,0,0)) SWIG_fail;
8684 {
8685 if (!wxPyCheckForApp()) SWIG_fail;
8686 PyThreadState* __tstate = wxPyBeginAllowThreads();
8687 result = (wxIcon *)new wxIcon();
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 SWIGINTERN PyObject *_wrap_new_IconFromLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8699 PyObject *resultobj = 0;
8700 wxIconLocation *arg1 = 0 ;
8701 wxIcon *result = 0 ;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 PyObject * obj0 = 0 ;
8705 char * kwnames[] = {
8706 (char *) "loc", NULL
8707 };
8708
8709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) SWIG_fail;
8710 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIconLocation, 0 | 0);
8711 if (!SWIG_IsOK(res1)) {
8712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8713 }
8714 if (!argp1) {
8715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8716 }
8717 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
8718 {
8719 if (!wxPyCheckForApp()) SWIG_fail;
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_new_IconFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = 0;
8734 wxBitmap *arg1 = 0 ;
8735 wxIcon *result = 0 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 PyObject * obj0 = 0 ;
8739 char * kwnames[] = {
8740 (char *) "bmp", NULL
8741 };
8742
8743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) SWIG_fail;
8744 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8745 if (!SWIG_IsOK(res1)) {
8746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8747 }
8748 if (!argp1) {
8749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8750 }
8751 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8752 {
8753 if (!wxPyCheckForApp()) SWIG_fail;
8754 PyThreadState* __tstate = wxPyBeginAllowThreads();
8755 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_new_IconFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 PyObject *arg1 = (PyObject *) 0 ;
8769 wxIcon *result = 0 ;
8770 PyObject * obj0 = 0 ;
8771 char * kwnames[] = {
8772 (char *) "listOfStrings", NULL
8773 };
8774
8775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) SWIG_fail;
8776 arg1 = obj0;
8777 {
8778 if (!wxPyCheckForApp()) SWIG_fail;
8779 PyThreadState* __tstate = wxPyBeginAllowThreads();
8780 result = (wxIcon *)new_wxIcon(arg1);
8781 wxPyEndAllowThreads(__tstate);
8782 if (PyErr_Occurred()) SWIG_fail;
8783 }
8784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8785 return resultobj;
8786 fail:
8787 return NULL;
8788 }
8789
8790
8791 SWIGINTERN PyObject *_wrap_Icon_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8792 PyObject *resultobj = 0;
8793 wxIcon *arg1 = (wxIcon *) 0 ;
8794 bool result;
8795 void *argp1 = 0 ;
8796 int res1 = 0 ;
8797 PyObject *swig_obj[1] ;
8798
8799 if (!args) SWIG_fail;
8800 swig_obj[0] = args;
8801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8802 if (!SWIG_IsOK(res1)) {
8803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_Ok" "', expected argument " "1"" of type '" "wxIcon *""'");
8804 }
8805 arg1 = reinterpret_cast< wxIcon * >(argp1);
8806 {
8807 PyThreadState* __tstate = wxPyBeginAllowThreads();
8808 result = (bool)(arg1)->Ok();
8809 wxPyEndAllowThreads(__tstate);
8810 if (PyErr_Occurred()) SWIG_fail;
8811 }
8812 {
8813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8814 }
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 SWIGINTERN PyObject *_wrap_Icon_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8822 PyObject *resultobj = 0;
8823 wxIcon *arg1 = (wxIcon *) 0 ;
8824 int result;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 PyObject *swig_obj[1] ;
8828
8829 if (!args) SWIG_fail;
8830 swig_obj[0] = args;
8831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8832 if (!SWIG_IsOK(res1)) {
8833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
8834 }
8835 arg1 = reinterpret_cast< wxIcon * >(argp1);
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = (int)(arg1)->GetWidth();
8839 wxPyEndAllowThreads(__tstate);
8840 if (PyErr_Occurred()) SWIG_fail;
8841 }
8842 resultobj = SWIG_From_int(static_cast< int >(result));
8843 return resultobj;
8844 fail:
8845 return NULL;
8846 }
8847
8848
8849 SWIGINTERN PyObject *_wrap_Icon_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8850 PyObject *resultobj = 0;
8851 wxIcon *arg1 = (wxIcon *) 0 ;
8852 int result;
8853 void *argp1 = 0 ;
8854 int res1 = 0 ;
8855 PyObject *swig_obj[1] ;
8856
8857 if (!args) SWIG_fail;
8858 swig_obj[0] = args;
8859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8860 if (!SWIG_IsOK(res1)) {
8861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
8862 }
8863 arg1 = reinterpret_cast< wxIcon * >(argp1);
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (int)(arg1)->GetHeight();
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 resultobj = SWIG_From_int(static_cast< int >(result));
8871 return resultobj;
8872 fail:
8873 return NULL;
8874 }
8875
8876
8877 SWIGINTERN PyObject *_wrap_Icon_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8878 PyObject *resultobj = 0;
8879 wxIcon *arg1 = (wxIcon *) 0 ;
8880 int result;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 PyObject *swig_obj[1] ;
8884
8885 if (!args) SWIG_fail;
8886 swig_obj[0] = args;
8887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
8890 }
8891 arg1 = reinterpret_cast< wxIcon * >(argp1);
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 result = (int)(arg1)->GetDepth();
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 resultobj = SWIG_From_int(static_cast< int >(result));
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Icon_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxIcon *arg1 = (wxIcon *) 0 ;
8908 int arg2 ;
8909 void *argp1 = 0 ;
8910 int res1 = 0 ;
8911 int val2 ;
8912 int ecode2 = 0 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "self",(char *) "w", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
8923 }
8924 arg1 = reinterpret_cast< wxIcon * >(argp1);
8925 ecode2 = SWIG_AsVal_int(obj1, &val2);
8926 if (!SWIG_IsOK(ecode2)) {
8927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetWidth" "', expected argument " "2"" of type '" "int""'");
8928 }
8929 arg2 = static_cast< int >(val2);
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 (arg1)->SetWidth(arg2);
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 resultobj = SWIG_Py_Void();
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 SWIGINTERN PyObject *_wrap_Icon_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj = 0;
8945 wxIcon *arg1 = (wxIcon *) 0 ;
8946 int arg2 ;
8947 void *argp1 = 0 ;
8948 int res1 = 0 ;
8949 int val2 ;
8950 int ecode2 = 0 ;
8951 PyObject * obj0 = 0 ;
8952 PyObject * obj1 = 0 ;
8953 char * kwnames[] = {
8954 (char *) "self",(char *) "h", NULL
8955 };
8956
8957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
8958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8959 if (!SWIG_IsOK(res1)) {
8960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
8961 }
8962 arg1 = reinterpret_cast< wxIcon * >(argp1);
8963 ecode2 = SWIG_AsVal_int(obj1, &val2);
8964 if (!SWIG_IsOK(ecode2)) {
8965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHeight" "', expected argument " "2"" of type '" "int""'");
8966 }
8967 arg2 = static_cast< int >(val2);
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 (arg1)->SetHeight(arg2);
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 resultobj = SWIG_Py_Void();
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 SWIGINTERN PyObject *_wrap_Icon_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj = 0;
8983 wxIcon *arg1 = (wxIcon *) 0 ;
8984 int arg2 ;
8985 void *argp1 = 0 ;
8986 int res1 = 0 ;
8987 int val2 ;
8988 int ecode2 = 0 ;
8989 PyObject * obj0 = 0 ;
8990 PyObject * obj1 = 0 ;
8991 char * kwnames[] = {
8992 (char *) "self",(char *) "d", NULL
8993 };
8994
8995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
8996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
8999 }
9000 arg1 = reinterpret_cast< wxIcon * >(argp1);
9001 ecode2 = SWIG_AsVal_int(obj1, &val2);
9002 if (!SWIG_IsOK(ecode2)) {
9003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetDepth" "', expected argument " "2"" of type '" "int""'");
9004 }
9005 arg2 = static_cast< int >(val2);
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 (arg1)->SetDepth(arg2);
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 resultobj = SWIG_Py_Void();
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_Icon_CopyFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = 0;
9021 wxIcon *arg1 = (wxIcon *) 0 ;
9022 wxBitmap *arg2 = 0 ;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 void *argp2 = 0 ;
9026 int res2 = 0 ;
9027 PyObject * obj0 = 0 ;
9028 PyObject * obj1 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "self",(char *) "bmp", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
9034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9035 if (!SWIG_IsOK(res1)) {
9036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_CopyFromBitmap" "', expected argument " "1"" of type '" "wxIcon *""'");
9037 }
9038 arg1 = reinterpret_cast< wxIcon * >(argp1);
9039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
9040 if (!SWIG_IsOK(res2)) {
9041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9042 }
9043 if (!argp2) {
9044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9045 }
9046 arg2 = reinterpret_cast< wxBitmap * >(argp2);
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_Py_Void();
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 SWIGINTERN PyObject *Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061 PyObject *obj;
9062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9063 SWIG_TypeNewClientData(SWIGTYPE_p_wxIcon, SWIG_NewClientData(obj));
9064 return SWIG_Py_Void();
9065 }
9066
9067 SWIGINTERN PyObject *Icon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9068 return SWIG_Python_InitShadowInstance(args);
9069 }
9070
9071 SWIGINTERN PyObject *_wrap_new_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj = 0;
9073 wxString *arg1 = (wxString *) &wxPyEmptyString ;
9074 int arg2 = (int) 0 ;
9075 wxIconLocation *result = 0 ;
9076 bool temp1 = false ;
9077 int val2 ;
9078 int ecode2 = 0 ;
9079 PyObject * obj0 = 0 ;
9080 PyObject * obj1 = 0 ;
9081 char * kwnames[] = {
9082 (char *) "filename",(char *) "num", NULL
9083 };
9084
9085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) SWIG_fail;
9086 if (obj0) {
9087 {
9088 arg1 = wxString_in_helper(obj0);
9089 if (arg1 == NULL) SWIG_fail;
9090 temp1 = true;
9091 }
9092 }
9093 if (obj1) {
9094 ecode2 = SWIG_AsVal_int(obj1, &val2);
9095 if (!SWIG_IsOK(ecode2)) {
9096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconLocation" "', expected argument " "2"" of type '" "int""'");
9097 }
9098 arg2 = static_cast< int >(val2);
9099 }
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconLocation, SWIG_POINTER_NEW | 0 );
9107 {
9108 if (temp1)
9109 delete arg1;
9110 }
9111 return resultobj;
9112 fail:
9113 {
9114 if (temp1)
9115 delete arg1;
9116 }
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *_wrap_delete_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *resultobj = 0;
9123 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9124 void *argp1 = 0 ;
9125 int res1 = 0 ;
9126 PyObject *swig_obj[1] ;
9127
9128 if (!args) SWIG_fail;
9129 swig_obj[0] = args;
9130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, SWIG_POINTER_DISOWN | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconLocation" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9133 }
9134 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 delete arg1;
9138
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 resultobj = SWIG_Py_Void();
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 SWIGINTERN PyObject *_wrap_IconLocation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9150 PyObject *resultobj = 0;
9151 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9152 bool result;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 PyObject *swig_obj[1] ;
9156
9157 if (!args) SWIG_fail;
9158 swig_obj[0] = args;
9159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_IsOk" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9162 }
9163 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 result = (bool)((wxIconLocation const *)arg1)->IsOk();
9167 wxPyEndAllowThreads(__tstate);
9168 if (PyErr_Occurred()) SWIG_fail;
9169 }
9170 {
9171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9172 }
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *_wrap_IconLocation_SetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj = 0;
9181 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9182 wxString *arg2 = 0 ;
9183 void *argp1 = 0 ;
9184 int res1 = 0 ;
9185 bool temp2 = false ;
9186 PyObject * obj0 = 0 ;
9187 PyObject * obj1 = 0 ;
9188 char * kwnames[] = {
9189 (char *) "self",(char *) "filename", NULL
9190 };
9191
9192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) SWIG_fail;
9193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9194 if (!SWIG_IsOK(res1)) {
9195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetFileName" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9196 }
9197 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9198 {
9199 arg2 = wxString_in_helper(obj1);
9200 if (arg2 == NULL) SWIG_fail;
9201 temp2 = true;
9202 }
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 (arg1)->SetFileName((wxString const &)*arg2);
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_Py_Void();
9210 {
9211 if (temp2)
9212 delete arg2;
9213 }
9214 return resultobj;
9215 fail:
9216 {
9217 if (temp2)
9218 delete arg2;
9219 }
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_IconLocation_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9225 PyObject *resultobj = 0;
9226 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9227 wxString *result = 0 ;
9228 void *argp1 = 0 ;
9229 int res1 = 0 ;
9230 PyObject *swig_obj[1] ;
9231
9232 if (!args) SWIG_fail;
9233 swig_obj[0] = args;
9234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9235 if (!SWIG_IsOK(res1)) {
9236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetFileName" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9237 }
9238 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9239 {
9240 PyThreadState* __tstate = wxPyBeginAllowThreads();
9241 {
9242 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
9243 result = (wxString *) &_result_ref;
9244 }
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 {
9249 #if wxUSE_UNICODE
9250 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9251 #else
9252 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9253 #endif
9254 }
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 SWIGINTERN PyObject *_wrap_IconLocation_SetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj = 0;
9263 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9264 int arg2 ;
9265 void *argp1 = 0 ;
9266 int res1 = 0 ;
9267 int val2 ;
9268 int ecode2 = 0 ;
9269 PyObject * obj0 = 0 ;
9270 PyObject * obj1 = 0 ;
9271 char * kwnames[] = {
9272 (char *) "self",(char *) "num", NULL
9273 };
9274
9275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) SWIG_fail;
9276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9277 if (!SWIG_IsOK(res1)) {
9278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9279 }
9280 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9281 ecode2 = SWIG_AsVal_int(obj1, &val2);
9282 if (!SWIG_IsOK(ecode2)) {
9283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IconLocation_SetIndex" "', expected argument " "2"" of type '" "int""'");
9284 }
9285 arg2 = static_cast< int >(val2);
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 wxIconLocation_SetIndex(arg1,arg2);
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_Py_Void();
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_IconLocation_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9300 PyObject *resultobj = 0;
9301 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9302 int result;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9312 }
9313 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 result = (int)wxIconLocation_GetIndex(arg1);
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_From_int(static_cast< int >(result));
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *IconLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *obj;
9329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9330 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconLocation, SWIG_NewClientData(obj));
9331 return SWIG_Py_Void();
9332 }
9333
9334 SWIGINTERN PyObject *IconLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 return SWIG_Python_InitShadowInstance(args);
9336 }
9337
9338 SWIGINTERN PyObject *_wrap_new_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *resultobj = 0;
9340 wxIconBundle *result = 0 ;
9341
9342 if (!SWIG_Python_UnpackTuple(args,"new_IconBundle",0,0,0)) SWIG_fail;
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (wxIconBundle *)new wxIconBundle();
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_NEW | 0 );
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 SWIGINTERN PyObject *_wrap_new_IconBundleFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9357 PyObject *resultobj = 0;
9358 wxString *arg1 = 0 ;
9359 long arg2 ;
9360 wxIconBundle *result = 0 ;
9361 bool temp1 = false ;
9362 long val2 ;
9363 int ecode2 = 0 ;
9364 PyObject * obj0 = 0 ;
9365 PyObject * obj1 = 0 ;
9366 char * kwnames[] = {
9367 (char *) "file",(char *) "type", NULL
9368 };
9369
9370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) SWIG_fail;
9371 {
9372 arg1 = wxString_in_helper(obj0);
9373 if (arg1 == NULL) SWIG_fail;
9374 temp1 = true;
9375 }
9376 ecode2 = SWIG_AsVal_long(obj1, &val2);
9377 if (!SWIG_IsOK(ecode2)) {
9378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconBundleFromFile" "', expected argument " "2"" of type '" "long""'");
9379 }
9380 arg2 = static_cast< long >(val2);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9388 {
9389 if (temp1)
9390 delete arg1;
9391 }
9392 return resultobj;
9393 fail:
9394 {
9395 if (temp1)
9396 delete arg1;
9397 }
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *_wrap_new_IconBundleFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = 0;
9404 wxIcon *arg1 = 0 ;
9405 wxIconBundle *result = 0 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 PyObject * obj0 = 0 ;
9409 char * kwnames[] = {
9410 (char *) "icon", NULL
9411 };
9412
9413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) SWIG_fail;
9414 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
9415 if (!SWIG_IsOK(res1)) {
9416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9417 }
9418 if (!argp1) {
9419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9420 }
9421 arg1 = reinterpret_cast< wxIcon * >(argp1);
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
9425 wxPyEndAllowThreads(__tstate);
9426 if (PyErr_Occurred()) SWIG_fail;
9427 }
9428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 SWIGINTERN PyObject *_wrap_delete_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9436 PyObject *resultobj = 0;
9437 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9438 void *argp1 = 0 ;
9439 int res1 = 0 ;
9440 PyObject *swig_obj[1] ;
9441
9442 if (!args) SWIG_fail;
9443 swig_obj[0] = args;
9444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconBundle, SWIG_POINTER_DISOWN | 0 );
9445 if (!SWIG_IsOK(res1)) {
9446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconBundle" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9447 }
9448 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9449 {
9450 PyThreadState* __tstate = wxPyBeginAllowThreads();
9451 delete arg1;
9452
9453 wxPyEndAllowThreads(__tstate);
9454 if (PyErr_Occurred()) SWIG_fail;
9455 }
9456 resultobj = SWIG_Py_Void();
9457 return resultobj;
9458 fail:
9459 return NULL;
9460 }
9461
9462
9463 SWIGINTERN PyObject *_wrap_IconBundle_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9464 PyObject *resultobj = 0;
9465 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9466 wxIcon *arg2 = 0 ;
9467 void *argp1 = 0 ;
9468 int res1 = 0 ;
9469 void *argp2 = 0 ;
9470 int res2 = 0 ;
9471 PyObject * obj0 = 0 ;
9472 PyObject * obj1 = 0 ;
9473 char * kwnames[] = {
9474 (char *) "self",(char *) "icon", NULL
9475 };
9476
9477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9479 if (!SWIG_IsOK(res1)) {
9480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIcon" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9481 }
9482 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
9484 if (!SWIG_IsOK(res2)) {
9485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9486 }
9487 if (!argp2) {
9488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9489 }
9490 arg2 = reinterpret_cast< wxIcon * >(argp2);
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 (arg1)->AddIcon((wxIcon const &)*arg2);
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 resultobj = SWIG_Py_Void();
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9507 wxString *arg2 = 0 ;
9508 long arg3 ;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 bool temp2 = false ;
9512 long val3 ;
9513 int ecode3 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 PyObject * obj2 = 0 ;
9517 char * kwnames[] = {
9518 (char *) "self",(char *) "file",(char *) "type", NULL
9519 };
9520
9521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9523 if (!SWIG_IsOK(res1)) {
9524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9525 }
9526 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9527 {
9528 arg2 = wxString_in_helper(obj1);
9529 if (arg2 == NULL) SWIG_fail;
9530 temp2 = true;
9531 }
9532 ecode3 = SWIG_AsVal_long(obj2, &val3);
9533 if (!SWIG_IsOK(ecode3)) {
9534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "3"" of type '" "long""'");
9535 }
9536 arg3 = static_cast< long >(val3);
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 (arg1)->AddIcon((wxString const &)*arg2,arg3);
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_Py_Void();
9544 {
9545 if (temp2)
9546 delete arg2;
9547 }
9548 return resultobj;
9549 fail:
9550 {
9551 if (temp2)
9552 delete arg2;
9553 }
9554 return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_IconBundle_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9561 wxSize *arg2 = 0 ;
9562 wxIcon *result = 0 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 wxSize temp2 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "size", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_GetIcon" "', expected argument " "1"" of type '" "wxIconBundle const *""'");
9576 }
9577 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9578 {
9579 arg2 = &temp2;
9580 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 {
9585 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
9586 result = (wxIcon *) &_result_ref;
9587 }
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 {
9592 wxIcon* resultptr = new wxIcon(*result);
9593 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
9594 }
9595 return resultobj;
9596 fail:
9597 return NULL;
9598 }
9599
9600
9601 SWIGINTERN PyObject *IconBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9602 PyObject *obj;
9603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9604 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconBundle, SWIG_NewClientData(obj));
9605 return SWIG_Py_Void();
9606 }
9607
9608 SWIGINTERN PyObject *IconBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 return SWIG_Python_InitShadowInstance(args);
9610 }
9611
9612 SWIGINTERN PyObject *_wrap_new_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9613 PyObject *resultobj = 0;
9614 wxString *arg1 = 0 ;
9615 long arg2 ;
9616 int arg3 = (int) 0 ;
9617 int arg4 = (int) 0 ;
9618 wxCursor *result = 0 ;
9619 bool temp1 = false ;
9620 long val2 ;
9621 int ecode2 = 0 ;
9622 int val3 ;
9623 int ecode3 = 0 ;
9624 int val4 ;
9625 int ecode4 = 0 ;
9626 PyObject * obj0 = 0 ;
9627 PyObject * obj1 = 0 ;
9628 PyObject * obj2 = 0 ;
9629 PyObject * obj3 = 0 ;
9630 char * kwnames[] = {
9631 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
9632 };
9633
9634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9635 {
9636 arg1 = wxString_in_helper(obj0);
9637 if (arg1 == NULL) SWIG_fail;
9638 temp1 = true;
9639 }
9640 ecode2 = SWIG_AsVal_long(obj1, &val2);
9641 if (!SWIG_IsOK(ecode2)) {
9642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cursor" "', expected argument " "2"" of type '" "long""'");
9643 }
9644 arg2 = static_cast< long >(val2);
9645 if (obj2) {
9646 ecode3 = SWIG_AsVal_int(obj2, &val3);
9647 if (!SWIG_IsOK(ecode3)) {
9648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cursor" "', expected argument " "3"" of type '" "int""'");
9649 }
9650 arg3 = static_cast< int >(val3);
9651 }
9652 if (obj3) {
9653 ecode4 = SWIG_AsVal_int(obj3, &val4);
9654 if (!SWIG_IsOK(ecode4)) {
9655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cursor" "', expected argument " "4"" of type '" "int""'");
9656 }
9657 arg4 = static_cast< int >(val4);
9658 }
9659 {
9660 if (!wxPyCheckForApp()) SWIG_fail;
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_NEW | 0 );
9667 {
9668 if (temp1)
9669 delete arg1;
9670 }
9671 return resultobj;
9672 fail:
9673 {
9674 if (temp1)
9675 delete arg1;
9676 }
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_delete_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 PyObject *resultobj = 0;
9683 wxCursor *arg1 = (wxCursor *) 0 ;
9684 void *argp1 = 0 ;
9685 int res1 = 0 ;
9686 PyObject *swig_obj[1] ;
9687
9688 if (!args) SWIG_fail;
9689 swig_obj[0] = args;
9690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, SWIG_POINTER_DISOWN | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9693 }
9694 arg1 = reinterpret_cast< wxCursor * >(argp1);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 delete arg1;
9698
9699 wxPyEndAllowThreads(__tstate);
9700 if (PyErr_Occurred()) SWIG_fail;
9701 }
9702 resultobj = SWIG_Py_Void();
9703 return resultobj;
9704 fail:
9705 return NULL;
9706 }
9707
9708
9709 SWIGINTERN PyObject *_wrap_new_StockCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9710 PyObject *resultobj = 0;
9711 int arg1 ;
9712 wxCursor *result = 0 ;
9713 int val1 ;
9714 int ecode1 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 char * kwnames[] = {
9717 (char *) "id", NULL
9718 };
9719
9720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) SWIG_fail;
9721 ecode1 = SWIG_AsVal_int(obj0, &val1);
9722 if (!SWIG_IsOK(ecode1)) {
9723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StockCursor" "', expected argument " "1"" of type '" "int""'");
9724 }
9725 arg1 = static_cast< int >(val1);
9726 {
9727 if (!wxPyCheckForApp()) SWIG_fail;
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 result = (wxCursor *)new wxCursor(arg1);
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_new_CursorFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = 0;
9742 wxImage *arg1 = 0 ;
9743 wxCursor *result = 0 ;
9744 void *argp1 = 0 ;
9745 int res1 = 0 ;
9746 PyObject * obj0 = 0 ;
9747 char * kwnames[] = {
9748 (char *) "image", NULL
9749 };
9750
9751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) SWIG_fail;
9752 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
9753 if (!SWIG_IsOK(res1)) {
9754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
9755 }
9756 if (!argp1) {
9757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
9758 }
9759 arg1 = reinterpret_cast< wxImage * >(argp1);
9760 {
9761 if (!wxPyCheckForApp()) SWIG_fail;
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
9764 wxPyEndAllowThreads(__tstate);
9765 if (PyErr_Occurred()) SWIG_fail;
9766 }
9767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
9768 return resultobj;
9769 fail:
9770 return NULL;
9771 }
9772
9773
9774 SWIGINTERN PyObject *_wrap_Cursor_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9775 PyObject *resultobj = 0;
9776 wxCursor *arg1 = (wxCursor *) 0 ;
9777 bool result;
9778 void *argp1 = 0 ;
9779 int res1 = 0 ;
9780 PyObject *swig_obj[1] ;
9781
9782 if (!args) SWIG_fail;
9783 swig_obj[0] = args;
9784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9785 if (!SWIG_IsOK(res1)) {
9786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_Ok" "', expected argument " "1"" of type '" "wxCursor *""'");
9787 }
9788 arg1 = reinterpret_cast< wxCursor * >(argp1);
9789 {
9790 PyThreadState* __tstate = wxPyBeginAllowThreads();
9791 result = (bool)(arg1)->Ok();
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 {
9796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9797 }
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *Cursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9805 PyObject *obj;
9806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9807 SWIG_TypeNewClientData(SWIGTYPE_p_wxCursor, SWIG_NewClientData(obj));
9808 return SWIG_Py_Void();
9809 }
9810
9811 SWIGINTERN PyObject *Cursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9812 return SWIG_Python_InitShadowInstance(args);
9813 }
9814
9815 SWIGINTERN PyObject *_wrap_new_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj = 0;
9817 int arg1 = (int) 0 ;
9818 int arg2 = (int) 0 ;
9819 int arg3 = (int) 0 ;
9820 int arg4 = (int) 0 ;
9821 wxRegion *result = 0 ;
9822 int val1 ;
9823 int ecode1 = 0 ;
9824 int val2 ;
9825 int ecode2 = 0 ;
9826 int val3 ;
9827 int ecode3 = 0 ;
9828 int val4 ;
9829 int ecode4 = 0 ;
9830 PyObject * obj0 = 0 ;
9831 PyObject * obj1 = 0 ;
9832 PyObject * obj2 = 0 ;
9833 PyObject * obj3 = 0 ;
9834 char * kwnames[] = {
9835 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
9836 };
9837
9838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9839 if (obj0) {
9840 ecode1 = SWIG_AsVal_int(obj0, &val1);
9841 if (!SWIG_IsOK(ecode1)) {
9842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Region" "', expected argument " "1"" of type '" "int""'");
9843 }
9844 arg1 = static_cast< int >(val1);
9845 }
9846 if (obj1) {
9847 ecode2 = SWIG_AsVal_int(obj1, &val2);
9848 if (!SWIG_IsOK(ecode2)) {
9849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Region" "', expected argument " "2"" of type '" "int""'");
9850 }
9851 arg2 = static_cast< int >(val2);
9852 }
9853 if (obj2) {
9854 ecode3 = SWIG_AsVal_int(obj2, &val3);
9855 if (!SWIG_IsOK(ecode3)) {
9856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Region" "', expected argument " "3"" of type '" "int""'");
9857 }
9858 arg3 = static_cast< int >(val3);
9859 }
9860 if (obj3) {
9861 ecode4 = SWIG_AsVal_int(obj3, &val4);
9862 if (!SWIG_IsOK(ecode4)) {
9863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Region" "', expected argument " "4"" of type '" "int""'");
9864 }
9865 arg4 = static_cast< int >(val4);
9866 }
9867 {
9868 if (!wxPyCheckForApp()) SWIG_fail;
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_NEW | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_new_RegionFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxBitmap *arg1 = 0 ;
9884 wxRegion *result = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 PyObject * obj0 = 0 ;
9888 char * kwnames[] = {
9889 (char *) "bmp", NULL
9890 };
9891
9892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) SWIG_fail;
9893 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
9894 if (!SWIG_IsOK(res1)) {
9895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9896 }
9897 if (!argp1) {
9898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9899 }
9900 arg1 = reinterpret_cast< wxBitmap * >(argp1);
9901 {
9902 if (!wxPyCheckForApp()) SWIG_fail;
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_new_RegionFromBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxBitmap *arg1 = 0 ;
9918 wxColour *arg2 = 0 ;
9919 int arg3 = (int) 0 ;
9920 wxRegion *result = 0 ;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 wxColour temp2 ;
9924 int val3 ;
9925 int ecode3 = 0 ;
9926 PyObject * obj0 = 0 ;
9927 PyObject * obj1 = 0 ;
9928 PyObject * obj2 = 0 ;
9929 char * kwnames[] = {
9930 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
9931 };
9932
9933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9934 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
9935 if (!SWIG_IsOK(res1)) {
9936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9937 }
9938 if (!argp1) {
9939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9940 }
9941 arg1 = reinterpret_cast< wxBitmap * >(argp1);
9942 {
9943 arg2 = &temp2;
9944 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
9945 }
9946 if (obj2) {
9947 ecode3 = SWIG_AsVal_int(obj2, &val3);
9948 if (!SWIG_IsOK(ecode3)) {
9949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromBitmapColour" "', expected argument " "3"" of type '" "int""'");
9950 }
9951 arg3 = static_cast< int >(val3);
9952 }
9953 {
9954 if (!wxPyCheckForApp()) SWIG_fail;
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
9957 wxPyEndAllowThreads(__tstate);
9958 if (PyErr_Occurred()) SWIG_fail;
9959 }
9960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
9961 return resultobj;
9962 fail:
9963 return NULL;
9964 }
9965
9966
9967 SWIGINTERN PyObject *_wrap_new_RegionFromPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9968 PyObject *resultobj = 0;
9969 int arg1 ;
9970 wxPoint *arg2 = (wxPoint *) 0 ;
9971 int arg3 = (int) wxWINDING_RULE ;
9972 wxRegion *result = 0 ;
9973 int val3 ;
9974 int ecode3 = 0 ;
9975 PyObject * obj0 = 0 ;
9976 PyObject * obj1 = 0 ;
9977 char * kwnames[] = {
9978 (char *) "points",(char *) "fillStyle", NULL
9979 };
9980
9981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) SWIG_fail;
9982 {
9983 arg2 = wxPoint_LIST_helper(obj0, &arg1);
9984 if (arg2 == NULL) SWIG_fail;
9985 }
9986 if (obj1) {
9987 ecode3 = SWIG_AsVal_int(obj1, &val3);
9988 if (!SWIG_IsOK(ecode3)) {
9989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromPoints" "', expected argument " "3"" of type '" "int""'");
9990 }
9991 arg3 = static_cast< int >(val3);
9992 }
9993 {
9994 if (!wxPyCheckForApp()) SWIG_fail;
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
10001 {
10002 if (arg2) delete [] arg2;
10003 }
10004 return resultobj;
10005 fail:
10006 {
10007 if (arg2) delete [] arg2;
10008 }
10009 return NULL;
10010 }
10011
10012
10013 SWIGINTERN PyObject *_wrap_delete_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10014 PyObject *resultobj = 0;
10015 wxRegion *arg1 = (wxRegion *) 0 ;
10016 void *argp1 = 0 ;
10017 int res1 = 0 ;
10018 PyObject *swig_obj[1] ;
10019
10020 if (!args) SWIG_fail;
10021 swig_obj[0] = args;
10022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, SWIG_POINTER_DISOWN | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', expected argument " "1"" of type '" "wxRegion *""'");
10025 }
10026 arg1 = reinterpret_cast< wxRegion * >(argp1);
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 delete arg1;
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 resultobj = SWIG_Py_Void();
10035 return resultobj;
10036 fail:
10037 return NULL;
10038 }
10039
10040
10041 SWIGINTERN PyObject *_wrap_Region_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10042 PyObject *resultobj = 0;
10043 wxRegion *arg1 = (wxRegion *) 0 ;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 PyObject *swig_obj[1] ;
10047
10048 if (!args) SWIG_fail;
10049 swig_obj[0] = args;
10050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10051 if (!SWIG_IsOK(res1)) {
10052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Clear" "', expected argument " "1"" of type '" "wxRegion *""'");
10053 }
10054 arg1 = reinterpret_cast< wxRegion * >(argp1);
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 (arg1)->Clear();
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_Py_Void();
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_Region_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxRegion *arg1 = (wxRegion *) 0 ;
10071 int arg2 ;
10072 int arg3 ;
10073 bool result;
10074 void *argp1 = 0 ;
10075 int res1 = 0 ;
10076 int val2 ;
10077 int ecode2 = 0 ;
10078 int val3 ;
10079 int ecode3 = 0 ;
10080 PyObject * obj0 = 0 ;
10081 PyObject * obj1 = 0 ;
10082 PyObject * obj2 = 0 ;
10083 char * kwnames[] = {
10084 (char *) "self",(char *) "x",(char *) "y", NULL
10085 };
10086
10087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10089 if (!SWIG_IsOK(res1)) {
10090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Offset" "', expected argument " "1"" of type '" "wxRegion *""'");
10091 }
10092 arg1 = reinterpret_cast< wxRegion * >(argp1);
10093 ecode2 = SWIG_AsVal_int(obj1, &val2);
10094 if (!SWIG_IsOK(ecode2)) {
10095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Offset" "', expected argument " "2"" of type '" "int""'");
10096 }
10097 arg2 = static_cast< int >(val2);
10098 ecode3 = SWIG_AsVal_int(obj2, &val3);
10099 if (!SWIG_IsOK(ecode3)) {
10100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Offset" "', expected argument " "3"" of type '" "int""'");
10101 }
10102 arg3 = static_cast< int >(val3);
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 result = (bool)(arg1)->Offset(arg2,arg3);
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 {
10110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10111 }
10112 return resultobj;
10113 fail:
10114 return NULL;
10115 }
10116
10117
10118 SWIGINTERN PyObject *_wrap_Region_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10119 PyObject *resultobj = 0;
10120 wxRegion *arg1 = (wxRegion *) 0 ;
10121 int arg2 ;
10122 int arg3 ;
10123 wxRegionContain result;
10124 void *argp1 = 0 ;
10125 int res1 = 0 ;
10126 int val2 ;
10127 int ecode2 = 0 ;
10128 int val3 ;
10129 int ecode3 = 0 ;
10130 PyObject * obj0 = 0 ;
10131 PyObject * obj1 = 0 ;
10132 PyObject * obj2 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "self",(char *) "x",(char *) "y", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Contains" "', expected argument " "1"" of type '" "wxRegion *""'");
10141 }
10142 arg1 = reinterpret_cast< wxRegion * >(argp1);
10143 ecode2 = SWIG_AsVal_int(obj1, &val2);
10144 if (!SWIG_IsOK(ecode2)) {
10145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Contains" "', expected argument " "2"" of type '" "int""'");
10146 }
10147 arg2 = static_cast< int >(val2);
10148 ecode3 = SWIG_AsVal_int(obj2, &val3);
10149 if (!SWIG_IsOK(ecode3)) {
10150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Contains" "', expected argument " "3"" of type '" "int""'");
10151 }
10152 arg3 = static_cast< int >(val3);
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
10156 wxPyEndAllowThreads(__tstate);
10157 if (PyErr_Occurred()) SWIG_fail;
10158 }
10159 resultobj = SWIG_From_int(static_cast< int >(result));
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_Region_ContainsPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj = 0;
10168 wxRegion *arg1 = (wxRegion *) 0 ;
10169 wxPoint *arg2 = 0 ;
10170 wxRegionContain result;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 wxPoint temp2 ;
10174 PyObject * obj0 = 0 ;
10175 PyObject * obj1 = 0 ;
10176 char * kwnames[] = {
10177 (char *) "self",(char *) "pt", NULL
10178 };
10179
10180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) SWIG_fail;
10181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10182 if (!SWIG_IsOK(res1)) {
10183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsPoint" "', expected argument " "1"" of type '" "wxRegion *""'");
10184 }
10185 arg1 = reinterpret_cast< wxRegion * >(argp1);
10186 {
10187 arg2 = &temp2;
10188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10189 }
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 resultobj = SWIG_From_int(static_cast< int >(result));
10197 return resultobj;
10198 fail:
10199 return NULL;
10200 }
10201
10202
10203 SWIGINTERN PyObject *_wrap_Region_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10204 PyObject *resultobj = 0;
10205 wxRegion *arg1 = (wxRegion *) 0 ;
10206 wxRect *arg2 = 0 ;
10207 wxRegionContain result;
10208 void *argp1 = 0 ;
10209 int res1 = 0 ;
10210 wxRect temp2 ;
10211 PyObject * obj0 = 0 ;
10212 PyObject * obj1 = 0 ;
10213 char * kwnames[] = {
10214 (char *) "self",(char *) "rect", NULL
10215 };
10216
10217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10219 if (!SWIG_IsOK(res1)) {
10220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10221 }
10222 arg1 = reinterpret_cast< wxRegion * >(argp1);
10223 {
10224 arg2 = &temp2;
10225 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 resultobj = SWIG_From_int(static_cast< int >(result));
10234 return resultobj;
10235 fail:
10236 return NULL;
10237 }
10238
10239
10240 SWIGINTERN PyObject *_wrap_Region_ContainsRectDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10241 PyObject *resultobj = 0;
10242 wxRegion *arg1 = (wxRegion *) 0 ;
10243 int arg2 ;
10244 int arg3 ;
10245 int arg4 ;
10246 int arg5 ;
10247 wxRegionContain result;
10248 void *argp1 = 0 ;
10249 int res1 = 0 ;
10250 int val2 ;
10251 int ecode2 = 0 ;
10252 int val3 ;
10253 int ecode3 = 0 ;
10254 int val4 ;
10255 int ecode4 = 0 ;
10256 int val5 ;
10257 int ecode5 = 0 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 PyObject * obj2 = 0 ;
10261 PyObject * obj3 = 0 ;
10262 PyObject * obj4 = 0 ;
10263 char * kwnames[] = {
10264 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
10265 };
10266
10267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRectDim" "', expected argument " "1"" of type '" "wxRegion *""'");
10271 }
10272 arg1 = reinterpret_cast< wxRegion * >(argp1);
10273 ecode2 = SWIG_AsVal_int(obj1, &val2);
10274 if (!SWIG_IsOK(ecode2)) {
10275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_ContainsRectDim" "', expected argument " "2"" of type '" "int""'");
10276 }
10277 arg2 = static_cast< int >(val2);
10278 ecode3 = SWIG_AsVal_int(obj2, &val3);
10279 if (!SWIG_IsOK(ecode3)) {
10280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_ContainsRectDim" "', expected argument " "3"" of type '" "int""'");
10281 }
10282 arg3 = static_cast< int >(val3);
10283 ecode4 = SWIG_AsVal_int(obj3, &val4);
10284 if (!SWIG_IsOK(ecode4)) {
10285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_ContainsRectDim" "', expected argument " "4"" of type '" "int""'");
10286 }
10287 arg4 = static_cast< int >(val4);
10288 ecode5 = SWIG_AsVal_int(obj4, &val5);
10289 if (!SWIG_IsOK(ecode5)) {
10290 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_ContainsRectDim" "', expected argument " "5"" of type '" "int""'");
10291 }
10292 arg5 = static_cast< int >(val5);
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_From_int(static_cast< int >(result));
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_Region_GetBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10307 PyObject *resultobj = 0;
10308 wxRegion *arg1 = (wxRegion *) 0 ;
10309 wxRect result;
10310 void *argp1 = 0 ;
10311 int res1 = 0 ;
10312 PyObject *swig_obj[1] ;
10313
10314 if (!args) SWIG_fail;
10315 swig_obj[0] = args;
10316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_GetBox" "', expected argument " "1"" of type '" "wxRegion *""'");
10319 }
10320 arg1 = reinterpret_cast< wxRegion * >(argp1);
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (arg1)->GetBox();
10324 wxPyEndAllowThreads(__tstate);
10325 if (PyErr_Occurred()) SWIG_fail;
10326 }
10327 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 SWIGINTERN PyObject *_wrap_Region_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj = 0;
10336 wxRegion *arg1 = (wxRegion *) 0 ;
10337 int arg2 ;
10338 int arg3 ;
10339 int arg4 ;
10340 int arg5 ;
10341 bool result;
10342 void *argp1 = 0 ;
10343 int res1 = 0 ;
10344 int val2 ;
10345 int ecode2 = 0 ;
10346 int val3 ;
10347 int ecode3 = 0 ;
10348 int val4 ;
10349 int ecode4 = 0 ;
10350 int val5 ;
10351 int ecode5 = 0 ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 PyObject * obj2 = 0 ;
10355 PyObject * obj3 = 0 ;
10356 PyObject * obj4 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Intersect" "', expected argument " "1"" of type '" "wxRegion *""'");
10365 }
10366 arg1 = reinterpret_cast< wxRegion * >(argp1);
10367 ecode2 = SWIG_AsVal_int(obj1, &val2);
10368 if (!SWIG_IsOK(ecode2)) {
10369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Intersect" "', expected argument " "2"" of type '" "int""'");
10370 }
10371 arg2 = static_cast< int >(val2);
10372 ecode3 = SWIG_AsVal_int(obj2, &val3);
10373 if (!SWIG_IsOK(ecode3)) {
10374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Intersect" "', expected argument " "3"" of type '" "int""'");
10375 }
10376 arg3 = static_cast< int >(val3);
10377 ecode4 = SWIG_AsVal_int(obj3, &val4);
10378 if (!SWIG_IsOK(ecode4)) {
10379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Intersect" "', expected argument " "4"" of type '" "int""'");
10380 }
10381 arg4 = static_cast< int >(val4);
10382 ecode5 = SWIG_AsVal_int(obj4, &val5);
10383 if (!SWIG_IsOK(ecode5)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Intersect" "', expected argument " "5"" of type '" "int""'");
10385 }
10386 arg5 = static_cast< int >(val5);
10387 {
10388 PyThreadState* __tstate = wxPyBeginAllowThreads();
10389 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 {
10394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10395 }
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_Region_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj = 0;
10404 wxRegion *arg1 = (wxRegion *) 0 ;
10405 wxRect *arg2 = 0 ;
10406 bool result;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 wxRect temp2 ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 char * kwnames[] = {
10413 (char *) "self",(char *) "rect", NULL
10414 };
10415
10416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10420 }
10421 arg1 = reinterpret_cast< wxRegion * >(argp1);
10422 {
10423 arg2 = &temp2;
10424 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10425 }
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10434 }
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_Region_IntersectRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10442 PyObject *resultobj = 0;
10443 wxRegion *arg1 = (wxRegion *) 0 ;
10444 wxRegion *arg2 = 0 ;
10445 bool result;
10446 void *argp1 = 0 ;
10447 int res1 = 0 ;
10448 void *argp2 = 0 ;
10449 int res2 = 0 ;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 char * kwnames[] = {
10453 (char *) "self",(char *) "region", NULL
10454 };
10455
10456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10458 if (!SWIG_IsOK(res1)) {
10459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10460 }
10461 arg1 = reinterpret_cast< wxRegion * >(argp1);
10462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10463 if (!SWIG_IsOK(res2)) {
10464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10465 }
10466 if (!argp2) {
10467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10468 }
10469 arg2 = reinterpret_cast< wxRegion * >(argp2);
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 {
10477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10478 }
10479 return resultobj;
10480 fail:
10481 return NULL;
10482 }
10483
10484
10485 SWIGINTERN PyObject *_wrap_Region_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10486 PyObject *resultobj = 0;
10487 wxRegion *arg1 = (wxRegion *) 0 ;
10488 bool result;
10489 void *argp1 = 0 ;
10490 int res1 = 0 ;
10491 PyObject *swig_obj[1] ;
10492
10493 if (!args) SWIG_fail;
10494 swig_obj[0] = args;
10495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10496 if (!SWIG_IsOK(res1)) {
10497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IsEmpty" "', expected argument " "1"" of type '" "wxRegion *""'");
10498 }
10499 arg1 = reinterpret_cast< wxRegion * >(argp1);
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 result = (bool)(arg1)->IsEmpty();
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 {
10507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10508 }
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_Region_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxRegion *arg1 = (wxRegion *) 0 ;
10518 int arg2 ;
10519 int arg3 ;
10520 int arg4 ;
10521 int arg5 ;
10522 bool result;
10523 void *argp1 = 0 ;
10524 int res1 = 0 ;
10525 int val2 ;
10526 int ecode2 = 0 ;
10527 int val3 ;
10528 int ecode3 = 0 ;
10529 int val4 ;
10530 int ecode4 = 0 ;
10531 int val5 ;
10532 int ecode5 = 0 ;
10533 PyObject * obj0 = 0 ;
10534 PyObject * obj1 = 0 ;
10535 PyObject * obj2 = 0 ;
10536 PyObject * obj3 = 0 ;
10537 PyObject * obj4 = 0 ;
10538 char * kwnames[] = {
10539 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10540 };
10541
10542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10544 if (!SWIG_IsOK(res1)) {
10545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Union" "', expected argument " "1"" of type '" "wxRegion *""'");
10546 }
10547 arg1 = reinterpret_cast< wxRegion * >(argp1);
10548 ecode2 = SWIG_AsVal_int(obj1, &val2);
10549 if (!SWIG_IsOK(ecode2)) {
10550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Union" "', expected argument " "2"" of type '" "int""'");
10551 }
10552 arg2 = static_cast< int >(val2);
10553 ecode3 = SWIG_AsVal_int(obj2, &val3);
10554 if (!SWIG_IsOK(ecode3)) {
10555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Union" "', expected argument " "3"" of type '" "int""'");
10556 }
10557 arg3 = static_cast< int >(val3);
10558 ecode4 = SWIG_AsVal_int(obj3, &val4);
10559 if (!SWIG_IsOK(ecode4)) {
10560 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Union" "', expected argument " "4"" of type '" "int""'");
10561 }
10562 arg4 = static_cast< int >(val4);
10563 ecode5 = SWIG_AsVal_int(obj4, &val5);
10564 if (!SWIG_IsOK(ecode5)) {
10565 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Union" "', expected argument " "5"" of type '" "int""'");
10566 }
10567 arg5 = static_cast< int >(val5);
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10576 }
10577 return resultobj;
10578 fail:
10579 return NULL;
10580 }
10581
10582
10583 SWIGINTERN PyObject *_wrap_Region_UnionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj = 0;
10585 wxRegion *arg1 = (wxRegion *) 0 ;
10586 wxRect *arg2 = 0 ;
10587 bool result;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 wxRect temp2 ;
10591 PyObject * obj0 = 0 ;
10592 PyObject * obj1 = 0 ;
10593 char * kwnames[] = {
10594 (char *) "self",(char *) "rect", NULL
10595 };
10596
10597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) SWIG_fail;
10598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10601 }
10602 arg1 = reinterpret_cast< wxRegion * >(argp1);
10603 {
10604 arg2 = &temp2;
10605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10606 }
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (bool)(arg1)->Union((wxRect const &)*arg2);
10610 wxPyEndAllowThreads(__tstate);
10611 if (PyErr_Occurred()) SWIG_fail;
10612 }
10613 {
10614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10615 }
10616 return resultobj;
10617 fail:
10618 return NULL;
10619 }
10620
10621
10622 SWIGINTERN PyObject *_wrap_Region_UnionRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10623 PyObject *resultobj = 0;
10624 wxRegion *arg1 = (wxRegion *) 0 ;
10625 wxRegion *arg2 = 0 ;
10626 bool result;
10627 void *argp1 = 0 ;
10628 int res1 = 0 ;
10629 void *argp2 = 0 ;
10630 int res2 = 0 ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "region", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10641 }
10642 arg1 = reinterpret_cast< wxRegion * >(argp1);
10643 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10644 if (!SWIG_IsOK(res2)) {
10645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10646 }
10647 if (!argp2) {
10648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10649 }
10650 arg2 = reinterpret_cast< wxRegion * >(argp2);
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 {
10658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10659 }
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_Region_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10667 PyObject *resultobj = 0;
10668 wxRegion *arg1 = (wxRegion *) 0 ;
10669 int arg2 ;
10670 int arg3 ;
10671 int arg4 ;
10672 int arg5 ;
10673 bool result;
10674 void *argp1 = 0 ;
10675 int res1 = 0 ;
10676 int val2 ;
10677 int ecode2 = 0 ;
10678 int val3 ;
10679 int ecode3 = 0 ;
10680 int val4 ;
10681 int ecode4 = 0 ;
10682 int val5 ;
10683 int ecode5 = 0 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 PyObject * obj3 = 0 ;
10688 PyObject * obj4 = 0 ;
10689 char * kwnames[] = {
10690 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10691 };
10692
10693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10695 if (!SWIG_IsOK(res1)) {
10696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Subtract" "', expected argument " "1"" of type '" "wxRegion *""'");
10697 }
10698 arg1 = reinterpret_cast< wxRegion * >(argp1);
10699 ecode2 = SWIG_AsVal_int(obj1, &val2);
10700 if (!SWIG_IsOK(ecode2)) {
10701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Subtract" "', expected argument " "2"" of type '" "int""'");
10702 }
10703 arg2 = static_cast< int >(val2);
10704 ecode3 = SWIG_AsVal_int(obj2, &val3);
10705 if (!SWIG_IsOK(ecode3)) {
10706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Subtract" "', expected argument " "3"" of type '" "int""'");
10707 }
10708 arg3 = static_cast< int >(val3);
10709 ecode4 = SWIG_AsVal_int(obj3, &val4);
10710 if (!SWIG_IsOK(ecode4)) {
10711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Subtract" "', expected argument " "4"" of type '" "int""'");
10712 }
10713 arg4 = static_cast< int >(val4);
10714 ecode5 = SWIG_AsVal_int(obj4, &val5);
10715 if (!SWIG_IsOK(ecode5)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Subtract" "', expected argument " "5"" of type '" "int""'");
10717 }
10718 arg5 = static_cast< int >(val5);
10719 {
10720 PyThreadState* __tstate = wxPyBeginAllowThreads();
10721 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 {
10726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10727 }
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 SWIGINTERN PyObject *_wrap_Region_SubtractRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj = 0;
10736 wxRegion *arg1 = (wxRegion *) 0 ;
10737 wxRect *arg2 = 0 ;
10738 bool result;
10739 void *argp1 = 0 ;
10740 int res1 = 0 ;
10741 wxRect temp2 ;
10742 PyObject * obj0 = 0 ;
10743 PyObject * obj1 = 0 ;
10744 char * kwnames[] = {
10745 (char *) "self",(char *) "rect", NULL
10746 };
10747
10748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) SWIG_fail;
10749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10750 if (!SWIG_IsOK(res1)) {
10751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10752 }
10753 arg1 = reinterpret_cast< wxRegion * >(argp1);
10754 {
10755 arg2 = &temp2;
10756 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 {
10765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10766 }
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_Region_SubtractRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj = 0;
10775 wxRegion *arg1 = (wxRegion *) 0 ;
10776 wxRegion *arg2 = 0 ;
10777 bool result;
10778 void *argp1 = 0 ;
10779 int res1 = 0 ;
10780 void *argp2 = 0 ;
10781 int res2 = 0 ;
10782 PyObject * obj0 = 0 ;
10783 PyObject * obj1 = 0 ;
10784 char * kwnames[] = {
10785 (char *) "self",(char *) "region", NULL
10786 };
10787
10788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10790 if (!SWIG_IsOK(res1)) {
10791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10792 }
10793 arg1 = reinterpret_cast< wxRegion * >(argp1);
10794 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10795 if (!SWIG_IsOK(res2)) {
10796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10797 }
10798 if (!argp2) {
10799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10800 }
10801 arg2 = reinterpret_cast< wxRegion * >(argp2);
10802 {
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 {
10809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10810 }
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 SWIGINTERN PyObject *_wrap_Region_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj = 0;
10819 wxRegion *arg1 = (wxRegion *) 0 ;
10820 int arg2 ;
10821 int arg3 ;
10822 int arg4 ;
10823 int arg5 ;
10824 bool result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 int val2 ;
10828 int ecode2 = 0 ;
10829 int val3 ;
10830 int ecode3 = 0 ;
10831 int val4 ;
10832 int ecode4 = 0 ;
10833 int val5 ;
10834 int ecode5 = 0 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 PyObject * obj2 = 0 ;
10838 PyObject * obj3 = 0 ;
10839 PyObject * obj4 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10846 if (!SWIG_IsOK(res1)) {
10847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Xor" "', expected argument " "1"" of type '" "wxRegion *""'");
10848 }
10849 arg1 = reinterpret_cast< wxRegion * >(argp1);
10850 ecode2 = SWIG_AsVal_int(obj1, &val2);
10851 if (!SWIG_IsOK(ecode2)) {
10852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Xor" "', expected argument " "2"" of type '" "int""'");
10853 }
10854 arg2 = static_cast< int >(val2);
10855 ecode3 = SWIG_AsVal_int(obj2, &val3);
10856 if (!SWIG_IsOK(ecode3)) {
10857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Xor" "', expected argument " "3"" of type '" "int""'");
10858 }
10859 arg3 = static_cast< int >(val3);
10860 ecode4 = SWIG_AsVal_int(obj3, &val4);
10861 if (!SWIG_IsOK(ecode4)) {
10862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Xor" "', expected argument " "4"" of type '" "int""'");
10863 }
10864 arg4 = static_cast< int >(val4);
10865 ecode5 = SWIG_AsVal_int(obj4, &val5);
10866 if (!SWIG_IsOK(ecode5)) {
10867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Xor" "', expected argument " "5"" of type '" "int""'");
10868 }
10869 arg5 = static_cast< int >(val5);
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10878 }
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *_wrap_Region_XorRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj = 0;
10887 wxRegion *arg1 = (wxRegion *) 0 ;
10888 wxRect *arg2 = 0 ;
10889 bool result;
10890 void *argp1 = 0 ;
10891 int res1 = 0 ;
10892 wxRect temp2 ;
10893 PyObject * obj0 = 0 ;
10894 PyObject * obj1 = 0 ;
10895 char * kwnames[] = {
10896 (char *) "self",(char *) "rect", NULL
10897 };
10898
10899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) SWIG_fail;
10900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10901 if (!SWIG_IsOK(res1)) {
10902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10903 }
10904 arg1 = reinterpret_cast< wxRegion * >(argp1);
10905 {
10906 arg2 = &temp2;
10907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10908 }
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 {
10916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10917 }
10918 return resultobj;
10919 fail:
10920 return NULL;
10921 }
10922
10923
10924 SWIGINTERN PyObject *_wrap_Region_XorRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10925 PyObject *resultobj = 0;
10926 wxRegion *arg1 = (wxRegion *) 0 ;
10927 wxRegion *arg2 = 0 ;
10928 bool result;
10929 void *argp1 = 0 ;
10930 int res1 = 0 ;
10931 void *argp2 = 0 ;
10932 int res2 = 0 ;
10933 PyObject * obj0 = 0 ;
10934 PyObject * obj1 = 0 ;
10935 char * kwnames[] = {
10936 (char *) "self",(char *) "region", NULL
10937 };
10938
10939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10941 if (!SWIG_IsOK(res1)) {
10942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10943 }
10944 arg1 = reinterpret_cast< wxRegion * >(argp1);
10945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10946 if (!SWIG_IsOK(res2)) {
10947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10948 }
10949 if (!argp2) {
10950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10951 }
10952 arg2 = reinterpret_cast< wxRegion * >(argp2);
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
10956 wxPyEndAllowThreads(__tstate);
10957 if (PyErr_Occurred()) SWIG_fail;
10958 }
10959 {
10960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10961 }
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 SWIGINTERN PyObject *_wrap_Region_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10969 PyObject *resultobj = 0;
10970 wxRegion *arg1 = (wxRegion *) 0 ;
10971 SwigValueWrapper<wxBitmap > result;
10972 void *argp1 = 0 ;
10973 int res1 = 0 ;
10974 PyObject *swig_obj[1] ;
10975
10976 if (!args) SWIG_fail;
10977 swig_obj[0] = args;
10978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ConvertToBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
10981 }
10982 arg1 = reinterpret_cast< wxRegion * >(argp1);
10983 {
10984 PyThreadState* __tstate = wxPyBeginAllowThreads();
10985 result = (arg1)->ConvertToBitmap();
10986 wxPyEndAllowThreads(__tstate);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_Region_UnionBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = 0;
10998 wxRegion *arg1 = (wxRegion *) 0 ;
10999 wxBitmap *arg2 = 0 ;
11000 bool result;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 void *argp2 = 0 ;
11004 int res2 = 0 ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 char * kwnames[] = {
11008 (char *) "self",(char *) "bmp", NULL
11009 };
11010
11011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
11012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11013 if (!SWIG_IsOK(res1)) {
11014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
11015 }
11016 arg1 = reinterpret_cast< wxRegion * >(argp1);
11017 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11018 if (!SWIG_IsOK(res2)) {
11019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11020 }
11021 if (!argp2) {
11022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11023 }
11024 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
11028 wxPyEndAllowThreads(__tstate);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 {
11032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Region_UnionBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxRegion *arg1 = (wxRegion *) 0 ;
11043 wxBitmap *arg2 = 0 ;
11044 wxColour *arg3 = 0 ;
11045 int arg4 = (int) 0 ;
11046 bool result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 void *argp2 = 0 ;
11050 int res2 = 0 ;
11051 wxColour temp3 ;
11052 int val4 ;
11053 int ecode4 = 0 ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 PyObject * obj3 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmapColour" "', expected argument " "1"" of type '" "wxRegion *""'");
11066 }
11067 arg1 = reinterpret_cast< wxRegion * >(argp1);
11068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11069 if (!SWIG_IsOK(res2)) {
11070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11071 }
11072 if (!argp2) {
11073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11074 }
11075 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11076 {
11077 arg3 = &temp3;
11078 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
11079 }
11080 if (obj3) {
11081 ecode4 = SWIG_AsVal_int(obj3, &val4);
11082 if (!SWIG_IsOK(ecode4)) {
11083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_UnionBitmapColour" "', expected argument " "4"" of type '" "int""'");
11084 }
11085 arg4 = static_cast< int >(val4);
11086 }
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11095 }
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11103 PyObject *obj;
11104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11105 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegion, SWIG_NewClientData(obj));
11106 return SWIG_Py_Void();
11107 }
11108
11109 SWIGINTERN PyObject *Region_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11110 return SWIG_Python_InitShadowInstance(args);
11111 }
11112
11113 SWIGINTERN PyObject *_wrap_new_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj = 0;
11115 wxRegion *arg1 = 0 ;
11116 wxRegionIterator *result = 0 ;
11117 void *argp1 = 0 ;
11118 int res1 = 0 ;
11119 PyObject * obj0 = 0 ;
11120 char * kwnames[] = {
11121 (char *) "region", NULL
11122 };
11123
11124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) SWIG_fail;
11125 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRegion, 0 | 0);
11126 if (!SWIG_IsOK(res1)) {
11127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11128 }
11129 if (!argp1) {
11130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11131 }
11132 arg1 = reinterpret_cast< wxRegion * >(argp1);
11133 {
11134 if (!wxPyCheckForApp()) SWIG_fail;
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_NEW | 0 );
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_delete_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11150 void *argp1 = 0 ;
11151 int res1 = 0 ;
11152 PyObject *swig_obj[1] ;
11153
11154 if (!args) SWIG_fail;
11155 swig_obj[0] = args;
11156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_DISOWN | 0 );
11157 if (!SWIG_IsOK(res1)) {
11158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegionIterator" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11159 }
11160 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11161 {
11162 PyThreadState* __tstate = wxPyBeginAllowThreads();
11163 delete arg1;
11164
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 resultobj = SWIG_Py_Void();
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 SWIGINTERN PyObject *_wrap_RegionIterator_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11176 PyObject *resultobj = 0;
11177 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11178 int result;
11179 void *argp1 = 0 ;
11180 int res1 = 0 ;
11181 PyObject *swig_obj[1] ;
11182
11183 if (!args) SWIG_fail;
11184 swig_obj[0] = args;
11185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11186 if (!SWIG_IsOK(res1)) {
11187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetX" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11188 }
11189 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 result = (int)(arg1)->GetX();
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 resultobj = SWIG_From_int(static_cast< int >(result));
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 SWIGINTERN PyObject *_wrap_RegionIterator_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11204 PyObject *resultobj = 0;
11205 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11206 int result;
11207 void *argp1 = 0 ;
11208 int res1 = 0 ;
11209 PyObject *swig_obj[1] ;
11210
11211 if (!args) SWIG_fail;
11212 swig_obj[0] = args;
11213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11214 if (!SWIG_IsOK(res1)) {
11215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetY" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11216 }
11217 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 result = (int)(arg1)->GetY();
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 resultobj = SWIG_From_int(static_cast< int >(result));
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 SWIGINTERN PyObject *_wrap_RegionIterator_GetW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11232 PyObject *resultobj = 0;
11233 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11234 int result;
11235 void *argp1 = 0 ;
11236 int res1 = 0 ;
11237 PyObject *swig_obj[1] ;
11238
11239 if (!args) SWIG_fail;
11240 swig_obj[0] = args;
11241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11242 if (!SWIG_IsOK(res1)) {
11243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetW" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11244 }
11245 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11246 {
11247 PyThreadState* __tstate = wxPyBeginAllowThreads();
11248 result = (int)(arg1)->GetW();
11249 wxPyEndAllowThreads(__tstate);
11250 if (PyErr_Occurred()) SWIG_fail;
11251 }
11252 resultobj = SWIG_From_int(static_cast< int >(result));
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 SWIGINTERN PyObject *_wrap_RegionIterator_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11260 PyObject *resultobj = 0;
11261 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11262 int result;
11263 void *argp1 = 0 ;
11264 int res1 = 0 ;
11265 PyObject *swig_obj[1] ;
11266
11267 if (!args) SWIG_fail;
11268 swig_obj[0] = args;
11269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11270 if (!SWIG_IsOK(res1)) {
11271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetWidth" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11272 }
11273 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = (int)(arg1)->GetWidth();
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 resultobj = SWIG_From_int(static_cast< int >(result));
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 SWIGINTERN PyObject *_wrap_RegionIterator_GetH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11288 PyObject *resultobj = 0;
11289 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11290 int result;
11291 void *argp1 = 0 ;
11292 int res1 = 0 ;
11293 PyObject *swig_obj[1] ;
11294
11295 if (!args) SWIG_fail;
11296 swig_obj[0] = args;
11297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11298 if (!SWIG_IsOK(res1)) {
11299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetH" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11300 }
11301 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (int)(arg1)->GetH();
11305 wxPyEndAllowThreads(__tstate);
11306 if (PyErr_Occurred()) SWIG_fail;
11307 }
11308 resultobj = SWIG_From_int(static_cast< int >(result));
11309 return resultobj;
11310 fail:
11311 return NULL;
11312 }
11313
11314
11315 SWIGINTERN PyObject *_wrap_RegionIterator_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11316 PyObject *resultobj = 0;
11317 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11318 int result;
11319 void *argp1 = 0 ;
11320 int res1 = 0 ;
11321 PyObject *swig_obj[1] ;
11322
11323 if (!args) SWIG_fail;
11324 swig_obj[0] = args;
11325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11326 if (!SWIG_IsOK(res1)) {
11327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetHeight" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11328 }
11329 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (int)(arg1)->GetHeight();
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 resultobj = SWIG_From_int(static_cast< int >(result));
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *_wrap_RegionIterator_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11344 PyObject *resultobj = 0;
11345 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11346 wxRect result;
11347 void *argp1 = 0 ;
11348 int res1 = 0 ;
11349 PyObject *swig_obj[1] ;
11350
11351 if (!args) SWIG_fail;
11352 swig_obj[0] = args;
11353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11354 if (!SWIG_IsOK(res1)) {
11355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetRect" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11356 }
11357 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 result = (arg1)->GetRect();
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_RegionIterator_HaveRects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 PyObject *resultobj = 0;
11373 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11374 bool result;
11375 void *argp1 = 0 ;
11376 int res1 = 0 ;
11377 PyObject *swig_obj[1] ;
11378
11379 if (!args) SWIG_fail;
11380 swig_obj[0] = args;
11381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_HaveRects" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11384 }
11385 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11386 {
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 result = (bool)(arg1)->HaveRects();
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 {
11393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 SWIGINTERN PyObject *_wrap_RegionIterator_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11402 PyObject *resultobj = 0;
11403 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11404 void *argp1 = 0 ;
11405 int res1 = 0 ;
11406 PyObject *swig_obj[1] ;
11407
11408 if (!args) SWIG_fail;
11409 swig_obj[0] = args;
11410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11411 if (!SWIG_IsOK(res1)) {
11412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Reset" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11413 }
11414 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 (arg1)->Reset();
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 resultobj = SWIG_Py_Void();
11422 return resultobj;
11423 fail:
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_RegionIterator_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11429 PyObject *resultobj = 0;
11430 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11431 void *argp1 = 0 ;
11432 int res1 = 0 ;
11433 PyObject *swig_obj[1] ;
11434
11435 if (!args) SWIG_fail;
11436 swig_obj[0] = args;
11437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11438 if (!SWIG_IsOK(res1)) {
11439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Next" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11440 }
11441 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11442 {
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 wxRegionIterator_Next(arg1);
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 resultobj = SWIG_Py_Void();
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_RegionIterator___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11456 PyObject *resultobj = 0;
11457 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11458 bool result;
11459 void *argp1 = 0 ;
11460 int res1 = 0 ;
11461 PyObject *swig_obj[1] ;
11462
11463 if (!args) SWIG_fail;
11464 swig_obj[0] = args;
11465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11466 if (!SWIG_IsOK(res1)) {
11467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator___nonzero__" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11468 }
11469 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11470 {
11471 PyThreadState* __tstate = wxPyBeginAllowThreads();
11472 result = (bool)wxRegionIterator___nonzero__(arg1);
11473 wxPyEndAllowThreads(__tstate);
11474 if (PyErr_Occurred()) SWIG_fail;
11475 }
11476 {
11477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11478 }
11479 return resultobj;
11480 fail:
11481 return NULL;
11482 }
11483
11484
11485 SWIGINTERN PyObject *RegionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11486 PyObject *obj;
11487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11488 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegionIterator, SWIG_NewClientData(obj));
11489 return SWIG_Py_Void();
11490 }
11491
11492 SWIGINTERN PyObject *RegionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11493 return SWIG_Python_InitShadowInstance(args);
11494 }
11495
11496 SWIGINTERN PyObject *_wrap_new_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11497 PyObject *resultobj = 0;
11498 wxNativeFontInfo *result = 0 ;
11499
11500 if (!SWIG_Python_UnpackTuple(args,"new_NativeFontInfo",0,0,0)) SWIG_fail;
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (wxNativeFontInfo *)new wxNativeFontInfo();
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_NEW | 0 );
11508 return resultobj;
11509 fail:
11510 return NULL;
11511 }
11512
11513
11514 SWIGINTERN PyObject *_wrap_delete_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11515 PyObject *resultobj = 0;
11516 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11517 void *argp1 = 0 ;
11518 int res1 = 0 ;
11519 PyObject *swig_obj[1] ;
11520
11521 if (!args) SWIG_fail;
11522 swig_obj[0] = args;
11523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_DISOWN | 0 );
11524 if (!SWIG_IsOK(res1)) {
11525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeFontInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11526 }
11527 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11528 {
11529 PyThreadState* __tstate = wxPyBeginAllowThreads();
11530 delete arg1;
11531
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 resultobj = SWIG_Py_Void();
11536 return resultobj;
11537 fail:
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_NativeFontInfo_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11543 PyObject *resultobj = 0;
11544 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11545 void *argp1 = 0 ;
11546 int res1 = 0 ;
11547 PyObject *swig_obj[1] ;
11548
11549 if (!args) SWIG_fail;
11550 swig_obj[0] = args;
11551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11552 if (!SWIG_IsOK(res1)) {
11553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_Init" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11554 }
11555 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11556 {
11557 PyThreadState* __tstate = wxPyBeginAllowThreads();
11558 (arg1)->Init();
11559 wxPyEndAllowThreads(__tstate);
11560 if (PyErr_Occurred()) SWIG_fail;
11561 }
11562 resultobj = SWIG_Py_Void();
11563 return resultobj;
11564 fail:
11565 return NULL;
11566 }
11567
11568
11569 SWIGINTERN PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11570 PyObject *resultobj = 0;
11571 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11572 wxFont *arg2 = 0 ;
11573 void *argp1 = 0 ;
11574 int res1 = 0 ;
11575 void *argp2 = 0 ;
11576 int res2 = 0 ;
11577 PyObject * obj0 = 0 ;
11578 PyObject * obj1 = 0 ;
11579 char * kwnames[] = {
11580 (char *) "self",(char *) "font", NULL
11581 };
11582
11583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) SWIG_fail;
11584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11585 if (!SWIG_IsOK(res1)) {
11586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11587 }
11588 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11589 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
11590 if (!SWIG_IsOK(res2)) {
11591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
11592 }
11593 if (!argp2) {
11594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
11595 }
11596 arg2 = reinterpret_cast< wxFont * >(argp2);
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 (arg1)->InitFromFont((wxFont const &)*arg2);
11600 wxPyEndAllowThreads(__tstate);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 }
11603 resultobj = SWIG_Py_Void();
11604 return resultobj;
11605 fail:
11606 return NULL;
11607 }
11608
11609
11610 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11611 PyObject *resultobj = 0;
11612 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11613 int result;
11614 void *argp1 = 0 ;
11615 int res1 = 0 ;
11616 PyObject *swig_obj[1] ;
11617
11618 if (!args) SWIG_fail;
11619 swig_obj[0] = args;
11620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11621 if (!SWIG_IsOK(res1)) {
11622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11623 }
11624 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11625 {
11626 PyThreadState* __tstate = wxPyBeginAllowThreads();
11627 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
11628 wxPyEndAllowThreads(__tstate);
11629 if (PyErr_Occurred()) SWIG_fail;
11630 }
11631 resultobj = SWIG_From_int(static_cast< int >(result));
11632 return resultobj;
11633 fail:
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11641 wxFontStyle result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11651 }
11652 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 resultobj = SWIG_From_int(static_cast< int >(result));
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *resultobj = 0;
11668 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11669 wxFontWeight result;
11670 void *argp1 = 0 ;
11671 int res1 = 0 ;
11672 PyObject *swig_obj[1] ;
11673
11674 if (!args) SWIG_fail;
11675 swig_obj[0] = args;
11676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11679 }
11680 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 resultobj = SWIG_From_int(static_cast< int >(result));
11688 return resultobj;
11689 fail:
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11697 bool result;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11707 }
11708 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11717 }
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 PyObject *resultobj = 0;
11726 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11727 wxString result;
11728 void *argp1 = 0 ;
11729 int res1 = 0 ;
11730 PyObject *swig_obj[1] ;
11731
11732 if (!args) SWIG_fail;
11733 swig_obj[0] = args;
11734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11737 }
11738 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11739 {
11740 PyThreadState* __tstate = wxPyBeginAllowThreads();
11741 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 PyObject *resultobj = 0;
11760 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11761 wxFontFamily result;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 PyObject *swig_obj[1] ;
11765
11766 if (!args) SWIG_fail;
11767 swig_obj[0] = args;
11768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11769 if (!SWIG_IsOK(res1)) {
11770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11771 }
11772 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 resultobj = SWIG_From_int(static_cast< int >(result));
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *resultobj = 0;
11788 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11789 wxFontEncoding result;
11790 void *argp1 = 0 ;
11791 int res1 = 0 ;
11792 PyObject *swig_obj[1] ;
11793
11794 if (!args) SWIG_fail;
11795 swig_obj[0] = args;
11796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11799 }
11800 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 resultobj = SWIG_From_int(static_cast< int >(result));
11808 return resultobj;
11809 fail:
11810 return NULL;
11811 }
11812
11813
11814 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11815 PyObject *resultobj = 0;
11816 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11817 int arg2 ;
11818 void *argp1 = 0 ;
11819 int res1 = 0 ;
11820 int val2 ;
11821 int ecode2 = 0 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 char * kwnames[] = {
11825 (char *) "self",(char *) "pointsize", NULL
11826 };
11827
11828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
11829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11832 }
11833 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11834 ecode2 = SWIG_AsVal_int(obj1, &val2);
11835 if (!SWIG_IsOK(ecode2)) {
11836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "2"" of type '" "int""'");
11837 }
11838 arg2 = static_cast< int >(val2);
11839 {
11840 PyThreadState* __tstate = wxPyBeginAllowThreads();
11841 (arg1)->SetPointSize(arg2);
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 resultobj = SWIG_Py_Void();
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11853 PyObject *resultobj = 0;
11854 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11855 wxFontStyle arg2 ;
11856 void *argp1 = 0 ;
11857 int res1 = 0 ;
11858 int val2 ;
11859 int ecode2 = 0 ;
11860 PyObject * obj0 = 0 ;
11861 PyObject * obj1 = 0 ;
11862 char * kwnames[] = {
11863 (char *) "self",(char *) "style", NULL
11864 };
11865
11866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
11867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11868 if (!SWIG_IsOK(res1)) {
11869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11870 }
11871 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11872 ecode2 = SWIG_AsVal_int(obj1, &val2);
11873 if (!SWIG_IsOK(ecode2)) {
11874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
11875 }
11876 arg2 = static_cast< wxFontStyle >(val2);
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 (arg1)->SetStyle(arg2);
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 resultobj = SWIG_Py_Void();
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11893 wxFontWeight arg2 ;
11894 void *argp1 = 0 ;
11895 int res1 = 0 ;
11896 int val2 ;
11897 int ecode2 = 0 ;
11898 PyObject * obj0 = 0 ;
11899 PyObject * obj1 = 0 ;
11900 char * kwnames[] = {
11901 (char *) "self",(char *) "weight", NULL
11902 };
11903
11904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
11905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11906 if (!SWIG_IsOK(res1)) {
11907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11908 }
11909 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11910 ecode2 = SWIG_AsVal_int(obj1, &val2);
11911 if (!SWIG_IsOK(ecode2)) {
11912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
11913 }
11914 arg2 = static_cast< wxFontWeight >(val2);
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 (arg1)->SetWeight(arg2);
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 resultobj = SWIG_Py_Void();
11922 return resultobj;
11923 fail:
11924 return NULL;
11925 }
11926
11927
11928 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11929 PyObject *resultobj = 0;
11930 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11931 bool arg2 ;
11932 void *argp1 = 0 ;
11933 int res1 = 0 ;
11934 bool val2 ;
11935 int ecode2 = 0 ;
11936 PyObject * obj0 = 0 ;
11937 PyObject * obj1 = 0 ;
11938 char * kwnames[] = {
11939 (char *) "self",(char *) "underlined", NULL
11940 };
11941
11942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
11943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11944 if (!SWIG_IsOK(res1)) {
11945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11946 }
11947 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11949 if (!SWIG_IsOK(ecode2)) {
11950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
11951 }
11952 arg2 = static_cast< bool >(val2);
11953 {
11954 PyThreadState* __tstate = wxPyBeginAllowThreads();
11955 (arg1)->SetUnderlined(arg2);
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 resultobj = SWIG_Py_Void();
11960 return resultobj;
11961 fail:
11962 return NULL;
11963 }
11964
11965
11966 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11967 PyObject *resultobj = 0;
11968 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11969 wxString arg2 ;
11970 bool result;
11971 void *argp1 = 0 ;
11972 int res1 = 0 ;
11973 PyObject * obj0 = 0 ;
11974 PyObject * obj1 = 0 ;
11975 char * kwnames[] = {
11976 (char *) "self",(char *) "facename", NULL
11977 };
11978
11979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
11980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11981 if (!SWIG_IsOK(res1)) {
11982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11983 }
11984 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11985 {
11986 wxString* sptr = wxString_in_helper(obj1);
11987 if (sptr == NULL) SWIG_fail;
11988 arg2 = *sptr;
11989 delete sptr;
11990 }
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (bool)(arg1)->SetFaceName(arg2);
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 {
11998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11999 }
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12007 PyObject *resultobj = 0;
12008 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12009 wxFontFamily arg2 ;
12010 void *argp1 = 0 ;
12011 int res1 = 0 ;
12012 int val2 ;
12013 int ecode2 = 0 ;
12014 PyObject * obj0 = 0 ;
12015 PyObject * obj1 = 0 ;
12016 char * kwnames[] = {
12017 (char *) "self",(char *) "family", NULL
12018 };
12019
12020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
12021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12022 if (!SWIG_IsOK(res1)) {
12023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12024 }
12025 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12026 ecode2 = SWIG_AsVal_int(obj1, &val2);
12027 if (!SWIG_IsOK(ecode2)) {
12028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
12029 }
12030 arg2 = static_cast< wxFontFamily >(val2);
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 (arg1)->SetFamily(arg2);
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 resultobj = SWIG_Py_Void();
12038 return resultobj;
12039 fail:
12040 return NULL;
12041 }
12042
12043
12044 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12045 PyObject *resultobj = 0;
12046 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12047 wxFontEncoding arg2 ;
12048 void *argp1 = 0 ;
12049 int res1 = 0 ;
12050 int val2 ;
12051 int ecode2 = 0 ;
12052 PyObject * obj0 = 0 ;
12053 PyObject * obj1 = 0 ;
12054 char * kwnames[] = {
12055 (char *) "self",(char *) "encoding", NULL
12056 };
12057
12058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
12059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12060 if (!SWIG_IsOK(res1)) {
12061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12062 }
12063 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12064 ecode2 = SWIG_AsVal_int(obj1, &val2);
12065 if (!SWIG_IsOK(ecode2)) {
12066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12067 }
12068 arg2 = static_cast< wxFontEncoding >(val2);
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 (arg1)->SetEncoding(arg2);
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 resultobj = SWIG_Py_Void();
12076 return resultobj;
12077 fail:
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12083 PyObject *resultobj = 0;
12084 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12085 wxString *arg2 = 0 ;
12086 bool result;
12087 void *argp1 = 0 ;
12088 int res1 = 0 ;
12089 bool temp2 = false ;
12090 PyObject * obj0 = 0 ;
12091 PyObject * obj1 = 0 ;
12092 char * kwnames[] = {
12093 (char *) "self",(char *) "s", NULL
12094 };
12095
12096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
12097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12098 if (!SWIG_IsOK(res1)) {
12099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12100 }
12101 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12102 {
12103 arg2 = wxString_in_helper(obj1);
12104 if (arg2 == NULL) SWIG_fail;
12105 temp2 = true;
12106 }
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (bool)(arg1)->FromString((wxString const &)*arg2);
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 {
12114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12115 }
12116 {
12117 if (temp2)
12118 delete arg2;
12119 }
12120 return resultobj;
12121 fail:
12122 {
12123 if (temp2)
12124 delete arg2;
12125 }
12126 return NULL;
12127 }
12128
12129
12130 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12131 PyObject *resultobj = 0;
12132 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12133 wxString result;
12134 void *argp1 = 0 ;
12135 int res1 = 0 ;
12136 PyObject *swig_obj[1] ;
12137
12138 if (!args) SWIG_fail;
12139 swig_obj[0] = args;
12140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12141 if (!SWIG_IsOK(res1)) {
12142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12143 }
12144 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = ((wxNativeFontInfo const *)arg1)->ToString();
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 #if wxUSE_UNICODE
12153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12154 #else
12155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12156 #endif
12157 }
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *_wrap_NativeFontInfo___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12165 PyObject *resultobj = 0;
12166 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12167 wxString result;
12168 void *argp1 = 0 ;
12169 int res1 = 0 ;
12170 PyObject *swig_obj[1] ;
12171
12172 if (!args) SWIG_fail;
12173 swig_obj[0] = args;
12174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12175 if (!SWIG_IsOK(res1)) {
12176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo___str__" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12177 }
12178 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = wxNativeFontInfo___str__(arg1);
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 {
12186 #if wxUSE_UNICODE
12187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12188 #else
12189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12190 #endif
12191 }
12192 return resultobj;
12193 fail:
12194 return NULL;
12195 }
12196
12197
12198 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj = 0;
12200 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12201 wxString *arg2 = 0 ;
12202 bool result;
12203 void *argp1 = 0 ;
12204 int res1 = 0 ;
12205 bool temp2 = false ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 char * kwnames[] = {
12209 (char *) "self",(char *) "s", NULL
12210 };
12211
12212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) SWIG_fail;
12213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12214 if (!SWIG_IsOK(res1)) {
12215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12216 }
12217 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12218 {
12219 arg2 = wxString_in_helper(obj1);
12220 if (arg2 == NULL) SWIG_fail;
12221 temp2 = true;
12222 }
12223 {
12224 PyThreadState* __tstate = wxPyBeginAllowThreads();
12225 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 {
12230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12231 }
12232 {
12233 if (temp2)
12234 delete arg2;
12235 }
12236 return resultobj;
12237 fail:
12238 {
12239 if (temp2)
12240 delete arg2;
12241 }
12242 return NULL;
12243 }
12244
12245
12246 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12247 PyObject *resultobj = 0;
12248 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12249 wxString result;
12250 void *argp1 = 0 ;
12251 int res1 = 0 ;
12252 PyObject *swig_obj[1] ;
12253
12254 if (!args) SWIG_fail;
12255 swig_obj[0] = args;
12256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12259 }
12260 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 {
12268 #if wxUSE_UNICODE
12269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12270 #else
12271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12272 #endif
12273 }
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 SWIGINTERN PyObject *NativeFontInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12281 PyObject *obj;
12282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12283 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeFontInfo, SWIG_NewClientData(obj));
12284 return SWIG_Py_Void();
12285 }
12286
12287 SWIGINTERN PyObject *NativeFontInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12288 return SWIG_Python_InitShadowInstance(args);
12289 }
12290
12291 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12292 PyObject *resultobj = 0;
12293 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12294 wxString *arg2 = (wxString *) 0 ;
12295 void *argp1 = 0 ;
12296 int res1 = 0 ;
12297 bool temp2 = false ;
12298 PyObject *swig_obj[2] ;
12299
12300 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_facename_set",2,2,swig_obj)) SWIG_fail;
12301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12302 if (!SWIG_IsOK(res1)) {
12303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12304 }
12305 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12306 {
12307 arg2 = wxString_in_helper(swig_obj[1]);
12308 if (arg2 == NULL) SWIG_fail;
12309 temp2 = true;
12310 }
12311 if (arg1) (arg1)->facename = *arg2;
12312
12313 resultobj = SWIG_Py_Void();
12314 {
12315 if (temp2)
12316 delete arg2;
12317 }
12318 return resultobj;
12319 fail:
12320 {
12321 if (temp2)
12322 delete arg2;
12323 }
12324 return NULL;
12325 }
12326
12327
12328 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12329 PyObject *resultobj = 0;
12330 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12331 wxString *result = 0 ;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 PyObject *swig_obj[1] ;
12335
12336 if (!args) SWIG_fail;
12337 swig_obj[0] = args;
12338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12341 }
12342 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12343 result = (wxString *)& ((arg1)->facename);
12344 {
12345 #if wxUSE_UNICODE
12346 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12347 #else
12348 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12349 #endif
12350 }
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12358 PyObject *resultobj = 0;
12359 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12360 wxFontEncoding arg2 ;
12361 void *argp1 = 0 ;
12362 int res1 = 0 ;
12363 int val2 ;
12364 int ecode2 = 0 ;
12365 PyObject *swig_obj[2] ;
12366
12367 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_encoding_set",2,2,swig_obj)) SWIG_fail;
12368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12369 if (!SWIG_IsOK(res1)) {
12370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12371 }
12372 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12373 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12374 if (!SWIG_IsOK(ecode2)) {
12375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12376 }
12377 arg2 = static_cast< wxFontEncoding >(val2);
12378 if (arg1) (arg1)->encoding = arg2;
12379
12380 resultobj = SWIG_Py_Void();
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12388 PyObject *resultobj = 0;
12389 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12390 wxFontEncoding result;
12391 void *argp1 = 0 ;
12392 int res1 = 0 ;
12393 PyObject *swig_obj[1] ;
12394
12395 if (!args) SWIG_fail;
12396 swig_obj[0] = args;
12397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12398 if (!SWIG_IsOK(res1)) {
12399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12400 }
12401 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12402 result = (wxFontEncoding) ((arg1)->encoding);
12403 resultobj = SWIG_From_int(static_cast< int >(result));
12404 return resultobj;
12405 fail:
12406 return NULL;
12407 }
12408
12409
12410 SWIGINTERN PyObject *_wrap_new_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12411 PyObject *resultobj = 0;
12412 wxNativeEncodingInfo *result = 0 ;
12413
12414 if (!SWIG_Python_UnpackTuple(args,"new_NativeEncodingInfo",0,0,0)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_NEW | 0 );
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_delete_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 PyObject *resultobj = 0;
12430 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12431 void *argp1 = 0 ;
12432 int res1 = 0 ;
12433 PyObject *swig_obj[1] ;
12434
12435 if (!args) SWIG_fail;
12436 swig_obj[0] = args;
12437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_DISOWN | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeEncodingInfo" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12440 }
12441 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 delete arg1;
12445
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_Py_Void();
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12459 wxString *arg2 = 0 ;
12460 bool result;
12461 void *argp1 = 0 ;
12462 int res1 = 0 ;
12463 bool temp2 = false ;
12464 PyObject * obj0 = 0 ;
12465 PyObject * obj1 = 0 ;
12466 char * kwnames[] = {
12467 (char *) "self",(char *) "s", NULL
12468 };
12469
12470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
12471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12472 if (!SWIG_IsOK(res1)) {
12473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_FromString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12474 }
12475 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12476 {
12477 arg2 = wxString_in_helper(obj1);
12478 if (arg2 == NULL) SWIG_fail;
12479 temp2 = true;
12480 }
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (bool)(arg1)->FromString((wxString const &)*arg2);
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12489 }
12490 {
12491 if (temp2)
12492 delete arg2;
12493 }
12494 return resultobj;
12495 fail:
12496 {
12497 if (temp2)
12498 delete arg2;
12499 }
12500 return NULL;
12501 }
12502
12503
12504 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12505 PyObject *resultobj = 0;
12506 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12507 wxString result;
12508 void *argp1 = 0 ;
12509 int res1 = 0 ;
12510 PyObject *swig_obj[1] ;
12511
12512 if (!args) SWIG_fail;
12513 swig_obj[0] = args;
12514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12515 if (!SWIG_IsOK(res1)) {
12516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_ToString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const *""'");
12517 }
12518 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 #if wxUSE_UNICODE
12527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12528 #else
12529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12530 #endif
12531 }
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 SWIGINTERN PyObject *NativeEncodingInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12539 PyObject *obj;
12540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12541 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeEncodingInfo, SWIG_NewClientData(obj));
12542 return SWIG_Py_Void();
12543 }
12544
12545 SWIGINTERN PyObject *NativeEncodingInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12546 return SWIG_Python_InitShadowInstance(args);
12547 }
12548
12549 SWIGINTERN PyObject *_wrap_GetNativeFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj = 0;
12551 wxFontEncoding arg1 ;
12552 wxNativeEncodingInfo *result = 0 ;
12553 int val1 ;
12554 int ecode1 = 0 ;
12555 PyObject * obj0 = 0 ;
12556 char * kwnames[] = {
12557 (char *) "encoding", NULL
12558 };
12559
12560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) SWIG_fail;
12561 ecode1 = SWIG_AsVal_int(obj0, &val1);
12562 if (!SWIG_IsOK(ecode1)) {
12563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetNativeFontEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12564 }
12565 arg1 = static_cast< wxFontEncoding >(val1);
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding(arg1);
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 SWIGINTERN PyObject *_wrap_TestFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj = 0;
12581 wxNativeEncodingInfo *arg1 = 0 ;
12582 bool result;
12583 void *argp1 = 0 ;
12584 int res1 = 0 ;
12585 PyObject * obj0 = 0 ;
12586 char * kwnames[] = {
12587 (char *) "info", NULL
12588 };
12589
12590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) SWIG_fail;
12591 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0);
12592 if (!SWIG_IsOK(res1)) {
12593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
12594 }
12595 if (!argp1) {
12596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
12597 }
12598 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 {
12606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12607 }
12608 return resultobj;
12609 fail:
12610 return NULL;
12611 }
12612
12613
12614 SWIGINTERN PyObject *_wrap_new_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12615 PyObject *resultobj = 0;
12616 wxFontMapper *result = 0 ;
12617
12618 if (!SWIG_Python_UnpackTuple(args,"new_FontMapper",0,0,0)) SWIG_fail;
12619 {
12620 PyThreadState* __tstate = wxPyBeginAllowThreads();
12621 result = (wxFontMapper *)new wxFontMapper();
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, SWIG_POINTER_NEW | 0 );
12626 return resultobj;
12627 fail:
12628 return NULL;
12629 }
12630
12631
12632 SWIGINTERN PyObject *_wrap_delete_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12633 PyObject *resultobj = 0;
12634 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 PyObject *swig_obj[1] ;
12638
12639 if (!args) SWIG_fail;
12640 swig_obj[0] = args;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontMapper, SWIG_POINTER_DISOWN | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontMapper" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12644 }
12645 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 delete arg1;
12649
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_FontMapper_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxFontMapper *result = 0 ;
12663
12664 if (!SWIG_Python_UnpackTuple(args,"FontMapper_Get",0,0,0)) SWIG_fail;
12665 {
12666 PyThreadState* __tstate = wxPyBeginAllowThreads();
12667 result = (wxFontMapper *)wxFontMapper::Get();
12668 wxPyEndAllowThreads(__tstate);
12669 if (PyErr_Occurred()) SWIG_fail;
12670 }
12671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_FontMapper_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj = 0;
12680 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12681 wxFontMapper *result = 0 ;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 PyObject * obj0 = 0 ;
12685 char * kwnames[] = {
12686 (char *) "mapper", NULL
12687 };
12688
12689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) SWIG_fail;
12690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12691 if (!SWIG_IsOK(res1)) {
12692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_Set" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12693 }
12694 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 result = (wxFontMapper *)wxFontMapper::Set(arg1);
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12709 PyObject *resultobj = 0;
12710 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12711 wxString *arg2 = 0 ;
12712 bool arg3 = (bool) true ;
12713 wxFontEncoding result;
12714 void *argp1 = 0 ;
12715 int res1 = 0 ;
12716 bool temp2 = false ;
12717 bool val3 ;
12718 int ecode3 = 0 ;
12719 PyObject * obj0 = 0 ;
12720 PyObject * obj1 = 0 ;
12721 PyObject * obj2 = 0 ;
12722 char * kwnames[] = {
12723 (char *) "self",(char *) "charset",(char *) "interactive", NULL
12724 };
12725
12726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12728 if (!SWIG_IsOK(res1)) {
12729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12730 }
12731 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12732 {
12733 arg2 = wxString_in_helper(obj1);
12734 if (arg2 == NULL) SWIG_fail;
12735 temp2 = true;
12736 }
12737 if (obj2) {
12738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12739 if (!SWIG_IsOK(ecode3)) {
12740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "3"" of type '" "bool""'");
12741 }
12742 arg3 = static_cast< bool >(val3);
12743 }
12744 {
12745 PyThreadState* __tstate = wxPyBeginAllowThreads();
12746 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 resultobj = SWIG_From_int(static_cast< int >(result));
12751 {
12752 if (temp2)
12753 delete arg2;
12754 }
12755 return resultobj;
12756 fail:
12757 {
12758 if (temp2)
12759 delete arg2;
12760 }
12761 return NULL;
12762 }
12763
12764
12765 SWIGINTERN PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12766 PyObject *resultobj = 0;
12767 size_t result;
12768
12769 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetSupportedEncodingsCount",0,0,0)) SWIG_fail;
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
12773 wxPyEndAllowThreads(__tstate);
12774 if (PyErr_Occurred()) SWIG_fail;
12775 }
12776 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12777 return resultobj;
12778 fail:
12779 return NULL;
12780 }
12781
12782
12783 SWIGINTERN PyObject *_wrap_FontMapper_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12784 PyObject *resultobj = 0;
12785 size_t arg1 ;
12786 wxFontEncoding result;
12787 size_t val1 ;
12788 int ecode1 = 0 ;
12789 PyObject * obj0 = 0 ;
12790 char * kwnames[] = {
12791 (char *) "n", NULL
12792 };
12793
12794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) SWIG_fail;
12795 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12796 if (!SWIG_IsOK(ecode1)) {
12797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncoding" "', expected argument " "1"" of type '" "size_t""'");
12798 }
12799 arg1 = static_cast< size_t >(val1);
12800 {
12801 PyThreadState* __tstate = wxPyBeginAllowThreads();
12802 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 resultobj = SWIG_From_int(static_cast< int >(result));
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj = 0;
12815 wxFontEncoding arg1 ;
12816 wxString result;
12817 int val1 ;
12818 int ecode1 = 0 ;
12819 PyObject * obj0 = 0 ;
12820 char * kwnames[] = {
12821 (char *) "encoding", NULL
12822 };
12823
12824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) SWIG_fail;
12825 ecode1 = SWIG_AsVal_int(obj0, &val1);
12826 if (!SWIG_IsOK(ecode1)) {
12827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingName" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12828 }
12829 arg1 = static_cast< wxFontEncoding >(val1);
12830 {
12831 PyThreadState* __tstate = wxPyBeginAllowThreads();
12832 result = wxFontMapper::GetEncodingName(arg1);
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 {
12837 #if wxUSE_UNICODE
12838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12839 #else
12840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12841 #endif
12842 }
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj = 0;
12851 wxFontEncoding arg1 ;
12852 wxString result;
12853 int val1 ;
12854 int ecode1 = 0 ;
12855 PyObject * obj0 = 0 ;
12856 char * kwnames[] = {
12857 (char *) "encoding", NULL
12858 };
12859
12860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) SWIG_fail;
12861 ecode1 = SWIG_AsVal_int(obj0, &val1);
12862 if (!SWIG_IsOK(ecode1)) {
12863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingDescription" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12864 }
12865 arg1 = static_cast< wxFontEncoding >(val1);
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 result = wxFontMapper::GetEncodingDescription(arg1);
12869 wxPyEndAllowThreads(__tstate);
12870 if (PyErr_Occurred()) SWIG_fail;
12871 }
12872 {
12873 #if wxUSE_UNICODE
12874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12875 #else
12876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12877 #endif
12878 }
12879 return resultobj;
12880 fail:
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12886 PyObject *resultobj = 0;
12887 wxString *arg1 = 0 ;
12888 wxFontEncoding result;
12889 bool temp1 = false ;
12890 PyObject * obj0 = 0 ;
12891 char * kwnames[] = {
12892 (char *) "name", NULL
12893 };
12894
12895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) SWIG_fail;
12896 {
12897 arg1 = wxString_in_helper(obj0);
12898 if (arg1 == NULL) SWIG_fail;
12899 temp1 = true;
12900 }
12901 {
12902 PyThreadState* __tstate = wxPyBeginAllowThreads();
12903 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
12904 wxPyEndAllowThreads(__tstate);
12905 if (PyErr_Occurred()) SWIG_fail;
12906 }
12907 resultobj = SWIG_From_int(static_cast< int >(result));
12908 {
12909 if (temp1)
12910 delete arg1;
12911 }
12912 return resultobj;
12913 fail:
12914 {
12915 if (temp1)
12916 delete arg1;
12917 }
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_FontMapper_SetConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12923 PyObject *resultobj = 0;
12924 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12925 wxString *arg2 = 0 ;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 bool temp2 = false ;
12929 PyObject * obj0 = 0 ;
12930 PyObject * obj1 = 0 ;
12931 char * kwnames[] = {
12932 (char *) "self",(char *) "prefix", NULL
12933 };
12934
12935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) SWIG_fail;
12936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12937 if (!SWIG_IsOK(res1)) {
12938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetConfigPath" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12939 }
12940 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12941 {
12942 arg2 = wxString_in_helper(obj1);
12943 if (arg2 == NULL) SWIG_fail;
12944 temp2 = true;
12945 }
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 (arg1)->SetConfigPath((wxString const &)*arg2);
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 resultobj = SWIG_Py_Void();
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return resultobj;
12958 fail:
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *resultobj = 0;
12969 wxString result;
12970
12971 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetDefaultConfigPath",0,0,0)) SWIG_fail;
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 result = wxFontMapper::GetDefaultConfigPath();
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 #if wxUSE_UNICODE
12980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12981 #else
12982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12983 #endif
12984 }
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = 0;
12993 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12994 wxFontEncoding arg2 ;
12995 wxString const &arg3_defvalue = wxPyEmptyString ;
12996 wxString *arg3 = (wxString *) &arg3_defvalue ;
12997 bool arg4 = (bool) true ;
12998 PyObject *result = 0 ;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 int val2 ;
13002 int ecode2 = 0 ;
13003 bool temp3 = false ;
13004 bool val4 ;
13005 int ecode4 = 0 ;
13006 PyObject * obj0 = 0 ;
13007 PyObject * obj1 = 0 ;
13008 PyObject * obj2 = 0 ;
13009 PyObject * obj3 = 0 ;
13010 char * kwnames[] = {
13011 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
13012 };
13013
13014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13016 if (!SWIG_IsOK(res1)) {
13017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13018 }
13019 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13020 ecode2 = SWIG_AsVal_int(obj1, &val2);
13021 if (!SWIG_IsOK(ecode2)) {
13022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13023 }
13024 arg2 = static_cast< wxFontEncoding >(val2);
13025 if (obj2) {
13026 {
13027 arg3 = wxString_in_helper(obj2);
13028 if (arg3 == NULL) SWIG_fail;
13029 temp3 = true;
13030 }
13031 }
13032 if (obj3) {
13033 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13034 if (!SWIG_IsOK(ecode4)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "4"" of type '" "bool""'");
13036 }
13037 arg4 = static_cast< bool >(val4);
13038 }
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,arg2,(wxString const &)*arg3,arg4);
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 resultobj = result;
13046 {
13047 if (temp3)
13048 delete arg3;
13049 }
13050 return resultobj;
13051 fail:
13052 {
13053 if (temp3)
13054 delete arg3;
13055 }
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj = 0;
13062 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13063 wxFontEncoding arg2 ;
13064 wxString const &arg3_defvalue = wxPyEmptyString ;
13065 wxString *arg3 = (wxString *) &arg3_defvalue ;
13066 bool result;
13067 void *argp1 = 0 ;
13068 int res1 = 0 ;
13069 int val2 ;
13070 int ecode2 = 0 ;
13071 bool temp3 = false ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 PyObject * obj2 = 0 ;
13075 char * kwnames[] = {
13076 (char *) "self",(char *) "encoding",(char *) "facename", NULL
13077 };
13078
13079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13081 if (!SWIG_IsOK(res1)) {
13082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13083 }
13084 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13085 ecode2 = SWIG_AsVal_int(obj1, &val2);
13086 if (!SWIG_IsOK(ecode2)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13088 }
13089 arg2 = static_cast< wxFontEncoding >(val2);
13090 if (obj2) {
13091 {
13092 arg3 = wxString_in_helper(obj2);
13093 if (arg3 == NULL) SWIG_fail;
13094 temp3 = true;
13095 }
13096 }
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 result = (bool)(arg1)->IsEncodingAvailable(arg2,(wxString const &)*arg3);
13100 wxPyEndAllowThreads(__tstate);
13101 if (PyErr_Occurred()) SWIG_fail;
13102 }
13103 {
13104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13105 }
13106 {
13107 if (temp3)
13108 delete arg3;
13109 }
13110 return resultobj;
13111 fail:
13112 {
13113 if (temp3)
13114 delete arg3;
13115 }
13116 return NULL;
13117 }
13118
13119
13120 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13121 PyObject *resultobj = 0;
13122 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13123 wxWindow *arg2 = (wxWindow *) 0 ;
13124 void *argp1 = 0 ;
13125 int res1 = 0 ;
13126 void *argp2 = 0 ;
13127 int res2 = 0 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char * kwnames[] = {
13131 (char *) "self",(char *) "parent", NULL
13132 };
13133
13134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) SWIG_fail;
13135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogParent" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13138 }
13139 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
13141 if (!SWIG_IsOK(res2)) {
13142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontMapper_SetDialogParent" "', expected argument " "2"" of type '" "wxWindow *""'");
13143 }
13144 arg2 = reinterpret_cast< wxWindow * >(argp2);
13145 {
13146 PyThreadState* __tstate = wxPyBeginAllowThreads();
13147 (arg1)->SetDialogParent(arg2);
13148 wxPyEndAllowThreads(__tstate);
13149 if (PyErr_Occurred()) SWIG_fail;
13150 }
13151 resultobj = SWIG_Py_Void();
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj = 0;
13160 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13161 wxString *arg2 = 0 ;
13162 void *argp1 = 0 ;
13163 int res1 = 0 ;
13164 bool temp2 = false ;
13165 PyObject * obj0 = 0 ;
13166 PyObject * obj1 = 0 ;
13167 char * kwnames[] = {
13168 (char *) "self",(char *) "title", NULL
13169 };
13170
13171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) SWIG_fail;
13172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13173 if (!SWIG_IsOK(res1)) {
13174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogTitle" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13175 }
13176 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13177 {
13178 arg2 = wxString_in_helper(obj1);
13179 if (arg2 == NULL) SWIG_fail;
13180 temp2 = true;
13181 }
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 (arg1)->SetDialogTitle((wxString const &)*arg2);
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 resultobj = SWIG_Py_Void();
13189 {
13190 if (temp2)
13191 delete arg2;
13192 }
13193 return resultobj;
13194 fail:
13195 {
13196 if (temp2)
13197 delete arg2;
13198 }
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *FontMapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13204 PyObject *obj;
13205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13206 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontMapper, SWIG_NewClientData(obj));
13207 return SWIG_Py_Void();
13208 }
13209
13210 SWIGINTERN PyObject *FontMapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13211 return SWIG_Python_InitShadowInstance(args);
13212 }
13213
13214 SWIGINTERN PyObject *_wrap_new_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = 0;
13216 int arg1 ;
13217 int arg2 ;
13218 int arg3 ;
13219 int arg4 ;
13220 bool arg5 = (bool) false ;
13221 wxString const &arg6_defvalue = wxPyEmptyString ;
13222 wxString *arg6 = (wxString *) &arg6_defvalue ;
13223 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13224 wxFont *result = 0 ;
13225 int val1 ;
13226 int ecode1 = 0 ;
13227 int val2 ;
13228 int ecode2 = 0 ;
13229 int val3 ;
13230 int ecode3 = 0 ;
13231 int val4 ;
13232 int ecode4 = 0 ;
13233 bool val5 ;
13234 int ecode5 = 0 ;
13235 bool temp6 = false ;
13236 int val7 ;
13237 int ecode7 = 0 ;
13238 PyObject * obj0 = 0 ;
13239 PyObject * obj1 = 0 ;
13240 PyObject * obj2 = 0 ;
13241 PyObject * obj3 = 0 ;
13242 PyObject * obj4 = 0 ;
13243 PyObject * obj5 = 0 ;
13244 PyObject * obj6 = 0 ;
13245 char * kwnames[] = {
13246 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
13247 };
13248
13249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13250 ecode1 = SWIG_AsVal_int(obj0, &val1);
13251 if (!SWIG_IsOK(ecode1)) {
13252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Font" "', expected argument " "1"" of type '" "int""'");
13253 }
13254 arg1 = static_cast< int >(val1);
13255 ecode2 = SWIG_AsVal_int(obj1, &val2);
13256 if (!SWIG_IsOK(ecode2)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Font" "', expected argument " "2"" of type '" "int""'");
13258 }
13259 arg2 = static_cast< int >(val2);
13260 ecode3 = SWIG_AsVal_int(obj2, &val3);
13261 if (!SWIG_IsOK(ecode3)) {
13262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Font" "', expected argument " "3"" of type '" "int""'");
13263 }
13264 arg3 = static_cast< int >(val3);
13265 ecode4 = SWIG_AsVal_int(obj3, &val4);
13266 if (!SWIG_IsOK(ecode4)) {
13267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Font" "', expected argument " "4"" of type '" "int""'");
13268 }
13269 arg4 = static_cast< int >(val4);
13270 if (obj4) {
13271 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13272 if (!SWIG_IsOK(ecode5)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Font" "', expected argument " "5"" of type '" "bool""'");
13274 }
13275 arg5 = static_cast< bool >(val5);
13276 }
13277 if (obj5) {
13278 {
13279 arg6 = wxString_in_helper(obj5);
13280 if (arg6 == NULL) SWIG_fail;
13281 temp6 = true;
13282 }
13283 }
13284 if (obj6) {
13285 ecode7 = SWIG_AsVal_int(obj6, &val7);
13286 if (!SWIG_IsOK(ecode7)) {
13287 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Font" "', expected argument " "7"" of type '" "wxFontEncoding""'");
13288 }
13289 arg7 = static_cast< wxFontEncoding >(val7);
13290 }
13291 {
13292 if (!wxPyCheckForApp()) SWIG_fail;
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_NEW | 0 );
13299 {
13300 if (temp6)
13301 delete arg6;
13302 }
13303 return resultobj;
13304 fail:
13305 {
13306 if (temp6)
13307 delete arg6;
13308 }
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_delete_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13314 PyObject *resultobj = 0;
13315 wxFont *arg1 = (wxFont *) 0 ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 PyObject *swig_obj[1] ;
13319
13320 if (!args) SWIG_fail;
13321 swig_obj[0] = args;
13322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, SWIG_POINTER_DISOWN | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Font" "', expected argument " "1"" of type '" "wxFont *""'");
13325 }
13326 arg1 = reinterpret_cast< wxFont * >(argp1);
13327 {
13328 PyThreadState* __tstate = wxPyBeginAllowThreads();
13329 delete arg1;
13330
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 resultobj = SWIG_Py_Void();
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj = 0;
13343 wxNativeFontInfo *arg1 = 0 ;
13344 wxFont *result = 0 ;
13345 void *argp1 = 0 ;
13346 int res1 = 0 ;
13347 PyObject * obj0 = 0 ;
13348 char * kwnames[] = {
13349 (char *) "info", NULL
13350 };
13351
13352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) SWIG_fail;
13353 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
13354 if (!SWIG_IsOK(res1)) {
13355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
13356 }
13357 if (!argp1) {
13358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
13359 }
13360 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
13361 {
13362 if (!wxPyCheckForApp()) SWIG_fail;
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfoString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj = 0;
13377 wxString *arg1 = 0 ;
13378 wxFont *result = 0 ;
13379 bool temp1 = false ;
13380 PyObject * obj0 = 0 ;
13381 char * kwnames[] = {
13382 (char *) "info", NULL
13383 };
13384
13385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) SWIG_fail;
13386 {
13387 arg1 = wxString_in_helper(obj0);
13388 if (arg1 == NULL) SWIG_fail;
13389 temp1 = true;
13390 }
13391 {
13392 if (!wxPyCheckForApp()) SWIG_fail;
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxFont *)new_wxFont((wxString const &)*arg1);
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13399 {
13400 if (temp1)
13401 delete arg1;
13402 }
13403 return resultobj;
13404 fail:
13405 {
13406 if (temp1)
13407 delete arg1;
13408 }
13409 return NULL;
13410 }
13411
13412
13413 SWIGINTERN PyObject *_wrap_new_FFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj = 0;
13415 int arg1 ;
13416 wxFontFamily arg2 ;
13417 int arg3 = (int) wxFONTFLAG_DEFAULT ;
13418 wxString const &arg4_defvalue = wxPyEmptyString ;
13419 wxString *arg4 = (wxString *) &arg4_defvalue ;
13420 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13421 wxFont *result = 0 ;
13422 int val1 ;
13423 int ecode1 = 0 ;
13424 int val2 ;
13425 int ecode2 = 0 ;
13426 int val3 ;
13427 int ecode3 = 0 ;
13428 bool temp4 = false ;
13429 int val5 ;
13430 int ecode5 = 0 ;
13431 PyObject * obj0 = 0 ;
13432 PyObject * obj1 = 0 ;
13433 PyObject * obj2 = 0 ;
13434 PyObject * obj3 = 0 ;
13435 PyObject * obj4 = 0 ;
13436 char * kwnames[] = {
13437 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
13438 };
13439
13440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13441 ecode1 = SWIG_AsVal_int(obj0, &val1);
13442 if (!SWIG_IsOK(ecode1)) {
13443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FFont" "', expected argument " "1"" of type '" "int""'");
13444 }
13445 arg1 = static_cast< int >(val1);
13446 ecode2 = SWIG_AsVal_int(obj1, &val2);
13447 if (!SWIG_IsOK(ecode2)) {
13448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFont" "', expected argument " "2"" of type '" "wxFontFamily""'");
13449 }
13450 arg2 = static_cast< wxFontFamily >(val2);
13451 if (obj2) {
13452 ecode3 = SWIG_AsVal_int(obj2, &val3);
13453 if (!SWIG_IsOK(ecode3)) {
13454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFont" "', expected argument " "3"" of type '" "int""'");
13455 }
13456 arg3 = static_cast< int >(val3);
13457 }
13458 if (obj3) {
13459 {
13460 arg4 = wxString_in_helper(obj3);
13461 if (arg4 == NULL) SWIG_fail;
13462 temp4 = true;
13463 }
13464 }
13465 if (obj4) {
13466 ecode5 = SWIG_AsVal_int(obj4, &val5);
13467 if (!SWIG_IsOK(ecode5)) {
13468 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFont" "', expected argument " "5"" of type '" "wxFontEncoding""'");
13469 }
13470 arg5 = static_cast< wxFontEncoding >(val5);
13471 }
13472 {
13473 if (!wxPyCheckForApp()) SWIG_fail;
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (wxFont *)new_wxFont(arg1,arg2,arg3,(wxString const &)*arg4,arg5);
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13480 {
13481 if (temp4)
13482 delete arg4;
13483 }
13484 return resultobj;
13485 fail:
13486 {
13487 if (temp4)
13488 delete arg4;
13489 }
13490 return NULL;
13491 }
13492
13493
13494 SWIGINTERN PyObject *_wrap_new_FontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj = 0;
13496 wxSize *arg1 = 0 ;
13497 int arg2 ;
13498 int arg3 ;
13499 int arg4 ;
13500 bool arg5 = (bool) false ;
13501 wxString const &arg6_defvalue = wxEmptyString ;
13502 wxString *arg6 = (wxString *) &arg6_defvalue ;
13503 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13504 wxFont *result = 0 ;
13505 wxSize temp1 ;
13506 int val2 ;
13507 int ecode2 = 0 ;
13508 int val3 ;
13509 int ecode3 = 0 ;
13510 int val4 ;
13511 int ecode4 = 0 ;
13512 bool val5 ;
13513 int ecode5 = 0 ;
13514 bool temp6 = false ;
13515 int val7 ;
13516 int ecode7 = 0 ;
13517 PyObject * obj0 = 0 ;
13518 PyObject * obj1 = 0 ;
13519 PyObject * obj2 = 0 ;
13520 PyObject * obj3 = 0 ;
13521 PyObject * obj4 = 0 ;
13522 PyObject * obj5 = 0 ;
13523 PyObject * obj6 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13529 {
13530 arg1 = &temp1;
13531 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
13532 }
13533 ecode2 = SWIG_AsVal_int(obj1, &val2);
13534 if (!SWIG_IsOK(ecode2)) {
13535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontFromPixelSize" "', expected argument " "2"" of type '" "int""'");
13536 }
13537 arg2 = static_cast< int >(val2);
13538 ecode3 = SWIG_AsVal_int(obj2, &val3);
13539 if (!SWIG_IsOK(ecode3)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
13541 }
13542 arg3 = static_cast< int >(val3);
13543 ecode4 = SWIG_AsVal_int(obj3, &val4);
13544 if (!SWIG_IsOK(ecode4)) {
13545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FontFromPixelSize" "', expected argument " "4"" of type '" "int""'");
13546 }
13547 arg4 = static_cast< int >(val4);
13548 if (obj4) {
13549 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13550 if (!SWIG_IsOK(ecode5)) {
13551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FontFromPixelSize" "', expected argument " "5"" of type '" "bool""'");
13552 }
13553 arg5 = static_cast< bool >(val5);
13554 }
13555 if (obj5) {
13556 {
13557 arg6 = wxString_in_helper(obj5);
13558 if (arg6 == NULL) SWIG_fail;
13559 temp6 = true;
13560 }
13561 }
13562 if (obj6) {
13563 ecode7 = SWIG_AsVal_int(obj6, &val7);
13564 if (!SWIG_IsOK(ecode7)) {
13565 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FontFromPixelSize" "', expected argument " "7"" of type '" "wxFontEncoding""'");
13566 }
13567 arg7 = static_cast< wxFontEncoding >(val7);
13568 }
13569 {
13570 if (!wxPyCheckForApp()) SWIG_fail;
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
13573 wxPyEndAllowThreads(__tstate);
13574 if (PyErr_Occurred()) SWIG_fail;
13575 }
13576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13577 {
13578 if (temp6)
13579 delete arg6;
13580 }
13581 return resultobj;
13582 fail:
13583 {
13584 if (temp6)
13585 delete arg6;
13586 }
13587 return NULL;
13588 }
13589
13590
13591 SWIGINTERN PyObject *_wrap_new_FFontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13592 PyObject *resultobj = 0;
13593 wxSize *arg1 = 0 ;
13594 wxFontFamily arg2 ;
13595 int arg3 = (int) wxFONTFLAG_DEFAULT ;
13596 wxString const &arg4_defvalue = wxEmptyString ;
13597 wxString *arg4 = (wxString *) &arg4_defvalue ;
13598 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13599 wxFont *result = 0 ;
13600 wxSize temp1 ;
13601 int val2 ;
13602 int ecode2 = 0 ;
13603 int val3 ;
13604 int ecode3 = 0 ;
13605 bool temp4 = false ;
13606 int val5 ;
13607 int ecode5 = 0 ;
13608 PyObject * obj0 = 0 ;
13609 PyObject * obj1 = 0 ;
13610 PyObject * obj2 = 0 ;
13611 PyObject * obj3 = 0 ;
13612 PyObject * obj4 = 0 ;
13613 char * kwnames[] = {
13614 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
13615 };
13616
13617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13618 {
13619 arg1 = &temp1;
13620 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
13621 }
13622 ecode2 = SWIG_AsVal_int(obj1, &val2);
13623 if (!SWIG_IsOK(ecode2)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFontFromPixelSize" "', expected argument " "2"" of type '" "wxFontFamily""'");
13625 }
13626 arg2 = static_cast< wxFontFamily >(val2);
13627 if (obj2) {
13628 ecode3 = SWIG_AsVal_int(obj2, &val3);
13629 if (!SWIG_IsOK(ecode3)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
13631 }
13632 arg3 = static_cast< int >(val3);
13633 }
13634 if (obj3) {
13635 {
13636 arg4 = wxString_in_helper(obj3);
13637 if (arg4 == NULL) SWIG_fail;
13638 temp4 = true;
13639 }
13640 }
13641 if (obj4) {
13642 ecode5 = SWIG_AsVal_int(obj4, &val5);
13643 if (!SWIG_IsOK(ecode5)) {
13644 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFontFromPixelSize" "', expected argument " "5"" of type '" "wxFontEncoding""'");
13645 }
13646 arg5 = static_cast< wxFontEncoding >(val5);
13647 }
13648 {
13649 if (!wxPyCheckForApp()) SWIG_fail;
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,(wxString const &)*arg4,arg5);
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13656 {
13657 if (temp4)
13658 delete arg4;
13659 }
13660 return resultobj;
13661 fail:
13662 {
13663 if (temp4)
13664 delete arg4;
13665 }
13666 return NULL;
13667 }
13668
13669
13670 SWIGINTERN PyObject *_wrap_Font_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13671 PyObject *resultobj = 0;
13672 wxFont *arg1 = (wxFont *) 0 ;
13673 bool result;
13674 void *argp1 = 0 ;
13675 int res1 = 0 ;
13676 PyObject *swig_obj[1] ;
13677
13678 if (!args) SWIG_fail;
13679 swig_obj[0] = args;
13680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13681 if (!SWIG_IsOK(res1)) {
13682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_Ok" "', expected argument " "1"" of type '" "wxFont const *""'");
13683 }
13684 arg1 = reinterpret_cast< wxFont * >(argp1);
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 result = (bool)((wxFont const *)arg1)->Ok();
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 {
13692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13693 }
13694 return resultobj;
13695 fail:
13696 return NULL;
13697 }
13698
13699
13700 SWIGINTERN PyObject *_wrap_Font___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13701 PyObject *resultobj = 0;
13702 wxFont *arg1 = (wxFont *) 0 ;
13703 wxFont *arg2 = (wxFont *) 0 ;
13704 bool result;
13705 void *argp1 = 0 ;
13706 int res1 = 0 ;
13707 void *argp2 = 0 ;
13708 int res2 = 0 ;
13709 PyObject * obj0 = 0 ;
13710 PyObject * obj1 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "self",(char *) "other", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
13716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___eq__" "', expected argument " "1"" of type '" "wxFont *""'");
13719 }
13720 arg1 = reinterpret_cast< wxFont * >(argp1);
13721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
13722 if (!SWIG_IsOK(res2)) {
13723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___eq__" "', expected argument " "2"" of type '" "wxFont const *""'");
13724 }
13725 arg2 = reinterpret_cast< wxFont * >(argp2);
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
13729 wxPyEndAllowThreads(__tstate);
13730 if (PyErr_Occurred()) SWIG_fail;
13731 }
13732 {
13733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13734 }
13735 return resultobj;
13736 fail:
13737 return NULL;
13738 }
13739
13740
13741 SWIGINTERN PyObject *_wrap_Font___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 wxFont *arg1 = (wxFont *) 0 ;
13744 wxFont *arg2 = (wxFont *) 0 ;
13745 bool result;
13746 void *argp1 = 0 ;
13747 int res1 = 0 ;
13748 void *argp2 = 0 ;
13749 int res2 = 0 ;
13750 PyObject * obj0 = 0 ;
13751 PyObject * obj1 = 0 ;
13752 char * kwnames[] = {
13753 (char *) "self",(char *) "other", NULL
13754 };
13755
13756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
13757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13758 if (!SWIG_IsOK(res1)) {
13759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___ne__" "', expected argument " "1"" of type '" "wxFont *""'");
13760 }
13761 arg1 = reinterpret_cast< wxFont * >(argp1);
13762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
13763 if (!SWIG_IsOK(res2)) {
13764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___ne__" "', expected argument " "2"" of type '" "wxFont const *""'");
13765 }
13766 arg2 = reinterpret_cast< wxFont * >(argp2);
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 {
13774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13775 }
13776 return resultobj;
13777 fail:
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *_wrap_Font_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13783 PyObject *resultobj = 0;
13784 wxFont *arg1 = (wxFont *) 0 ;
13785 int result;
13786 void *argp1 = 0 ;
13787 int res1 = 0 ;
13788 PyObject *swig_obj[1] ;
13789
13790 if (!args) SWIG_fail;
13791 swig_obj[0] = args;
13792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13793 if (!SWIG_IsOK(res1)) {
13794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPointSize" "', expected argument " "1"" of type '" "wxFont const *""'");
13795 }
13796 arg1 = reinterpret_cast< wxFont * >(argp1);
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 result = (int)((wxFont const *)arg1)->GetPointSize();
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_From_int(static_cast< int >(result));
13804 return resultobj;
13805 fail:
13806 return NULL;
13807 }
13808
13809
13810 SWIGINTERN PyObject *_wrap_Font_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13811 PyObject *resultobj = 0;
13812 wxFont *arg1 = (wxFont *) 0 ;
13813 wxSize result;
13814 void *argp1 = 0 ;
13815 int res1 = 0 ;
13816 PyObject *swig_obj[1] ;
13817
13818 if (!args) SWIG_fail;
13819 swig_obj[0] = args;
13820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13821 if (!SWIG_IsOK(res1)) {
13822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPixelSize" "', expected argument " "1"" of type '" "wxFont const *""'");
13823 }
13824 arg1 = reinterpret_cast< wxFont * >(argp1);
13825 {
13826 PyThreadState* __tstate = wxPyBeginAllowThreads();
13827 result = ((wxFont const *)arg1)->GetPixelSize();
13828 wxPyEndAllowThreads(__tstate);
13829 if (PyErr_Occurred()) SWIG_fail;
13830 }
13831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
13832 return resultobj;
13833 fail:
13834 return NULL;
13835 }
13836
13837
13838 SWIGINTERN PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13839 PyObject *resultobj = 0;
13840 wxFont *arg1 = (wxFont *) 0 ;
13841 bool result;
13842 void *argp1 = 0 ;
13843 int res1 = 0 ;
13844 PyObject *swig_obj[1] ;
13845
13846 if (!args) SWIG_fail;
13847 swig_obj[0] = args;
13848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13849 if (!SWIG_IsOK(res1)) {
13850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsUsingSizeInPixels" "', expected argument " "1"" of type '" "wxFont const *""'");
13851 }
13852 arg1 = reinterpret_cast< wxFont * >(argp1);
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 {
13860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13861 }
13862 return resultobj;
13863 fail:
13864 return NULL;
13865 }
13866
13867
13868 SWIGINTERN PyObject *_wrap_Font_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13869 PyObject *resultobj = 0;
13870 wxFont *arg1 = (wxFont *) 0 ;
13871 int result;
13872 void *argp1 = 0 ;
13873 int res1 = 0 ;
13874 PyObject *swig_obj[1] ;
13875
13876 if (!args) SWIG_fail;
13877 swig_obj[0] = args;
13878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13879 if (!SWIG_IsOK(res1)) {
13880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamily" "', expected argument " "1"" of type '" "wxFont const *""'");
13881 }
13882 arg1 = reinterpret_cast< wxFont * >(argp1);
13883 {
13884 PyThreadState* __tstate = wxPyBeginAllowThreads();
13885 result = (int)((wxFont const *)arg1)->GetFamily();
13886 wxPyEndAllowThreads(__tstate);
13887 if (PyErr_Occurred()) SWIG_fail;
13888 }
13889 resultobj = SWIG_From_int(static_cast< int >(result));
13890 return resultobj;
13891 fail:
13892 return NULL;
13893 }
13894
13895
13896 SWIGINTERN PyObject *_wrap_Font_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13897 PyObject *resultobj = 0;
13898 wxFont *arg1 = (wxFont *) 0 ;
13899 int result;
13900 void *argp1 = 0 ;
13901 int res1 = 0 ;
13902 PyObject *swig_obj[1] ;
13903
13904 if (!args) SWIG_fail;
13905 swig_obj[0] = args;
13906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13907 if (!SWIG_IsOK(res1)) {
13908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyle" "', expected argument " "1"" of type '" "wxFont const *""'");
13909 }
13910 arg1 = reinterpret_cast< wxFont * >(argp1);
13911 {
13912 PyThreadState* __tstate = wxPyBeginAllowThreads();
13913 result = (int)((wxFont const *)arg1)->GetStyle();
13914 wxPyEndAllowThreads(__tstate);
13915 if (PyErr_Occurred()) SWIG_fail;
13916 }
13917 resultobj = SWIG_From_int(static_cast< int >(result));
13918 return resultobj;
13919 fail:
13920 return NULL;
13921 }
13922
13923
13924 SWIGINTERN PyObject *_wrap_Font_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13925 PyObject *resultobj = 0;
13926 wxFont *arg1 = (wxFont *) 0 ;
13927 int result;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 PyObject *swig_obj[1] ;
13931
13932 if (!args) SWIG_fail;
13933 swig_obj[0] = args;
13934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13935 if (!SWIG_IsOK(res1)) {
13936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeight" "', expected argument " "1"" of type '" "wxFont const *""'");
13937 }
13938 arg1 = reinterpret_cast< wxFont * >(argp1);
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 result = (int)((wxFont const *)arg1)->GetWeight();
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 resultobj = SWIG_From_int(static_cast< int >(result));
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 SWIGINTERN PyObject *_wrap_Font_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13953 PyObject *resultobj = 0;
13954 wxFont *arg1 = (wxFont *) 0 ;
13955 bool result;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 PyObject *swig_obj[1] ;
13959
13960 if (!args) SWIG_fail;
13961 swig_obj[0] = args;
13962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13963 if (!SWIG_IsOK(res1)) {
13964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetUnderlined" "', expected argument " "1"" of type '" "wxFont const *""'");
13965 }
13966 arg1 = reinterpret_cast< wxFont * >(argp1);
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 result = (bool)((wxFont const *)arg1)->GetUnderlined();
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 {
13974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13975 }
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 SWIGINTERN PyObject *_wrap_Font_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13983 PyObject *resultobj = 0;
13984 wxFont *arg1 = (wxFont *) 0 ;
13985 wxString result;
13986 void *argp1 = 0 ;
13987 int res1 = 0 ;
13988 PyObject *swig_obj[1] ;
13989
13990 if (!args) SWIG_fail;
13991 swig_obj[0] = args;
13992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13993 if (!SWIG_IsOK(res1)) {
13994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFaceName" "', expected argument " "1"" of type '" "wxFont const *""'");
13995 }
13996 arg1 = reinterpret_cast< wxFont * >(argp1);
13997 {
13998 PyThreadState* __tstate = wxPyBeginAllowThreads();
13999 result = ((wxFont const *)arg1)->GetFaceName();
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 {
14004 #if wxUSE_UNICODE
14005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14006 #else
14007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14008 #endif
14009 }
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 SWIGINTERN PyObject *_wrap_Font_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14017 PyObject *resultobj = 0;
14018 wxFont *arg1 = (wxFont *) 0 ;
14019 wxFontEncoding result;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 PyObject *swig_obj[1] ;
14023
14024 if (!args) SWIG_fail;
14025 swig_obj[0] = args;
14026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetEncoding" "', expected argument " "1"" of type '" "wxFont const *""'");
14029 }
14030 arg1 = reinterpret_cast< wxFont * >(argp1);
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
14034 wxPyEndAllowThreads(__tstate);
14035 if (PyErr_Occurred()) SWIG_fail;
14036 }
14037 resultobj = SWIG_From_int(static_cast< int >(result));
14038 return resultobj;
14039 fail:
14040 return NULL;
14041 }
14042
14043
14044 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14045 PyObject *resultobj = 0;
14046 wxFont *arg1 = (wxFont *) 0 ;
14047 wxNativeFontInfo *result = 0 ;
14048 void *argp1 = 0 ;
14049 int res1 = 0 ;
14050 PyObject *swig_obj[1] ;
14051
14052 if (!args) SWIG_fail;
14053 swig_obj[0] = args;
14054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14055 if (!SWIG_IsOK(res1)) {
14056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont const *""'");
14057 }
14058 arg1 = reinterpret_cast< wxFont * >(argp1);
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
14066 return resultobj;
14067 fail:
14068 return NULL;
14069 }
14070
14071
14072 SWIGINTERN PyObject *_wrap_Font_IsFixedWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 PyObject *resultobj = 0;
14074 wxFont *arg1 = (wxFont *) 0 ;
14075 bool result;
14076 void *argp1 = 0 ;
14077 int res1 = 0 ;
14078 PyObject *swig_obj[1] ;
14079
14080 if (!args) SWIG_fail;
14081 swig_obj[0] = args;
14082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14083 if (!SWIG_IsOK(res1)) {
14084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsFixedWidth" "', expected argument " "1"" of type '" "wxFont const *""'");
14085 }
14086 arg1 = reinterpret_cast< wxFont * >(argp1);
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14095 }
14096 return resultobj;
14097 fail:
14098 return NULL;
14099 }
14100
14101
14102 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14103 PyObject *resultobj = 0;
14104 wxFont *arg1 = (wxFont *) 0 ;
14105 wxString result;
14106 void *argp1 = 0 ;
14107 int res1 = 0 ;
14108 PyObject *swig_obj[1] ;
14109
14110 if (!args) SWIG_fail;
14111 swig_obj[0] = args;
14112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14113 if (!SWIG_IsOK(res1)) {
14114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14115 }
14116 arg1 = reinterpret_cast< wxFont * >(argp1);
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
14120 wxPyEndAllowThreads(__tstate);
14121 if (PyErr_Occurred()) SWIG_fail;
14122 }
14123 {
14124 #if wxUSE_UNICODE
14125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14126 #else
14127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14128 #endif
14129 }
14130 return resultobj;
14131 fail:
14132 return NULL;
14133 }
14134
14135
14136 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14137 PyObject *resultobj = 0;
14138 wxFont *arg1 = (wxFont *) 0 ;
14139 wxString result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 PyObject *swig_obj[1] ;
14143
14144 if (!args) SWIG_fail;
14145 swig_obj[0] = args;
14146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14147 if (!SWIG_IsOK(res1)) {
14148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14149 }
14150 arg1 = reinterpret_cast< wxFont * >(argp1);
14151 {
14152 PyThreadState* __tstate = wxPyBeginAllowThreads();
14153 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 {
14158 #if wxUSE_UNICODE
14159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14160 #else
14161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14162 #endif
14163 }
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 SWIGINTERN PyObject *_wrap_Font_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14171 PyObject *resultobj = 0;
14172 wxFont *arg1 = (wxFont *) 0 ;
14173 int arg2 ;
14174 void *argp1 = 0 ;
14175 int res1 = 0 ;
14176 int val2 ;
14177 int ecode2 = 0 ;
14178 PyObject * obj0 = 0 ;
14179 PyObject * obj1 = 0 ;
14180 char * kwnames[] = {
14181 (char *) "self",(char *) "pointSize", NULL
14182 };
14183
14184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
14185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14186 if (!SWIG_IsOK(res1)) {
14187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPointSize" "', expected argument " "1"" of type '" "wxFont *""'");
14188 }
14189 arg1 = reinterpret_cast< wxFont * >(argp1);
14190 ecode2 = SWIG_AsVal_int(obj1, &val2);
14191 if (!SWIG_IsOK(ecode2)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetPointSize" "', expected argument " "2"" of type '" "int""'");
14193 }
14194 arg2 = static_cast< int >(val2);
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 (arg1)->SetPointSize(arg2);
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = SWIG_Py_Void();
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_Font_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj = 0;
14210 wxFont *arg1 = (wxFont *) 0 ;
14211 wxSize *arg2 = 0 ;
14212 void *argp1 = 0 ;
14213 int res1 = 0 ;
14214 wxSize temp2 ;
14215 PyObject * obj0 = 0 ;
14216 PyObject * obj1 = 0 ;
14217 char * kwnames[] = {
14218 (char *) "self",(char *) "pixelSize", NULL
14219 };
14220
14221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
14222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14223 if (!SWIG_IsOK(res1)) {
14224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPixelSize" "', expected argument " "1"" of type '" "wxFont *""'");
14225 }
14226 arg1 = reinterpret_cast< wxFont * >(argp1);
14227 {
14228 arg2 = &temp2;
14229 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14230 }
14231 {
14232 PyThreadState* __tstate = wxPyBeginAllowThreads();
14233 (arg1)->SetPixelSize((wxSize const &)*arg2);
14234 wxPyEndAllowThreads(__tstate);
14235 if (PyErr_Occurred()) SWIG_fail;
14236 }
14237 resultobj = SWIG_Py_Void();
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 SWIGINTERN PyObject *_wrap_Font_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj = 0;
14246 wxFont *arg1 = (wxFont *) 0 ;
14247 int arg2 ;
14248 void *argp1 = 0 ;
14249 int res1 = 0 ;
14250 int val2 ;
14251 int ecode2 = 0 ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char * kwnames[] = {
14255 (char *) "self",(char *) "family", NULL
14256 };
14257
14258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
14259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14260 if (!SWIG_IsOK(res1)) {
14261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFamily" "', expected argument " "1"" of type '" "wxFont *""'");
14262 }
14263 arg1 = reinterpret_cast< wxFont * >(argp1);
14264 ecode2 = SWIG_AsVal_int(obj1, &val2);
14265 if (!SWIG_IsOK(ecode2)) {
14266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetFamily" "', expected argument " "2"" of type '" "int""'");
14267 }
14268 arg2 = static_cast< int >(val2);
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 (arg1)->SetFamily(arg2);
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 resultobj = SWIG_Py_Void();
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 SWIGINTERN PyObject *_wrap_Font_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj = 0;
14284 wxFont *arg1 = (wxFont *) 0 ;
14285 int arg2 ;
14286 void *argp1 = 0 ;
14287 int res1 = 0 ;
14288 int val2 ;
14289 int ecode2 = 0 ;
14290 PyObject * obj0 = 0 ;
14291 PyObject * obj1 = 0 ;
14292 char * kwnames[] = {
14293 (char *) "self",(char *) "style", NULL
14294 };
14295
14296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
14297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetStyle" "', expected argument " "1"" of type '" "wxFont *""'");
14300 }
14301 arg1 = reinterpret_cast< wxFont * >(argp1);
14302 ecode2 = SWIG_AsVal_int(obj1, &val2);
14303 if (!SWIG_IsOK(ecode2)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetStyle" "', expected argument " "2"" of type '" "int""'");
14305 }
14306 arg2 = static_cast< int >(val2);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 (arg1)->SetStyle(arg2);
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 resultobj = SWIG_Py_Void();
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 SWIGINTERN PyObject *_wrap_Font_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj = 0;
14322 wxFont *arg1 = (wxFont *) 0 ;
14323 int arg2 ;
14324 void *argp1 = 0 ;
14325 int res1 = 0 ;
14326 int val2 ;
14327 int ecode2 = 0 ;
14328 PyObject * obj0 = 0 ;
14329 PyObject * obj1 = 0 ;
14330 char * kwnames[] = {
14331 (char *) "self",(char *) "weight", NULL
14332 };
14333
14334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
14335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14336 if (!SWIG_IsOK(res1)) {
14337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetWeight" "', expected argument " "1"" of type '" "wxFont *""'");
14338 }
14339 arg1 = reinterpret_cast< wxFont * >(argp1);
14340 ecode2 = SWIG_AsVal_int(obj1, &val2);
14341 if (!SWIG_IsOK(ecode2)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetWeight" "', expected argument " "2"" of type '" "int""'");
14343 }
14344 arg2 = static_cast< int >(val2);
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 (arg1)->SetWeight(arg2);
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = SWIG_Py_Void();
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 SWIGINTERN PyObject *_wrap_Font_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj = 0;
14360 wxFont *arg1 = (wxFont *) 0 ;
14361 wxString *arg2 = 0 ;
14362 bool result;
14363 void *argp1 = 0 ;
14364 int res1 = 0 ;
14365 bool temp2 = false ;
14366 PyObject * obj0 = 0 ;
14367 PyObject * obj1 = 0 ;
14368 char * kwnames[] = {
14369 (char *) "self",(char *) "faceName", NULL
14370 };
14371
14372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
14373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFaceName" "', expected argument " "1"" of type '" "wxFont *""'");
14376 }
14377 arg1 = reinterpret_cast< wxFont * >(argp1);
14378 {
14379 arg2 = wxString_in_helper(obj1);
14380 if (arg2 == NULL) SWIG_fail;
14381 temp2 = true;
14382 }
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 result = (bool)(arg1)->SetFaceName((wxString const &)*arg2);
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 {
14390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14391 }
14392 {
14393 if (temp2)
14394 delete arg2;
14395 }
14396 return resultobj;
14397 fail:
14398 {
14399 if (temp2)
14400 delete arg2;
14401 }
14402 return NULL;
14403 }
14404
14405
14406 SWIGINTERN PyObject *_wrap_Font_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj = 0;
14408 wxFont *arg1 = (wxFont *) 0 ;
14409 bool arg2 ;
14410 void *argp1 = 0 ;
14411 int res1 = 0 ;
14412 bool val2 ;
14413 int ecode2 = 0 ;
14414 PyObject * obj0 = 0 ;
14415 PyObject * obj1 = 0 ;
14416 char * kwnames[] = {
14417 (char *) "self",(char *) "underlined", NULL
14418 };
14419
14420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
14421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14422 if (!SWIG_IsOK(res1)) {
14423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetUnderlined" "', expected argument " "1"" of type '" "wxFont *""'");
14424 }
14425 arg1 = reinterpret_cast< wxFont * >(argp1);
14426 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14427 if (!SWIG_IsOK(ecode2)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
14429 }
14430 arg2 = static_cast< bool >(val2);
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 (arg1)->SetUnderlined(arg2);
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = SWIG_Py_Void();
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Font_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj = 0;
14446 wxFont *arg1 = (wxFont *) 0 ;
14447 wxFontEncoding arg2 ;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 int val2 ;
14451 int ecode2 = 0 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 char * kwnames[] = {
14455 (char *) "self",(char *) "encoding", NULL
14456 };
14457
14458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
14459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14460 if (!SWIG_IsOK(res1)) {
14461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetEncoding" "', expected argument " "1"" of type '" "wxFont *""'");
14462 }
14463 arg1 = reinterpret_cast< wxFont * >(argp1);
14464 ecode2 = SWIG_AsVal_int(obj1, &val2);
14465 if (!SWIG_IsOK(ecode2)) {
14466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14467 }
14468 arg2 = static_cast< wxFontEncoding >(val2);
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 (arg1)->SetEncoding(arg2);
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_Py_Void();
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj = 0;
14484 wxFont *arg1 = (wxFont *) 0 ;
14485 wxNativeFontInfo *arg2 = 0 ;
14486 void *argp1 = 0 ;
14487 int res1 = 0 ;
14488 void *argp2 = 0 ;
14489 int res2 = 0 ;
14490 PyObject * obj0 = 0 ;
14491 PyObject * obj1 = 0 ;
14492 char * kwnames[] = {
14493 (char *) "self",(char *) "info", NULL
14494 };
14495
14496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) SWIG_fail;
14497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont *""'");
14500 }
14501 arg1 = reinterpret_cast< wxFont * >(argp1);
14502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
14503 if (!SWIG_IsOK(res2)) {
14504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
14505 }
14506 if (!argp2) {
14507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
14508 }
14509 arg2 = reinterpret_cast< wxNativeFontInfo * >(argp2);
14510 {
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
14513 wxPyEndAllowThreads(__tstate);
14514 if (PyErr_Occurred()) SWIG_fail;
14515 }
14516 resultobj = SWIG_Py_Void();
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj = 0;
14525 wxFont *arg1 = (wxFont *) 0 ;
14526 wxString *arg2 = 0 ;
14527 bool result;
14528 void *argp1 = 0 ;
14529 int res1 = 0 ;
14530 bool temp2 = false ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 char * kwnames[] = {
14534 (char *) "self",(char *) "info", NULL
14535 };
14536
14537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) SWIG_fail;
14538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14539 if (!SWIG_IsOK(res1)) {
14540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoFromString" "', expected argument " "1"" of type '" "wxFont *""'");
14541 }
14542 arg1 = reinterpret_cast< wxFont * >(argp1);
14543 {
14544 arg2 = wxString_in_helper(obj1);
14545 if (arg2 == NULL) SWIG_fail;
14546 temp2 = true;
14547 }
14548 {
14549 PyThreadState* __tstate = wxPyBeginAllowThreads();
14550 result = (bool)(arg1)->SetNativeFontInfo((wxString const &)*arg2);
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 {
14555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14556 }
14557 {
14558 if (temp2)
14559 delete arg2;
14560 }
14561 return resultobj;
14562 fail:
14563 {
14564 if (temp2)
14565 delete arg2;
14566 }
14567 return NULL;
14568 }
14569
14570
14571 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14572 PyObject *resultobj = 0;
14573 wxFont *arg1 = (wxFont *) 0 ;
14574 wxString *arg2 = 0 ;
14575 bool result;
14576 void *argp1 = 0 ;
14577 int res1 = 0 ;
14578 bool temp2 = false ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 char * kwnames[] = {
14582 (char *) "self",(char *) "info", NULL
14583 };
14584
14585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) SWIG_fail;
14586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont *""'");
14589 }
14590 arg1 = reinterpret_cast< wxFont * >(argp1);
14591 {
14592 arg2 = wxString_in_helper(obj1);
14593 if (arg2 == NULL) SWIG_fail;
14594 temp2 = true;
14595 }
14596 {
14597 PyThreadState* __tstate = wxPyBeginAllowThreads();
14598 result = (bool)(arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
14599 wxPyEndAllowThreads(__tstate);
14600 if (PyErr_Occurred()) SWIG_fail;
14601 }
14602 {
14603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14604 }
14605 {
14606 if (temp2)
14607 delete arg2;
14608 }
14609 return resultobj;
14610 fail:
14611 {
14612 if (temp2)
14613 delete arg2;
14614 }
14615 return NULL;
14616 }
14617
14618
14619 SWIGINTERN PyObject *_wrap_Font_GetFamilyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14620 PyObject *resultobj = 0;
14621 wxFont *arg1 = (wxFont *) 0 ;
14622 wxString result;
14623 void *argp1 = 0 ;
14624 int res1 = 0 ;
14625 PyObject *swig_obj[1] ;
14626
14627 if (!args) SWIG_fail;
14628 swig_obj[0] = args;
14629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14630 if (!SWIG_IsOK(res1)) {
14631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamilyString" "', expected argument " "1"" of type '" "wxFont const *""'");
14632 }
14633 arg1 = reinterpret_cast< wxFont * >(argp1);
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 result = ((wxFont const *)arg1)->GetFamilyString();
14637 wxPyEndAllowThreads(__tstate);
14638 if (PyErr_Occurred()) SWIG_fail;
14639 }
14640 {
14641 #if wxUSE_UNICODE
14642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14643 #else
14644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14645 #endif
14646 }
14647 return resultobj;
14648 fail:
14649 return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_Font_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14654 PyObject *resultobj = 0;
14655 wxFont *arg1 = (wxFont *) 0 ;
14656 wxString result;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 PyObject *swig_obj[1] ;
14660
14661 if (!args) SWIG_fail;
14662 swig_obj[0] = args;
14663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyleString" "', expected argument " "1"" of type '" "wxFont const *""'");
14666 }
14667 arg1 = reinterpret_cast< wxFont * >(argp1);
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = ((wxFont const *)arg1)->GetStyleString();
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 {
14675 #if wxUSE_UNICODE
14676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14677 #else
14678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14679 #endif
14680 }
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_Font_GetWeightString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14688 PyObject *resultobj = 0;
14689 wxFont *arg1 = (wxFont *) 0 ;
14690 wxString result;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 PyObject *swig_obj[1] ;
14694
14695 if (!args) SWIG_fail;
14696 swig_obj[0] = args;
14697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14698 if (!SWIG_IsOK(res1)) {
14699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeightString" "', expected argument " "1"" of type '" "wxFont const *""'");
14700 }
14701 arg1 = reinterpret_cast< wxFont * >(argp1);
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = ((wxFont const *)arg1)->GetWeightString();
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 {
14709 #if wxUSE_UNICODE
14710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14711 #else
14712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14713 #endif
14714 }
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 SWIGINTERN PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14722 PyObject *resultobj = 0;
14723 wxFont *arg1 = (wxFont *) 0 ;
14724 bool arg2 = (bool) true ;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 bool val2 ;
14728 int ecode2 = 0 ;
14729 PyObject * obj0 = 0 ;
14730 PyObject * obj1 = 0 ;
14731 char * kwnames[] = {
14732 (char *) "self",(char *) "no", NULL
14733 };
14734
14735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;
14736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14737 if (!SWIG_IsOK(res1)) {
14738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont *""'");
14739 }
14740 arg1 = reinterpret_cast< wxFont * >(argp1);
14741 if (obj1) {
14742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14743 if (!SWIG_IsOK(ecode2)) {
14744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "2"" of type '" "bool""'");
14745 }
14746 arg2 = static_cast< bool >(val2);
14747 }
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 (arg1)->SetNoAntiAliasing(arg2);
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 resultobj = SWIG_Py_Void();
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14762 PyObject *resultobj = 0;
14763 wxFont *arg1 = (wxFont *) 0 ;
14764 bool result;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont const *""'");
14774 }
14775 arg1 = reinterpret_cast< wxFont * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 {
14783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14784 }
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 SWIGINTERN PyObject *_wrap_Font_GetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14792 PyObject *resultobj = 0;
14793 wxFontEncoding result;
14794
14795 if (!SWIG_Python_UnpackTuple(args,"Font_GetDefaultEncoding",0,0,0)) SWIG_fail;
14796 {
14797 if (!wxPyCheckForApp()) SWIG_fail;
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 resultobj = SWIG_From_int(static_cast< int >(result));
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_Font_SetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14811 PyObject *resultobj = 0;
14812 wxFontEncoding arg1 ;
14813 int val1 ;
14814 int ecode1 = 0 ;
14815 PyObject * obj0 = 0 ;
14816 char * kwnames[] = {
14817 (char *) "encoding", NULL
14818 };
14819
14820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) SWIG_fail;
14821 ecode1 = SWIG_AsVal_int(obj0, &val1);
14822 if (!SWIG_IsOK(ecode1)) {
14823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Font_SetDefaultEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14824 }
14825 arg1 = static_cast< wxFontEncoding >(val1);
14826 {
14827 if (!wxPyCheckForApp()) SWIG_fail;
14828 PyThreadState* __tstate = wxPyBeginAllowThreads();
14829 wxFont::SetDefaultEncoding(arg1);
14830 wxPyEndAllowThreads(__tstate);
14831 if (PyErr_Occurred()) SWIG_fail;
14832 }
14833 resultobj = SWIG_Py_Void();
14834 return resultobj;
14835 fail:
14836 return NULL;
14837 }
14838
14839
14840 SWIGINTERN PyObject *Font_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14841 PyObject *obj;
14842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14843 SWIG_TypeNewClientData(SWIGTYPE_p_wxFont, SWIG_NewClientData(obj));
14844 return SWIG_Py_Void();
14845 }
14846
14847 SWIGINTERN PyObject *Font_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14848 return SWIG_Python_InitShadowInstance(args);
14849 }
14850
14851 SWIGINTERN PyObject *_wrap_new_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14852 PyObject *resultobj = 0;
14853 wxPyFontEnumerator *result = 0 ;
14854
14855 if (!SWIG_Python_UnpackTuple(args,"new_FontEnumerator",0,0,0)) SWIG_fail;
14856 {
14857 if (!wxPyCheckForApp()) SWIG_fail;
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_NEW | 0 );
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 SWIGINTERN PyObject *_wrap_delete_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14871 PyObject *resultobj = 0;
14872 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14873 void *argp1 = 0 ;
14874 int res1 = 0 ;
14875 PyObject *swig_obj[1] ;
14876
14877 if (!args) SWIG_fail;
14878 swig_obj[0] = args;
14879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_DISOWN | 0 );
14880 if (!SWIG_IsOK(res1)) {
14881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontEnumerator" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14882 }
14883 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14884 {
14885 PyThreadState* __tstate = wxPyBeginAllowThreads();
14886 delete arg1;
14887
14888 wxPyEndAllowThreads(__tstate);
14889 if (PyErr_Occurred()) SWIG_fail;
14890 }
14891 resultobj = SWIG_Py_Void();
14892 return resultobj;
14893 fail:
14894 return NULL;
14895 }
14896
14897
14898 SWIGINTERN PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14899 PyObject *resultobj = 0;
14900 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14901 PyObject *arg2 = (PyObject *) 0 ;
14902 PyObject *arg3 = (PyObject *) 0 ;
14903 bool arg4 ;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 bool val4 ;
14907 int ecode4 = 0 ;
14908 PyObject * obj0 = 0 ;
14909 PyObject * obj1 = 0 ;
14910 PyObject * obj2 = 0 ;
14911 PyObject * obj3 = 0 ;
14912 char * kwnames[] = {
14913 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
14914 };
14915
14916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
14918 if (!SWIG_IsOK(res1)) {
14919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14920 }
14921 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14922 arg2 = obj1;
14923 arg3 = obj2;
14924 ecode4 = SWIG_AsVal_bool(obj3, &val4);
14925 if (!SWIG_IsOK(ecode4)) {
14926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
14927 }
14928 arg4 = static_cast< bool >(val4);
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 resultobj = SWIG_Py_Void();
14936 return resultobj;
14937 fail:
14938 return NULL;
14939 }
14940
14941
14942 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14943 PyObject *resultobj = 0;
14944 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14945 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
14946 bool arg3 = (bool) false ;
14947 bool result;
14948 void *argp1 = 0 ;
14949 int res1 = 0 ;
14950 int val2 ;
14951 int ecode2 = 0 ;
14952 bool val3 ;
14953 int ecode3 = 0 ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 PyObject * obj2 = 0 ;
14957 char * kwnames[] = {
14958 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
14959 };
14960
14961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
14963 if (!SWIG_IsOK(res1)) {
14964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14965 }
14966 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14967 if (obj1) {
14968 ecode2 = SWIG_AsVal_int(obj1, &val2);
14969 if (!SWIG_IsOK(ecode2)) {
14970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14971 }
14972 arg2 = static_cast< wxFontEncoding >(val2);
14973 }
14974 if (obj2) {
14975 ecode3 = SWIG_AsVal_bool(obj2, &val3);
14976 if (!SWIG_IsOK(ecode3)) {
14977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "3"" of type '" "bool""'");
14978 }
14979 arg3 = static_cast< bool >(val3);
14980 }
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (bool)(arg1)->EnumerateFacenames(arg2,arg3);
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj = 0;
14998 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14999 wxString const &arg2_defvalue = wxPyEmptyString ;
15000 wxString *arg2 = (wxString *) &arg2_defvalue ;
15001 bool result;
15002 void *argp1 = 0 ;
15003 int res1 = 0 ;
15004 bool temp2 = false ;
15005 PyObject * obj0 = 0 ;
15006 PyObject * obj1 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "facename", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15015 }
15016 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15017 if (obj1) {
15018 {
15019 arg2 = wxString_in_helper(obj1);
15020 if (arg2 == NULL) SWIG_fail;
15021 temp2 = true;
15022 }
15023 }
15024 {
15025 PyThreadState* __tstate = wxPyBeginAllowThreads();
15026 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
15027 wxPyEndAllowThreads(__tstate);
15028 if (PyErr_Occurred()) SWIG_fail;
15029 }
15030 {
15031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15032 }
15033 {
15034 if (temp2)
15035 delete arg2;
15036 }
15037 return resultobj;
15038 fail:
15039 {
15040 if (temp2)
15041 delete arg2;
15042 }
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15048 PyObject *resultobj = 0;
15049 PyObject *result = 0 ;
15050
15051 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetEncodings",0,0,0)) SWIG_fail;
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (PyObject *)wxPyFontEnumerator_GetEncodings();
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = result;
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 SWIGINTERN PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15066 PyObject *resultobj = 0;
15067 PyObject *result = 0 ;
15068
15069 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetFacenames",0,0,0)) SWIG_fail;
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = (PyObject *)wxPyFontEnumerator_GetFacenames();
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 resultobj = result;
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_FontEnumerator_IsValidFacename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj = 0;
15085 wxString *arg1 = 0 ;
15086 bool result;
15087 bool temp1 = false ;
15088 PyObject * obj0 = 0 ;
15089 char * kwnames[] = {
15090 (char *) "str", NULL
15091 };
15092
15093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_IsValidFacename",kwnames,&obj0)) SWIG_fail;
15094 {
15095 arg1 = wxString_in_helper(obj0);
15096 if (arg1 == NULL) SWIG_fail;
15097 temp1 = true;
15098 }
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (bool)wxPyFontEnumerator::IsValidFacename((wxString const &)*arg1);
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 {
15106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15107 }
15108 {
15109 if (temp1)
15110 delete arg1;
15111 }
15112 return resultobj;
15113 fail:
15114 {
15115 if (temp1)
15116 delete arg1;
15117 }
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *FontEnumerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *obj;
15124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15125 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFontEnumerator, SWIG_NewClientData(obj));
15126 return SWIG_Py_Void();
15127 }
15128
15129 SWIGINTERN PyObject *FontEnumerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15130 return SWIG_Python_InitShadowInstance(args);
15131 }
15132
15133 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15134 PyObject *resultobj = 0;
15135 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15136 int arg2 ;
15137 void *argp1 = 0 ;
15138 int res1 = 0 ;
15139 int val2 ;
15140 int ecode2 = 0 ;
15141 PyObject *swig_obj[2] ;
15142
15143 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Language_set",2,2,swig_obj)) SWIG_fail;
15144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15145 if (!SWIG_IsOK(res1)) {
15146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15147 }
15148 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15149 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15150 if (!SWIG_IsOK(ecode2)) {
15151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LanguageInfo_Language_set" "', expected argument " "2"" of type '" "int""'");
15152 }
15153 arg2 = static_cast< int >(val2);
15154 if (arg1) (arg1)->Language = arg2;
15155
15156 resultobj = SWIG_Py_Void();
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15166 int result;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 PyObject *swig_obj[1] ;
15170
15171 if (!args) SWIG_fail;
15172 swig_obj[0] = args;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15176 }
15177 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15178 result = (int) ((arg1)->Language);
15179 resultobj = SWIG_From_int(static_cast< int >(result));
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15187 PyObject *resultobj = 0;
15188 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15189 wxString *arg2 = (wxString *) 0 ;
15190 void *argp1 = 0 ;
15191 int res1 = 0 ;
15192 bool temp2 = false ;
15193 PyObject *swig_obj[2] ;
15194
15195 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_CanonicalName_set",2,2,swig_obj)) SWIG_fail;
15196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15197 if (!SWIG_IsOK(res1)) {
15198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15199 }
15200 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15201 {
15202 arg2 = wxString_in_helper(swig_obj[1]);
15203 if (arg2 == NULL) SWIG_fail;
15204 temp2 = true;
15205 }
15206 if (arg1) (arg1)->CanonicalName = *arg2;
15207
15208 resultobj = SWIG_Py_Void();
15209 {
15210 if (temp2)
15211 delete arg2;
15212 }
15213 return resultobj;
15214 fail:
15215 {
15216 if (temp2)
15217 delete arg2;
15218 }
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15226 wxString *result = 0 ;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject *swig_obj[1] ;
15230
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15236 }
15237 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15238 result = (wxString *)& ((arg1)->CanonicalName);
15239 {
15240 #if wxUSE_UNICODE
15241 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15242 #else
15243 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15244 #endif
15245 }
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15255 wxString *arg2 = (wxString *) 0 ;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 bool temp2 = false ;
15259 PyObject *swig_obj[2] ;
15260
15261 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Description_set",2,2,swig_obj)) SWIG_fail;
15262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15265 }
15266 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15267 {
15268 arg2 = wxString_in_helper(swig_obj[1]);
15269 if (arg2 == NULL) SWIG_fail;
15270 temp2 = true;
15271 }
15272 if (arg1) (arg1)->Description = *arg2;
15273
15274 resultobj = SWIG_Py_Void();
15275 {
15276 if (temp2)
15277 delete arg2;
15278 }
15279 return resultobj;
15280 fail:
15281 {
15282 if (temp2)
15283 delete arg2;
15284 }
15285 return NULL;
15286 }
15287
15288
15289 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15290 PyObject *resultobj = 0;
15291 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15292 wxString *result = 0 ;
15293 void *argp1 = 0 ;
15294 int res1 = 0 ;
15295 PyObject *swig_obj[1] ;
15296
15297 if (!args) SWIG_fail;
15298 swig_obj[0] = args;
15299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15300 if (!SWIG_IsOK(res1)) {
15301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15302 }
15303 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15304 result = (wxString *)& ((arg1)->Description);
15305 {
15306 #if wxUSE_UNICODE
15307 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15308 #else
15309 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15310 #endif
15311 }
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 SWIGINTERN PyObject *LanguageInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15319 PyObject *obj;
15320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15321 SWIG_TypeNewClientData(SWIGTYPE_p_wxLanguageInfo, SWIG_NewClientData(obj));
15322 return SWIG_Py_Void();
15323 }
15324
15325 SWIGINTERN PyObject *_wrap_new_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj = 0;
15327 int arg1 = (int) -1 ;
15328 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
15329 wxLocale *result = 0 ;
15330 int val1 ;
15331 int ecode1 = 0 ;
15332 int val2 ;
15333 int ecode2 = 0 ;
15334 PyObject * obj0 = 0 ;
15335 PyObject * obj1 = 0 ;
15336 char * kwnames[] = {
15337 (char *) "language",(char *) "flags", NULL
15338 };
15339
15340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) SWIG_fail;
15341 if (obj0) {
15342 ecode1 = SWIG_AsVal_int(obj0, &val1);
15343 if (!SWIG_IsOK(ecode1)) {
15344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Locale" "', expected argument " "1"" of type '" "int""'");
15345 }
15346 arg1 = static_cast< int >(val1);
15347 }
15348 if (obj1) {
15349 ecode2 = SWIG_AsVal_int(obj1, &val2);
15350 if (!SWIG_IsOK(ecode2)) {
15351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Locale" "', expected argument " "2"" of type '" "int""'");
15352 }
15353 arg2 = static_cast< int >(val2);
15354 }
15355 {
15356 PyThreadState* __tstate = wxPyBeginAllowThreads();
15357 result = (wxLocale *)new_wxLocale(arg1,arg2);
15358 wxPyEndAllowThreads(__tstate);
15359 if (PyErr_Occurred()) SWIG_fail;
15360 }
15361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, SWIG_POINTER_NEW | 0 );
15362 return resultobj;
15363 fail:
15364 return NULL;
15365 }
15366
15367
15368 SWIGINTERN PyObject *_wrap_delete_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15369 PyObject *resultobj = 0;
15370 wxLocale *arg1 = (wxLocale *) 0 ;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 PyObject *swig_obj[1] ;
15374
15375 if (!args) SWIG_fail;
15376 swig_obj[0] = args;
15377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, SWIG_POINTER_DISOWN | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locale" "', expected argument " "1"" of type '" "wxLocale *""'");
15380 }
15381 arg1 = reinterpret_cast< wxLocale * >(argp1);
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 delete arg1;
15385
15386 wxPyEndAllowThreads(__tstate);
15387 if (PyErr_Occurred()) SWIG_fail;
15388 }
15389 resultobj = SWIG_Py_Void();
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 SWIGINTERN PyObject *_wrap_Locale_Init1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15397 PyObject *resultobj = 0;
15398 wxLocale *arg1 = (wxLocale *) 0 ;
15399 wxString *arg2 = 0 ;
15400 wxString const &arg3_defvalue = wxPyEmptyString ;
15401 wxString *arg3 = (wxString *) &arg3_defvalue ;
15402 wxString const &arg4_defvalue = wxPyEmptyString ;
15403 wxString *arg4 = (wxString *) &arg4_defvalue ;
15404 bool arg5 = (bool) true ;
15405 bool arg6 = (bool) false ;
15406 bool result;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 bool temp2 = false ;
15410 bool temp3 = false ;
15411 bool temp4 = false ;
15412 bool val5 ;
15413 int ecode5 = 0 ;
15414 bool val6 ;
15415 int ecode6 = 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 PyObject * obj2 = 0 ;
15419 PyObject * obj3 = 0 ;
15420 PyObject * obj4 = 0 ;
15421 PyObject * obj5 = 0 ;
15422 char * kwnames[] = {
15423 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
15424 };
15425
15426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init1" "', expected argument " "1"" of type '" "wxLocale *""'");
15430 }
15431 arg1 = reinterpret_cast< wxLocale * >(argp1);
15432 {
15433 arg2 = wxString_in_helper(obj1);
15434 if (arg2 == NULL) SWIG_fail;
15435 temp2 = true;
15436 }
15437 if (obj2) {
15438 {
15439 arg3 = wxString_in_helper(obj2);
15440 if (arg3 == NULL) SWIG_fail;
15441 temp3 = true;
15442 }
15443 }
15444 if (obj3) {
15445 {
15446 arg4 = wxString_in_helper(obj3);
15447 if (arg4 == NULL) SWIG_fail;
15448 temp4 = true;
15449 }
15450 }
15451 if (obj4) {
15452 ecode5 = SWIG_AsVal_bool(obj4, &val5);
15453 if (!SWIG_IsOK(ecode5)) {
15454 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Locale_Init1" "', expected argument " "5"" of type '" "bool""'");
15455 }
15456 arg5 = static_cast< bool >(val5);
15457 }
15458 if (obj5) {
15459 ecode6 = SWIG_AsVal_bool(obj5, &val6);
15460 if (!SWIG_IsOK(ecode6)) {
15461 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Locale_Init1" "', expected argument " "6"" of type '" "bool""'");
15462 }
15463 arg6 = static_cast< bool >(val6);
15464 }
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 {
15472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15473 }
15474 {
15475 if (temp2)
15476 delete arg2;
15477 }
15478 {
15479 if (temp3)
15480 delete arg3;
15481 }
15482 {
15483 if (temp4)
15484 delete arg4;
15485 }
15486 return resultobj;
15487 fail:
15488 {
15489 if (temp2)
15490 delete arg2;
15491 }
15492 {
15493 if (temp3)
15494 delete arg3;
15495 }
15496 {
15497 if (temp4)
15498 delete arg4;
15499 }
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Locale_Init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = 0;
15506 wxLocale *arg1 = (wxLocale *) 0 ;
15507 int arg2 = (int) wxLANGUAGE_DEFAULT ;
15508 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
15509 bool result;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 int val2 ;
15513 int ecode2 = 0 ;
15514 int val3 ;
15515 int ecode3 = 0 ;
15516 PyObject * obj0 = 0 ;
15517 PyObject * obj1 = 0 ;
15518 PyObject * obj2 = 0 ;
15519 char * kwnames[] = {
15520 (char *) "self",(char *) "language",(char *) "flags", NULL
15521 };
15522
15523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15525 if (!SWIG_IsOK(res1)) {
15526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init2" "', expected argument " "1"" of type '" "wxLocale *""'");
15527 }
15528 arg1 = reinterpret_cast< wxLocale * >(argp1);
15529 if (obj1) {
15530 ecode2 = SWIG_AsVal_int(obj1, &val2);
15531 if (!SWIG_IsOK(ecode2)) {
15532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Locale_Init2" "', expected argument " "2"" of type '" "int""'");
15533 }
15534 arg2 = static_cast< int >(val2);
15535 }
15536 if (obj2) {
15537 ecode3 = SWIG_AsVal_int(obj2, &val3);
15538 if (!SWIG_IsOK(ecode3)) {
15539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Locale_Init2" "', expected argument " "3"" of type '" "int""'");
15540 }
15541 arg3 = static_cast< int >(val3);
15542 }
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 {
15550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15551 }
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 SWIGINTERN PyObject *_wrap_Locale_GetSystemLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15559 PyObject *resultobj = 0;
15560 int result;
15561
15562 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemLanguage",0,0,0)) SWIG_fail;
15563 {
15564 PyThreadState* __tstate = wxPyBeginAllowThreads();
15565 result = (int)wxLocale::GetSystemLanguage();
15566 wxPyEndAllowThreads(__tstate);
15567 if (PyErr_Occurred()) SWIG_fail;
15568 }
15569 resultobj = SWIG_From_int(static_cast< int >(result));
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15577 PyObject *resultobj = 0;
15578 wxFontEncoding result;
15579
15580 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncoding",0,0,0)) SWIG_fail;
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_From_int(static_cast< int >(result));
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15595 PyObject *resultobj = 0;
15596 wxString result;
15597
15598 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncodingName",0,0,0)) SWIG_fail;
15599 {
15600 PyThreadState* __tstate = wxPyBeginAllowThreads();
15601 result = wxLocale::GetSystemEncodingName();
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 {
15606 #if wxUSE_UNICODE
15607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15608 #else
15609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15610 #endif
15611 }
15612 return resultobj;
15613 fail:
15614 return NULL;
15615 }
15616
15617
15618 SWIGINTERN PyObject *_wrap_Locale_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15619 PyObject *resultobj = 0;
15620 wxLocale *arg1 = (wxLocale *) 0 ;
15621 bool result;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 PyObject *swig_obj[1] ;
15625
15626 if (!args) SWIG_fail;
15627 swig_obj[0] = args;
15628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15629 if (!SWIG_IsOK(res1)) {
15630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsOk" "', expected argument " "1"" of type '" "wxLocale const *""'");
15631 }
15632 arg1 = reinterpret_cast< wxLocale * >(argp1);
15633 {
15634 PyThreadState* __tstate = wxPyBeginAllowThreads();
15635 result = (bool)((wxLocale const *)arg1)->IsOk();
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 SWIGINTERN PyObject *_wrap_Locale_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15649 PyObject *resultobj = 0;
15650 wxLocale *arg1 = (wxLocale *) 0 ;
15651 wxString result;
15652 void *argp1 = 0 ;
15653 int res1 = 0 ;
15654 PyObject *swig_obj[1] ;
15655
15656 if (!args) SWIG_fail;
15657 swig_obj[0] = args;
15658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLocale" "', expected argument " "1"" of type '" "wxLocale const *""'");
15661 }
15662 arg1 = reinterpret_cast< wxLocale * >(argp1);
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = ((wxLocale const *)arg1)->GetLocale();
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 #if wxUSE_UNICODE
15671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15672 #else
15673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15674 #endif
15675 }
15676 return resultobj;
15677 fail:
15678 return NULL;
15679 }
15680
15681
15682 SWIGINTERN PyObject *_wrap_Locale_GetLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15683 PyObject *resultobj = 0;
15684 wxLocale *arg1 = (wxLocale *) 0 ;
15685 int result;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 PyObject *swig_obj[1] ;
15689
15690 if (!args) SWIG_fail;
15691 swig_obj[0] = args;
15692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15693 if (!SWIG_IsOK(res1)) {
15694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLanguage" "', expected argument " "1"" of type '" "wxLocale const *""'");
15695 }
15696 arg1 = reinterpret_cast< wxLocale * >(argp1);
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (int)((wxLocale const *)arg1)->GetLanguage();
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 resultobj = SWIG_From_int(static_cast< int >(result));
15704 return resultobj;
15705 fail:
15706 return NULL;
15707 }
15708
15709
15710 SWIGINTERN PyObject *_wrap_Locale_GetSysName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15711 PyObject *resultobj = 0;
15712 wxLocale *arg1 = (wxLocale *) 0 ;
15713 wxString result;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 PyObject *swig_obj[1] ;
15717
15718 if (!args) SWIG_fail;
15719 swig_obj[0] = args;
15720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetSysName" "', expected argument " "1"" of type '" "wxLocale const *""'");
15723 }
15724 arg1 = reinterpret_cast< wxLocale * >(argp1);
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = ((wxLocale const *)arg1)->GetSysName();
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 {
15732 #if wxUSE_UNICODE
15733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15734 #else
15735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15736 #endif
15737 }
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_Locale_GetCanonicalName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 PyObject *resultobj = 0;
15746 wxLocale *arg1 = (wxLocale *) 0 ;
15747 wxString result;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 PyObject *swig_obj[1] ;
15751
15752 if (!args) SWIG_fail;
15753 swig_obj[0] = args;
15754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15755 if (!SWIG_IsOK(res1)) {
15756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetCanonicalName" "', expected argument " "1"" of type '" "wxLocale const *""'");
15757 }
15758 arg1 = reinterpret_cast< wxLocale * >(argp1);
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 result = ((wxLocale const *)arg1)->GetCanonicalName();
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 {
15766 #if wxUSE_UNICODE
15767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15768 #else
15769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15770 #endif
15771 }
15772 return resultobj;
15773 fail:
15774 return NULL;
15775 }
15776
15777
15778 SWIGINTERN PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15779 PyObject *resultobj = 0;
15780 wxString *arg1 = 0 ;
15781 bool temp1 = false ;
15782 PyObject * obj0 = 0 ;
15783 char * kwnames[] = {
15784 (char *) "prefix", NULL
15785 };
15786
15787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) SWIG_fail;
15788 {
15789 arg1 = wxString_in_helper(obj0);
15790 if (arg1 == NULL) SWIG_fail;
15791 temp1 = true;
15792 }
15793 {
15794 PyThreadState* __tstate = wxPyBeginAllowThreads();
15795 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 resultobj = SWIG_Py_Void();
15800 {
15801 if (temp1)
15802 delete arg1;
15803 }
15804 return resultobj;
15805 fail:
15806 {
15807 if (temp1)
15808 delete arg1;
15809 }
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_Locale_AddCatalog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj = 0;
15816 wxLocale *arg1 = (wxLocale *) 0 ;
15817 wxString *arg2 = 0 ;
15818 bool result;
15819 void *argp1 = 0 ;
15820 int res1 = 0 ;
15821 bool temp2 = false ;
15822 PyObject * obj0 = 0 ;
15823 PyObject * obj1 = 0 ;
15824 char * kwnames[] = {
15825 (char *) "self",(char *) "szDomain", NULL
15826 };
15827
15828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) SWIG_fail;
15829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15830 if (!SWIG_IsOK(res1)) {
15831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddCatalog" "', expected argument " "1"" of type '" "wxLocale *""'");
15832 }
15833 arg1 = reinterpret_cast< wxLocale * >(argp1);
15834 {
15835 arg2 = wxString_in_helper(obj1);
15836 if (arg2 == NULL) SWIG_fail;
15837 temp2 = true;
15838 }
15839 {
15840 PyThreadState* __tstate = wxPyBeginAllowThreads();
15841 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
15842 wxPyEndAllowThreads(__tstate);
15843 if (PyErr_Occurred()) SWIG_fail;
15844 }
15845 {
15846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15847 }
15848 {
15849 if (temp2)
15850 delete arg2;
15851 }
15852 return resultobj;
15853 fail:
15854 {
15855 if (temp2)
15856 delete arg2;
15857 }
15858 return NULL;
15859 }
15860
15861
15862 SWIGINTERN PyObject *_wrap_Locale_IsLoaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj = 0;
15864 wxLocale *arg1 = (wxLocale *) 0 ;
15865 wxString *arg2 = 0 ;
15866 bool result;
15867 void *argp1 = 0 ;
15868 int res1 = 0 ;
15869 bool temp2 = false ;
15870 PyObject * obj0 = 0 ;
15871 PyObject * obj1 = 0 ;
15872 char * kwnames[] = {
15873 (char *) "self",(char *) "szDomain", NULL
15874 };
15875
15876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) SWIG_fail;
15877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15878 if (!SWIG_IsOK(res1)) {
15879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsLoaded" "', expected argument " "1"" of type '" "wxLocale const *""'");
15880 }
15881 arg1 = reinterpret_cast< wxLocale * >(argp1);
15882 {
15883 arg2 = wxString_in_helper(obj1);
15884 if (arg2 == NULL) SWIG_fail;
15885 temp2 = true;
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 {
15894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15895 }
15896 {
15897 if (temp2)
15898 delete arg2;
15899 }
15900 return resultobj;
15901 fail:
15902 {
15903 if (temp2)
15904 delete arg2;
15905 }
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_Locale_GetLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj = 0;
15912 int arg1 ;
15913 wxLanguageInfo *result = 0 ;
15914 int val1 ;
15915 int ecode1 = 0 ;
15916 PyObject * obj0 = 0 ;
15917 char * kwnames[] = {
15918 (char *) "lang", NULL
15919 };
15920
15921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) SWIG_fail;
15922 ecode1 = SWIG_AsVal_int(obj0, &val1);
15923 if (!SWIG_IsOK(ecode1)) {
15924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageInfo" "', expected argument " "1"" of type '" "int""'");
15925 }
15926 arg1 = static_cast< int >(val1);
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 SWIGINTERN PyObject *_wrap_Locale_GetLanguageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15941 PyObject *resultobj = 0;
15942 int arg1 ;
15943 wxString result;
15944 int val1 ;
15945 int ecode1 = 0 ;
15946 PyObject * obj0 = 0 ;
15947 char * kwnames[] = {
15948 (char *) "lang", NULL
15949 };
15950
15951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) SWIG_fail;
15952 ecode1 = SWIG_AsVal_int(obj0, &val1);
15953 if (!SWIG_IsOK(ecode1)) {
15954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageName" "', expected argument " "1"" of type '" "int""'");
15955 }
15956 arg1 = static_cast< int >(val1);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = wxLocale::GetLanguageName(arg1);
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 {
15964 #if wxUSE_UNICODE
15965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15966 #else
15967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15968 #endif
15969 }
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 SWIGINTERN PyObject *_wrap_Locale_FindLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj = 0;
15978 wxString *arg1 = 0 ;
15979 wxLanguageInfo *result = 0 ;
15980 bool temp1 = false ;
15981 PyObject * obj0 = 0 ;
15982 char * kwnames[] = {
15983 (char *) "locale", NULL
15984 };
15985
15986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) SWIG_fail;
15987 {
15988 arg1 = wxString_in_helper(obj0);
15989 if (arg1 == NULL) SWIG_fail;
15990 temp1 = true;
15991 }
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15999 {
16000 if (temp1)
16001 delete arg1;
16002 }
16003 return resultobj;
16004 fail:
16005 {
16006 if (temp1)
16007 delete arg1;
16008 }
16009 return NULL;
16010 }
16011
16012
16013 SWIGINTERN PyObject *_wrap_Locale_AddLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16014 PyObject *resultobj = 0;
16015 wxLanguageInfo *arg1 = 0 ;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 PyObject * obj0 = 0 ;
16019 char * kwnames[] = {
16020 (char *) "info", NULL
16021 };
16022
16023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) SWIG_fail;
16024 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxLanguageInfo, 0 | 0);
16025 if (!SWIG_IsOK(res1)) {
16026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16027 }
16028 if (!argp1) {
16029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16030 }
16031 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_Py_Void();
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Locale_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16046 PyObject *resultobj = 0;
16047 wxLocale *arg1 = (wxLocale *) 0 ;
16048 wxString *arg2 = 0 ;
16049 wxString const &arg3_defvalue = wxPyEmptyString ;
16050 wxString *arg3 = (wxString *) &arg3_defvalue ;
16051 wxString result;
16052 void *argp1 = 0 ;
16053 int res1 = 0 ;
16054 bool temp2 = false ;
16055 bool temp3 = false ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 PyObject * obj2 = 0 ;
16059 char * kwnames[] = {
16060 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16061 };
16062
16063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetString" "', expected argument " "1"" of type '" "wxLocale const *""'");
16067 }
16068 arg1 = reinterpret_cast< wxLocale * >(argp1);
16069 {
16070 arg2 = wxString_in_helper(obj1);
16071 if (arg2 == NULL) SWIG_fail;
16072 temp2 = true;
16073 }
16074 if (obj2) {
16075 {
16076 arg3 = wxString_in_helper(obj2);
16077 if (arg3 == NULL) SWIG_fail;
16078 temp3 = true;
16079 }
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 {
16088 #if wxUSE_UNICODE
16089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16090 #else
16091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16092 #endif
16093 }
16094 {
16095 if (temp2)
16096 delete arg2;
16097 }
16098 {
16099 if (temp3)
16100 delete arg3;
16101 }
16102 return resultobj;
16103 fail:
16104 {
16105 if (temp2)
16106 delete arg2;
16107 }
16108 {
16109 if (temp3)
16110 delete arg3;
16111 }
16112 return NULL;
16113 }
16114
16115
16116 SWIGINTERN PyObject *_wrap_Locale_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16117 PyObject *resultobj = 0;
16118 wxLocale *arg1 = (wxLocale *) 0 ;
16119 wxString *result = 0 ;
16120 void *argp1 = 0 ;
16121 int res1 = 0 ;
16122 PyObject *swig_obj[1] ;
16123
16124 if (!args) SWIG_fail;
16125 swig_obj[0] = args;
16126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetName" "', expected argument " "1"" of type '" "wxLocale const *""'");
16129 }
16130 arg1 = reinterpret_cast< wxLocale * >(argp1);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 {
16134 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
16135 result = (wxString *) &_result_ref;
16136 }
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 {
16141 #if wxUSE_UNICODE
16142 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16143 #else
16144 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16145 #endif
16146 }
16147 return resultobj;
16148 fail:
16149 return NULL;
16150 }
16151
16152
16153 SWIGINTERN PyObject *Locale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16154 PyObject *obj;
16155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16156 SWIG_TypeNewClientData(SWIGTYPE_p_wxLocale, SWIG_NewClientData(obj));
16157 return SWIG_Py_Void();
16158 }
16159
16160 SWIGINTERN PyObject *Locale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16161 return SWIG_Python_InitShadowInstance(args);
16162 }
16163
16164 SWIGINTERN PyObject *_wrap_new_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 int arg1 = (int) -1 ;
16167 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
16168 wxPyLocale *result = 0 ;
16169 int val1 ;
16170 int ecode1 = 0 ;
16171 int val2 ;
16172 int ecode2 = 0 ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "language",(char *) "flags", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyLocale",kwnames,&obj0,&obj1)) SWIG_fail;
16180 if (obj0) {
16181 ecode1 = SWIG_AsVal_int(obj0, &val1);
16182 if (!SWIG_IsOK(ecode1)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyLocale" "', expected argument " "1"" of type '" "int""'");
16184 }
16185 arg1 = static_cast< int >(val1);
16186 }
16187 if (obj1) {
16188 ecode2 = SWIG_AsVal_int(obj1, &val2);
16189 if (!SWIG_IsOK(ecode2)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyLocale" "', expected argument " "2"" of type '" "int""'");
16191 }
16192 arg2 = static_cast< int >(val2);
16193 }
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 result = (wxPyLocale *)new_wxPyLocale(arg1,arg2);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLocale, SWIG_POINTER_NEW | 0 );
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_delete_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16208 PyObject *resultobj = 0;
16209 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 PyObject *swig_obj[1] ;
16213
16214 if (!args) SWIG_fail;
16215 swig_obj[0] = args;
16216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyLocale, SWIG_POINTER_DISOWN | 0 );
16217 if (!SWIG_IsOK(res1)) {
16218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyLocale" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16219 }
16220 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 delete arg1;
16224
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 resultobj = SWIG_Py_Void();
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 SWIGINTERN PyObject *_wrap_PyLocale__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj = 0;
16237 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16238 PyObject *arg2 = (PyObject *) 0 ;
16239 PyObject *arg3 = (PyObject *) 0 ;
16240 void *argp1 = 0 ;
16241 int res1 = 0 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 PyObject * obj2 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "self",(char *) "_class", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLocale__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16253 }
16254 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16255 arg2 = obj1;
16256 arg3 = obj2;
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 (arg1)->_setCallbackInfo(arg2,arg3);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_Py_Void();
16264 return resultobj;
16265 fail:
16266 return NULL;
16267 }
16268
16269
16270 SWIGINTERN PyObject *_wrap_PyLocale_GetSingularString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = 0;
16272 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16273 wxChar *arg2 = (wxChar *) 0 ;
16274 wxChar *arg3 = (wxChar *) NULL ;
16275 wxChar *result = 0 ;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 void *argp2 = 0 ;
16279 int res2 = 0 ;
16280 void *argp3 = 0 ;
16281 int res3 = 0 ;
16282 PyObject * obj0 = 0 ;
16283 PyObject * obj1 = 0 ;
16284 PyObject * obj2 = 0 ;
16285 char * kwnames[] = {
16286 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16287 };
16288
16289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyLocale_GetSingularString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16291 if (!SWIG_IsOK(res1)) {
16292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetSingularString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
16293 }
16294 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
16296 if (!SWIG_IsOK(res2)) {
16297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetSingularString" "', expected argument " "2"" of type '" "wxChar const *""'");
16298 }
16299 arg2 = reinterpret_cast< wxChar * >(argp2);
16300 if (obj2) {
16301 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
16302 if (!SWIG_IsOK(res3)) {
16303 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetSingularString" "', expected argument " "3"" of type '" "wxChar const *""'");
16304 }
16305 arg3 = reinterpret_cast< wxChar * >(argp3);
16306 }
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = (wxChar *)((wxPyLocale const *)arg1)->GetSingularString((wxChar const *)arg2,(wxChar const *)arg3);
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 SWIGINTERN PyObject *_wrap_PyLocale_GetPluralString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj = 0;
16322 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16323 wxChar *arg2 = (wxChar *) 0 ;
16324 wxChar *arg3 = (wxChar *) 0 ;
16325 size_t arg4 ;
16326 wxChar *arg5 = (wxChar *) NULL ;
16327 wxChar *result = 0 ;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 void *argp2 = 0 ;
16331 int res2 = 0 ;
16332 void *argp3 = 0 ;
16333 int res3 = 0 ;
16334 size_t val4 ;
16335 int ecode4 = 0 ;
16336 void *argp5 = 0 ;
16337 int res5 = 0 ;
16338 PyObject * obj0 = 0 ;
16339 PyObject * obj1 = 0 ;
16340 PyObject * obj2 = 0 ;
16341 PyObject * obj3 = 0 ;
16342 PyObject * obj4 = 0 ;
16343 char * kwnames[] = {
16344 (char *) "self",(char *) "szOrigString",(char *) "szOrigString2",(char *) "n",(char *) "szDomain", NULL
16345 };
16346
16347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PyLocale_GetPluralString",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16349 if (!SWIG_IsOK(res1)) {
16350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetPluralString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
16351 }
16352 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
16354 if (!SWIG_IsOK(res2)) {
16355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetPluralString" "', expected argument " "2"" of type '" "wxChar const *""'");
16356 }
16357 arg2 = reinterpret_cast< wxChar * >(argp2);
16358 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
16359 if (!SWIG_IsOK(res3)) {
16360 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetPluralString" "', expected argument " "3"" of type '" "wxChar const *""'");
16361 }
16362 arg3 = reinterpret_cast< wxChar * >(argp3);
16363 ecode4 = SWIG_AsVal_size_t(obj3, &val4);
16364 if (!SWIG_IsOK(ecode4)) {
16365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyLocale_GetPluralString" "', expected argument " "4"" of type '" "size_t""'");
16366 }
16367 arg4 = static_cast< size_t >(val4);
16368 if (obj4) {
16369 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxChar, 0 | 0 );
16370 if (!SWIG_IsOK(res5)) {
16371 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PyLocale_GetPluralString" "', expected argument " "5"" of type '" "wxChar const *""'");
16372 }
16373 arg5 = reinterpret_cast< wxChar * >(argp5);
16374 }
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 result = (wxChar *)((wxPyLocale const *)arg1)->GetPluralString((wxChar const *)arg2,(wxChar const *)arg3,arg4,(wxChar const *)arg5);
16378 wxPyEndAllowThreads(__tstate);
16379 if (PyErr_Occurred()) SWIG_fail;
16380 }
16381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
16382 return resultobj;
16383 fail:
16384 return NULL;
16385 }
16386
16387
16388 SWIGINTERN PyObject *PyLocale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16389 PyObject *obj;
16390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16391 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLocale, SWIG_NewClientData(obj));
16392 return SWIG_Py_Void();
16393 }
16394
16395 SWIGINTERN PyObject *PyLocale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16396 return SWIG_Python_InitShadowInstance(args);
16397 }
16398
16399 SWIGINTERN PyObject *_wrap_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16400 PyObject *resultobj = 0;
16401 wxLocale *result = 0 ;
16402
16403 if (!SWIG_Python_UnpackTuple(args,"GetLocale",0,0,0)) SWIG_fail;
16404 {
16405 PyThreadState* __tstate = wxPyBeginAllowThreads();
16406 result = (wxLocale *)wxGetLocale();
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, 0 | 0 );
16411 return resultobj;
16412 fail:
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16418 PyObject *resultobj = 0;
16419 wxString *arg1 = 0 ;
16420 wxString result;
16421 bool temp1 = false ;
16422
16423 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
16424 {
16425 arg1 = wxString_in_helper(swig_obj[0]);
16426 if (arg1 == NULL) SWIG_fail;
16427 temp1 = true;
16428 }
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 result = wxGetTranslation((wxString const &)*arg1);
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 {
16436 #if wxUSE_UNICODE
16437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16438 #else
16439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16440 #endif
16441 }
16442 {
16443 if (temp1)
16444 delete arg1;
16445 }
16446 return resultobj;
16447 fail:
16448 {
16449 if (temp1)
16450 delete arg1;
16451 }
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16457 PyObject *resultobj = 0;
16458 wxString *arg1 = 0 ;
16459 wxString *arg2 = 0 ;
16460 wxString result;
16461 bool temp1 = false ;
16462 bool temp2 = false ;
16463
16464 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16465 {
16466 arg1 = wxString_in_helper(swig_obj[0]);
16467 if (arg1 == NULL) SWIG_fail;
16468 temp1 = true;
16469 }
16470 {
16471 arg2 = wxString_in_helper(swig_obj[1]);
16472 if (arg2 == NULL) SWIG_fail;
16473 temp2 = true;
16474 }
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2);
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 {
16482 #if wxUSE_UNICODE
16483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16484 #else
16485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16486 #endif
16487 }
16488 {
16489 if (temp1)
16490 delete arg1;
16491 }
16492 {
16493 if (temp2)
16494 delete arg2;
16495 }
16496 return resultobj;
16497 fail:
16498 {
16499 if (temp1)
16500 delete arg1;
16501 }
16502 {
16503 if (temp2)
16504 delete arg2;
16505 }
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16511 PyObject *resultobj = 0;
16512 wxString *arg1 = 0 ;
16513 wxString *arg2 = 0 ;
16514 size_t arg3 ;
16515 wxString result;
16516 bool temp1 = false ;
16517 bool temp2 = false ;
16518 size_t val3 ;
16519 int ecode3 = 0 ;
16520
16521 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
16522 {
16523 arg1 = wxString_in_helper(swig_obj[0]);
16524 if (arg1 == NULL) SWIG_fail;
16525 temp1 = true;
16526 }
16527 {
16528 arg2 = wxString_in_helper(swig_obj[1]);
16529 if (arg2 == NULL) SWIG_fail;
16530 temp2 = true;
16531 }
16532 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
16533 if (!SWIG_IsOK(ecode3)) {
16534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
16535 }
16536 arg3 = static_cast< size_t >(val3);
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 {
16544 #if wxUSE_UNICODE
16545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16546 #else
16547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16548 #endif
16549 }
16550 {
16551 if (temp1)
16552 delete arg1;
16553 }
16554 {
16555 if (temp2)
16556 delete arg2;
16557 }
16558 return resultobj;
16559 fail:
16560 {
16561 if (temp1)
16562 delete arg1;
16563 }
16564 {
16565 if (temp2)
16566 delete arg2;
16567 }
16568 return NULL;
16569 }
16570
16571
16572 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16573 PyObject *resultobj = 0;
16574 wxString *arg1 = 0 ;
16575 wxString *arg2 = 0 ;
16576 size_t arg3 ;
16577 wxString *arg4 = 0 ;
16578 wxString result;
16579 bool temp1 = false ;
16580 bool temp2 = false ;
16581 size_t val3 ;
16582 int ecode3 = 0 ;
16583 bool temp4 = false ;
16584
16585 if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
16586 {
16587 arg1 = wxString_in_helper(swig_obj[0]);
16588 if (arg1 == NULL) SWIG_fail;
16589 temp1 = true;
16590 }
16591 {
16592 arg2 = wxString_in_helper(swig_obj[1]);
16593 if (arg2 == NULL) SWIG_fail;
16594 temp2 = true;
16595 }
16596 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
16597 if (!SWIG_IsOK(ecode3)) {
16598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
16599 }
16600 arg3 = static_cast< size_t >(val3);
16601 {
16602 arg4 = wxString_in_helper(swig_obj[3]);
16603 if (arg4 == NULL) SWIG_fail;
16604 temp4 = true;
16605 }
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxString const &)*arg4);
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 {
16613 #if wxUSE_UNICODE
16614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16615 #else
16616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16617 #endif
16618 }
16619 {
16620 if (temp1)
16621 delete arg1;
16622 }
16623 {
16624 if (temp2)
16625 delete arg2;
16626 }
16627 {
16628 if (temp4)
16629 delete arg4;
16630 }
16631 return resultobj;
16632 fail:
16633 {
16634 if (temp1)
16635 delete arg1;
16636 }
16637 {
16638 if (temp2)
16639 delete arg2;
16640 }
16641 {
16642 if (temp4)
16643 delete arg4;
16644 }
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
16650 int argc;
16651 PyObject *argv[5];
16652
16653 if (!(argc = SWIG_Python_UnpackTuple(args,"GetTranslation",0,4,argv))) SWIG_fail;
16654 --argc;
16655 if (argc == 1) {
16656 return _wrap_GetTranslation__SWIG_0(self, argc, argv);
16657 }
16658 if (argc == 2) {
16659 return _wrap_GetTranslation__SWIG_1(self, argc, argv);
16660 }
16661 if (argc == 3) {
16662 return _wrap_GetTranslation__SWIG_2(self, argc, argv);
16663 }
16664 if (argc == 4) {
16665 return _wrap_GetTranslation__SWIG_3(self, argc, argv);
16666 }
16667
16668 fail:
16669 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_new_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16675 PyObject *resultobj = 0;
16676 wxEncodingConverter *result = 0 ;
16677
16678 if (!SWIG_Python_UnpackTuple(args,"new_EncodingConverter",0,0,0)) SWIG_fail;
16679 {
16680 PyThreadState* __tstate = wxPyBeginAllowThreads();
16681 result = (wxEncodingConverter *)new wxEncodingConverter();
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_NEW | 0 );
16686 return resultobj;
16687 fail:
16688 return NULL;
16689 }
16690
16691
16692 SWIGINTERN PyObject *_wrap_delete_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16693 PyObject *resultobj = 0;
16694 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16695 void *argp1 = 0 ;
16696 int res1 = 0 ;
16697 PyObject *swig_obj[1] ;
16698
16699 if (!args) SWIG_fail;
16700 swig_obj[0] = args;
16701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_DISOWN | 0 );
16702 if (!SWIG_IsOK(res1)) {
16703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingConverter" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16704 }
16705 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 delete arg1;
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 resultobj = SWIG_Py_Void();
16714 return resultobj;
16715 fail:
16716 return NULL;
16717 }
16718
16719
16720 SWIGINTERN PyObject *_wrap_EncodingConverter_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16721 PyObject *resultobj = 0;
16722 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16723 wxFontEncoding arg2 ;
16724 wxFontEncoding arg3 ;
16725 int arg4 = (int) wxCONVERT_STRICT ;
16726 bool result;
16727 void *argp1 = 0 ;
16728 int res1 = 0 ;
16729 int val2 ;
16730 int ecode2 = 0 ;
16731 int val3 ;
16732 int ecode3 = 0 ;
16733 int val4 ;
16734 int ecode4 = 0 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 PyObject * obj2 = 0 ;
16738 PyObject * obj3 = 0 ;
16739 char * kwnames[] = {
16740 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
16741 };
16742
16743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
16745 if (!SWIG_IsOK(res1)) {
16746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Init" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16747 }
16748 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16749 ecode2 = SWIG_AsVal_int(obj1, &val2);
16750 if (!SWIG_IsOK(ecode2)) {
16751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_Init" "', expected argument " "2"" of type '" "wxFontEncoding""'");
16752 }
16753 arg2 = static_cast< wxFontEncoding >(val2);
16754 ecode3 = SWIG_AsVal_int(obj2, &val3);
16755 if (!SWIG_IsOK(ecode3)) {
16756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EncodingConverter_Init" "', expected argument " "3"" of type '" "wxFontEncoding""'");
16757 }
16758 arg3 = static_cast< wxFontEncoding >(val3);
16759 if (obj3) {
16760 ecode4 = SWIG_AsVal_int(obj3, &val4);
16761 if (!SWIG_IsOK(ecode4)) {
16762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EncodingConverter_Init" "', expected argument " "4"" of type '" "int""'");
16763 }
16764 arg4 = static_cast< int >(val4);
16765 }
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (bool)(arg1)->Init(arg2,arg3,arg4);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 {
16773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16774 }
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_EncodingConverter_Convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16784 wxString *arg2 = 0 ;
16785 wxString result;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 bool temp2 = false ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 char * kwnames[] = {
16792 (char *) "self",(char *) "input", NULL
16793 };
16794
16795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) SWIG_fail;
16796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
16797 if (!SWIG_IsOK(res1)) {
16798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Convert" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16799 }
16800 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16801 {
16802 arg2 = wxString_in_helper(obj1);
16803 if (arg2 == NULL) SWIG_fail;
16804 temp2 = true;
16805 }
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = (arg1)->Convert((wxString const &)*arg2);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 {
16813 #if wxUSE_UNICODE
16814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16815 #else
16816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16817 #endif
16818 }
16819 {
16820 if (temp2)
16821 delete arg2;
16822 }
16823 return resultobj;
16824 fail:
16825 {
16826 if (temp2)
16827 delete arg2;
16828 }
16829 return NULL;
16830 }
16831
16832
16833 SWIGINTERN PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj = 0;
16835 wxFontEncoding arg1 ;
16836 int arg2 = (int) wxPLATFORM_CURRENT ;
16837 wxFontEncodingArray result;
16838 int val1 ;
16839 int ecode1 = 0 ;
16840 int val2 ;
16841 int ecode2 = 0 ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char * kwnames[] = {
16845 (char *) "enc",(char *) "platform", NULL
16846 };
16847
16848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) SWIG_fail;
16849 ecode1 = SWIG_AsVal_int(obj0, &val1);
16850 if (!SWIG_IsOK(ecode1)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16852 }
16853 arg1 = static_cast< wxFontEncoding >(val1);
16854 if (obj1) {
16855 ecode2 = SWIG_AsVal_int(obj1, &val2);
16856 if (!SWIG_IsOK(ecode2)) {
16857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "2"" of type '" "int""'");
16858 }
16859 arg2 = static_cast< int >(val2);
16860 }
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 result = wxEncodingConverter::GetPlatformEquivalents(arg1,arg2);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 resultobj = PyList_New(0);
16869 for (size_t i=0; i < (&result)->GetCount(); i++) {
16870 PyObject* number = PyInt_FromLong((&result)->Item(i));
16871 PyList_Append(resultobj, number);
16872 Py_DECREF(number);
16873 }
16874 }
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj = 0;
16883 wxFontEncoding arg1 ;
16884 wxFontEncodingArray result;
16885 int val1 ;
16886 int ecode1 = 0 ;
16887 PyObject * obj0 = 0 ;
16888 char * kwnames[] = {
16889 (char *) "enc", NULL
16890 };
16891
16892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) SWIG_fail;
16893 ecode1 = SWIG_AsVal_int(obj0, &val1);
16894 if (!SWIG_IsOK(ecode1)) {
16895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetAllEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16896 }
16897 arg1 = static_cast< wxFontEncoding >(val1);
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = wxEncodingConverter::GetAllEquivalents(arg1);
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 {
16905 resultobj = PyList_New(0);
16906 for (size_t i=0; i < (&result)->GetCount(); i++) {
16907 PyObject* number = PyInt_FromLong((&result)->Item(i));
16908 PyList_Append(resultobj, number);
16909 Py_DECREF(number);
16910 }
16911 }
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_EncodingConverter_CanConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16919 PyObject *resultobj = 0;
16920 wxFontEncoding arg1 ;
16921 wxFontEncoding arg2 ;
16922 bool result;
16923 int val1 ;
16924 int ecode1 = 0 ;
16925 int val2 ;
16926 int ecode2 = 0 ;
16927 PyObject * obj0 = 0 ;
16928 PyObject * obj1 = 0 ;
16929 char * kwnames[] = {
16930 (char *) "encIn",(char *) "encOut", NULL
16931 };
16932
16933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) SWIG_fail;
16934 ecode1 = SWIG_AsVal_int(obj0, &val1);
16935 if (!SWIG_IsOK(ecode1)) {
16936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_CanConvert" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16937 }
16938 arg1 = static_cast< wxFontEncoding >(val1);
16939 ecode2 = SWIG_AsVal_int(obj1, &val2);
16940 if (!SWIG_IsOK(ecode2)) {
16941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_CanConvert" "', expected argument " "2"" of type '" "wxFontEncoding""'");
16942 }
16943 arg2 = static_cast< wxFontEncoding >(val2);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (bool)wxEncodingConverter::CanConvert(arg1,arg2);
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 {
16951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16952 }
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 SWIGINTERN PyObject *EncodingConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 PyObject *obj;
16961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16962 SWIG_TypeNewClientData(SWIGTYPE_p_wxEncodingConverter, SWIG_NewClientData(obj));
16963 return SWIG_Py_Void();
16964 }
16965
16966 SWIGINTERN PyObject *EncodingConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16967 return SWIG_Python_InitShadowInstance(args);
16968 }
16969
16970 SWIGINTERN PyObject *_wrap_delete_DC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971 PyObject *resultobj = 0;
16972 wxDC *arg1 = (wxDC *) 0 ;
16973 void *argp1 = 0 ;
16974 int res1 = 0 ;
16975 PyObject *swig_obj[1] ;
16976
16977 if (!args) SWIG_fail;
16978 swig_obj[0] = args;
16979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, SWIG_POINTER_DISOWN | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DC" "', expected argument " "1"" of type '" "wxDC *""'");
16982 }
16983 arg1 = reinterpret_cast< wxDC * >(argp1);
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 delete arg1;
16987
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 resultobj = SWIG_Py_Void();
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_DC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj = 0;
17000 wxDC *arg1 = (wxDC *) 0 ;
17001 int arg2 ;
17002 int arg3 ;
17003 wxColour *arg4 = 0 ;
17004 int arg5 = (int) wxFLOOD_SURFACE ;
17005 bool result;
17006 void *argp1 = 0 ;
17007 int res1 = 0 ;
17008 int val2 ;
17009 int ecode2 = 0 ;
17010 int val3 ;
17011 int ecode3 = 0 ;
17012 wxColour temp4 ;
17013 int val5 ;
17014 int ecode5 = 0 ;
17015 PyObject * obj0 = 0 ;
17016 PyObject * obj1 = 0 ;
17017 PyObject * obj2 = 0 ;
17018 PyObject * obj3 = 0 ;
17019 PyObject * obj4 = 0 ;
17020 char * kwnames[] = {
17021 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
17022 };
17023
17024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17026 if (!SWIG_IsOK(res1)) {
17027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFill" "', expected argument " "1"" of type '" "wxDC *""'");
17028 }
17029 arg1 = reinterpret_cast< wxDC * >(argp1);
17030 ecode2 = SWIG_AsVal_int(obj1, &val2);
17031 if (!SWIG_IsOK(ecode2)) {
17032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_FloodFill" "', expected argument " "2"" of type '" "int""'");
17033 }
17034 arg2 = static_cast< int >(val2);
17035 ecode3 = SWIG_AsVal_int(obj2, &val3);
17036 if (!SWIG_IsOK(ecode3)) {
17037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_FloodFill" "', expected argument " "3"" of type '" "int""'");
17038 }
17039 arg3 = static_cast< int >(val3);
17040 {
17041 arg4 = &temp4;
17042 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17043 }
17044 if (obj4) {
17045 ecode5 = SWIG_AsVal_int(obj4, &val5);
17046 if (!SWIG_IsOK(ecode5)) {
17047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_FloodFill" "', expected argument " "5"" of type '" "int""'");
17048 }
17049 arg5 = static_cast< int >(val5);
17050 }
17051 {
17052 PyThreadState* __tstate = wxPyBeginAllowThreads();
17053 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 {
17058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17059 }
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 SWIGINTERN PyObject *_wrap_DC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj = 0;
17068 wxDC *arg1 = (wxDC *) 0 ;
17069 wxPoint *arg2 = 0 ;
17070 wxColour *arg3 = 0 ;
17071 int arg4 = (int) wxFLOOD_SURFACE ;
17072 bool result;
17073 void *argp1 = 0 ;
17074 int res1 = 0 ;
17075 wxPoint temp2 ;
17076 wxColour temp3 ;
17077 int val4 ;
17078 int ecode4 = 0 ;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 PyObject * obj2 = 0 ;
17082 PyObject * obj3 = 0 ;
17083 char * kwnames[] = {
17084 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
17085 };
17086
17087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17089 if (!SWIG_IsOK(res1)) {
17090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFillPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17091 }
17092 arg1 = reinterpret_cast< wxDC * >(argp1);
17093 {
17094 arg2 = &temp2;
17095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17096 }
17097 {
17098 arg3 = &temp3;
17099 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17100 }
17101 if (obj3) {
17102 ecode4 = SWIG_AsVal_int(obj3, &val4);
17103 if (!SWIG_IsOK(ecode4)) {
17104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
17105 }
17106 arg4 = static_cast< int >(val4);
17107 }
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
17111 wxPyEndAllowThreads(__tstate);
17112 if (PyErr_Occurred()) SWIG_fail;
17113 }
17114 {
17115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17116 }
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 SWIGINTERN PyObject *_wrap_DC_GradientFillConcentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = 0;
17125 wxDC *arg1 = (wxDC *) 0 ;
17126 wxRect *arg2 = 0 ;
17127 wxColour *arg3 = 0 ;
17128 wxColour *arg4 = 0 ;
17129 wxPoint *arg5 = 0 ;
17130 void *argp1 = 0 ;
17131 int res1 = 0 ;
17132 wxRect temp2 ;
17133 wxColour temp3 ;
17134 wxColour temp4 ;
17135 wxPoint temp5 ;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 PyObject * obj2 = 0 ;
17139 PyObject * obj3 = 0 ;
17140 PyObject * obj4 = 0 ;
17141 char * kwnames[] = {
17142 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "circleCenter", NULL
17143 };
17144
17145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_GradientFillConcentric",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17147 if (!SWIG_IsOK(res1)) {
17148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillConcentric" "', expected argument " "1"" of type '" "wxDC *""'");
17149 }
17150 arg1 = reinterpret_cast< wxDC * >(argp1);
17151 {
17152 arg2 = &temp2;
17153 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17154 }
17155 {
17156 arg3 = &temp3;
17157 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17158 }
17159 {
17160 arg4 = &temp4;
17161 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17162 }
17163 {
17164 arg5 = &temp5;
17165 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17166 }
17167 {
17168 PyThreadState* __tstate = wxPyBeginAllowThreads();
17169 (arg1)->GradientFillConcentric((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5);
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 resultobj = SWIG_Py_Void();
17174 return resultobj;
17175 fail:
17176 return NULL;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_DC_GradientFillLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17181 PyObject *resultobj = 0;
17182 wxDC *arg1 = (wxDC *) 0 ;
17183 wxRect *arg2 = 0 ;
17184 wxColour *arg3 = 0 ;
17185 wxColour *arg4 = 0 ;
17186 wxDirection arg5 = (wxDirection) wxEAST ;
17187 void *argp1 = 0 ;
17188 int res1 = 0 ;
17189 wxRect temp2 ;
17190 wxColour temp3 ;
17191 wxColour temp4 ;
17192 int val5 ;
17193 int ecode5 = 0 ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 PyObject * obj2 = 0 ;
17197 PyObject * obj3 = 0 ;
17198 PyObject * obj4 = 0 ;
17199 char * kwnames[] = {
17200 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "nDirection", NULL
17201 };
17202
17203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_GradientFillLinear",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17205 if (!SWIG_IsOK(res1)) {
17206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillLinear" "', expected argument " "1"" of type '" "wxDC *""'");
17207 }
17208 arg1 = reinterpret_cast< wxDC * >(argp1);
17209 {
17210 arg2 = &temp2;
17211 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17212 }
17213 {
17214 arg3 = &temp3;
17215 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17216 }
17217 {
17218 arg4 = &temp4;
17219 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17220 }
17221 if (obj4) {
17222 ecode5 = SWIG_AsVal_int(obj4, &val5);
17223 if (!SWIG_IsOK(ecode5)) {
17224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_GradientFillLinear" "', expected argument " "5"" of type '" "wxDirection""'");
17225 }
17226 arg5 = static_cast< wxDirection >(val5);
17227 }
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 (arg1)->GradientFillLinear((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,arg5);
17231 wxPyEndAllowThreads(__tstate);
17232 if (PyErr_Occurred()) SWIG_fail;
17233 }
17234 resultobj = SWIG_Py_Void();
17235 return resultobj;
17236 fail:
17237 return NULL;
17238 }
17239
17240
17241 SWIGINTERN PyObject *_wrap_DC_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17242 PyObject *resultobj = 0;
17243 wxDC *arg1 = (wxDC *) 0 ;
17244 int arg2 ;
17245 int arg3 ;
17246 wxColour result;
17247 void *argp1 = 0 ;
17248 int res1 = 0 ;
17249 int val2 ;
17250 int ecode2 = 0 ;
17251 int val3 ;
17252 int ecode3 = 0 ;
17253 PyObject * obj0 = 0 ;
17254 PyObject * obj1 = 0 ;
17255 PyObject * obj2 = 0 ;
17256 char * kwnames[] = {
17257 (char *) "self",(char *) "x",(char *) "y", NULL
17258 };
17259
17260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17262 if (!SWIG_IsOK(res1)) {
17263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixel" "', expected argument " "1"" of type '" "wxDC *""'");
17264 }
17265 arg1 = reinterpret_cast< wxDC * >(argp1);
17266 ecode2 = SWIG_AsVal_int(obj1, &val2);
17267 if (!SWIG_IsOK(ecode2)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_GetPixel" "', expected argument " "2"" of type '" "int""'");
17269 }
17270 arg2 = static_cast< int >(val2);
17271 ecode3 = SWIG_AsVal_int(obj2, &val3);
17272 if (!SWIG_IsOK(ecode3)) {
17273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_GetPixel" "', expected argument " "3"" of type '" "int""'");
17274 }
17275 arg3 = static_cast< int >(val3);
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = wxDC_GetPixel(arg1,arg2,arg3);
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *_wrap_DC_GetPixelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj = 0;
17291 wxDC *arg1 = (wxDC *) 0 ;
17292 wxPoint *arg2 = 0 ;
17293 wxColour result;
17294 void *argp1 = 0 ;
17295 int res1 = 0 ;
17296 wxPoint temp2 ;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "self",(char *) "pt", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17305 if (!SWIG_IsOK(res1)) {
17306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixelPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17307 }
17308 arg1 = reinterpret_cast< wxDC * >(argp1);
17309 {
17310 arg2 = &temp2;
17311 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17312 }
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 SWIGINTERN PyObject *_wrap_DC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj = 0;
17328 wxDC *arg1 = (wxDC *) 0 ;
17329 int arg2 ;
17330 int arg3 ;
17331 int arg4 ;
17332 int arg5 ;
17333 void *argp1 = 0 ;
17334 int res1 = 0 ;
17335 int val2 ;
17336 int ecode2 = 0 ;
17337 int val3 ;
17338 int ecode3 = 0 ;
17339 int val4 ;
17340 int ecode4 = 0 ;
17341 int val5 ;
17342 int ecode5 = 0 ;
17343 PyObject * obj0 = 0 ;
17344 PyObject * obj1 = 0 ;
17345 PyObject * obj2 = 0 ;
17346 PyObject * obj3 = 0 ;
17347 PyObject * obj4 = 0 ;
17348 char * kwnames[] = {
17349 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
17350 };
17351
17352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17354 if (!SWIG_IsOK(res1)) {
17355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLine" "', expected argument " "1"" of type '" "wxDC *""'");
17356 }
17357 arg1 = reinterpret_cast< wxDC * >(argp1);
17358 ecode2 = SWIG_AsVal_int(obj1, &val2);
17359 if (!SWIG_IsOK(ecode2)) {
17360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawLine" "', expected argument " "2"" of type '" "int""'");
17361 }
17362 arg2 = static_cast< int >(val2);
17363 ecode3 = SWIG_AsVal_int(obj2, &val3);
17364 if (!SWIG_IsOK(ecode3)) {
17365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawLine" "', expected argument " "3"" of type '" "int""'");
17366 }
17367 arg3 = static_cast< int >(val3);
17368 ecode4 = SWIG_AsVal_int(obj3, &val4);
17369 if (!SWIG_IsOK(ecode4)) {
17370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLine" "', expected argument " "4"" of type '" "int""'");
17371 }
17372 arg4 = static_cast< int >(val4);
17373 ecode5 = SWIG_AsVal_int(obj4, &val5);
17374 if (!SWIG_IsOK(ecode5)) {
17375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLine" "', expected argument " "5"" of type '" "int""'");
17376 }
17377 arg5 = static_cast< int >(val5);
17378 {
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 resultobj = SWIG_Py_Void();
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 SWIGINTERN PyObject *_wrap_DC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj = 0;
17393 wxDC *arg1 = (wxDC *) 0 ;
17394 wxPoint *arg2 = 0 ;
17395 wxPoint *arg3 = 0 ;
17396 void *argp1 = 0 ;
17397 int res1 = 0 ;
17398 wxPoint temp2 ;
17399 wxPoint temp3 ;
17400 PyObject * obj0 = 0 ;
17401 PyObject * obj1 = 0 ;
17402 PyObject * obj2 = 0 ;
17403 char * kwnames[] = {
17404 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
17405 };
17406
17407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17409 if (!SWIG_IsOK(res1)) {
17410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLinePoint" "', expected argument " "1"" of type '" "wxDC *""'");
17411 }
17412 arg1 = reinterpret_cast< wxDC * >(argp1);
17413 {
17414 arg2 = &temp2;
17415 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17416 }
17417 {
17418 arg3 = &temp3;
17419 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17420 }
17421 {
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
17424 wxPyEndAllowThreads(__tstate);
17425 if (PyErr_Occurred()) SWIG_fail;
17426 }
17427 resultobj = SWIG_Py_Void();
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 SWIGINTERN PyObject *_wrap_DC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj = 0;
17436 wxDC *arg1 = (wxDC *) 0 ;
17437 int arg2 ;
17438 int arg3 ;
17439 void *argp1 = 0 ;
17440 int res1 = 0 ;
17441 int val2 ;
17442 int ecode2 = 0 ;
17443 int val3 ;
17444 int ecode3 = 0 ;
17445 PyObject * obj0 = 0 ;
17446 PyObject * obj1 = 0 ;
17447 PyObject * obj2 = 0 ;
17448 char * kwnames[] = {
17449 (char *) "self",(char *) "x",(char *) "y", NULL
17450 };
17451
17452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17454 if (!SWIG_IsOK(res1)) {
17455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHair" "', expected argument " "1"" of type '" "wxDC *""'");
17456 }
17457 arg1 = reinterpret_cast< wxDC * >(argp1);
17458 ecode2 = SWIG_AsVal_int(obj1, &val2);
17459 if (!SWIG_IsOK(ecode2)) {
17460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CrossHair" "', expected argument " "2"" of type '" "int""'");
17461 }
17462 arg2 = static_cast< int >(val2);
17463 ecode3 = SWIG_AsVal_int(obj2, &val3);
17464 if (!SWIG_IsOK(ecode3)) {
17465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CrossHair" "', expected argument " "3"" of type '" "int""'");
17466 }
17467 arg3 = static_cast< int >(val3);
17468 {
17469 PyThreadState* __tstate = wxPyBeginAllowThreads();
17470 (arg1)->CrossHair(arg2,arg3);
17471 wxPyEndAllowThreads(__tstate);
17472 if (PyErr_Occurred()) SWIG_fail;
17473 }
17474 resultobj = SWIG_Py_Void();
17475 return resultobj;
17476 fail:
17477 return NULL;
17478 }
17479
17480
17481 SWIGINTERN PyObject *_wrap_DC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj = 0;
17483 wxDC *arg1 = (wxDC *) 0 ;
17484 wxPoint *arg2 = 0 ;
17485 void *argp1 = 0 ;
17486 int res1 = 0 ;
17487 wxPoint temp2 ;
17488 PyObject * obj0 = 0 ;
17489 PyObject * obj1 = 0 ;
17490 char * kwnames[] = {
17491 (char *) "self",(char *) "pt", NULL
17492 };
17493
17494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17496 if (!SWIG_IsOK(res1)) {
17497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHairPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17498 }
17499 arg1 = reinterpret_cast< wxDC * >(argp1);
17500 {
17501 arg2 = &temp2;
17502 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17503 }
17504 {
17505 PyThreadState* __tstate = wxPyBeginAllowThreads();
17506 (arg1)->CrossHair((wxPoint const &)*arg2);
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 resultobj = SWIG_Py_Void();
17511 return resultobj;
17512 fail:
17513 return NULL;
17514 }
17515
17516
17517 SWIGINTERN PyObject *_wrap_DC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj = 0;
17519 wxDC *arg1 = (wxDC *) 0 ;
17520 int arg2 ;
17521 int arg3 ;
17522 int arg4 ;
17523 int arg5 ;
17524 int arg6 ;
17525 int arg7 ;
17526 void *argp1 = 0 ;
17527 int res1 = 0 ;
17528 int val2 ;
17529 int ecode2 = 0 ;
17530 int val3 ;
17531 int ecode3 = 0 ;
17532 int val4 ;
17533 int ecode4 = 0 ;
17534 int val5 ;
17535 int ecode5 = 0 ;
17536 int val6 ;
17537 int ecode6 = 0 ;
17538 int val7 ;
17539 int ecode7 = 0 ;
17540 PyObject * obj0 = 0 ;
17541 PyObject * obj1 = 0 ;
17542 PyObject * obj2 = 0 ;
17543 PyObject * obj3 = 0 ;
17544 PyObject * obj4 = 0 ;
17545 PyObject * obj5 = 0 ;
17546 PyObject * obj6 = 0 ;
17547 char * kwnames[] = {
17548 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
17549 };
17550
17551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17553 if (!SWIG_IsOK(res1)) {
17554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArc" "', expected argument " "1"" of type '" "wxDC *""'");
17555 }
17556 arg1 = reinterpret_cast< wxDC * >(argp1);
17557 ecode2 = SWIG_AsVal_int(obj1, &val2);
17558 if (!SWIG_IsOK(ecode2)) {
17559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawArc" "', expected argument " "2"" of type '" "int""'");
17560 }
17561 arg2 = static_cast< int >(val2);
17562 ecode3 = SWIG_AsVal_int(obj2, &val3);
17563 if (!SWIG_IsOK(ecode3)) {
17564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawArc" "', expected argument " "3"" of type '" "int""'");
17565 }
17566 arg3 = static_cast< int >(val3);
17567 ecode4 = SWIG_AsVal_int(obj3, &val4);
17568 if (!SWIG_IsOK(ecode4)) {
17569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawArc" "', expected argument " "4"" of type '" "int""'");
17570 }
17571 arg4 = static_cast< int >(val4);
17572 ecode5 = SWIG_AsVal_int(obj4, &val5);
17573 if (!SWIG_IsOK(ecode5)) {
17574 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawArc" "', expected argument " "5"" of type '" "int""'");
17575 }
17576 arg5 = static_cast< int >(val5);
17577 ecode6 = SWIG_AsVal_int(obj5, &val6);
17578 if (!SWIG_IsOK(ecode6)) {
17579 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawArc" "', expected argument " "6"" of type '" "int""'");
17580 }
17581 arg6 = static_cast< int >(val6);
17582 ecode7 = SWIG_AsVal_int(obj6, &val7);
17583 if (!SWIG_IsOK(ecode7)) {
17584 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawArc" "', expected argument " "7"" of type '" "int""'");
17585 }
17586 arg7 = static_cast< int >(val7);
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 resultobj = SWIG_Py_Void();
17594 return resultobj;
17595 fail:
17596 return NULL;
17597 }
17598
17599
17600 SWIGINTERN PyObject *_wrap_DC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17601 PyObject *resultobj = 0;
17602 wxDC *arg1 = (wxDC *) 0 ;
17603 wxPoint *arg2 = 0 ;
17604 wxPoint *arg3 = 0 ;
17605 wxPoint *arg4 = 0 ;
17606 void *argp1 = 0 ;
17607 int res1 = 0 ;
17608 wxPoint temp2 ;
17609 wxPoint temp3 ;
17610 wxPoint temp4 ;
17611 PyObject * obj0 = 0 ;
17612 PyObject * obj1 = 0 ;
17613 PyObject * obj2 = 0 ;
17614 PyObject * obj3 = 0 ;
17615 char * kwnames[] = {
17616 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
17617 };
17618
17619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17621 if (!SWIG_IsOK(res1)) {
17622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArcPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17623 }
17624 arg1 = reinterpret_cast< wxDC * >(argp1);
17625 {
17626 arg2 = &temp2;
17627 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17628 }
17629 {
17630 arg3 = &temp3;
17631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17632 }
17633 {
17634 arg4 = &temp4;
17635 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17636 }
17637 {
17638 PyThreadState* __tstate = wxPyBeginAllowThreads();
17639 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
17640 wxPyEndAllowThreads(__tstate);
17641 if (PyErr_Occurred()) SWIG_fail;
17642 }
17643 resultobj = SWIG_Py_Void();
17644 return resultobj;
17645 fail:
17646 return NULL;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_DC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj = 0;
17652 wxDC *arg1 = (wxDC *) 0 ;
17653 int arg2 ;
17654 int arg3 ;
17655 int arg4 ;
17656 int arg5 ;
17657 void *argp1 = 0 ;
17658 int res1 = 0 ;
17659 int val2 ;
17660 int ecode2 = 0 ;
17661 int val3 ;
17662 int ecode3 = 0 ;
17663 int val4 ;
17664 int ecode4 = 0 ;
17665 int val5 ;
17666 int ecode5 = 0 ;
17667 PyObject * obj0 = 0 ;
17668 PyObject * obj1 = 0 ;
17669 PyObject * obj2 = 0 ;
17670 PyObject * obj3 = 0 ;
17671 PyObject * obj4 = 0 ;
17672 char * kwnames[] = {
17673 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17674 };
17675
17676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17678 if (!SWIG_IsOK(res1)) {
17679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMark" "', expected argument " "1"" of type '" "wxDC *""'");
17680 }
17681 arg1 = reinterpret_cast< wxDC * >(argp1);
17682 ecode2 = SWIG_AsVal_int(obj1, &val2);
17683 if (!SWIG_IsOK(ecode2)) {
17684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
17685 }
17686 arg2 = static_cast< int >(val2);
17687 ecode3 = SWIG_AsVal_int(obj2, &val3);
17688 if (!SWIG_IsOK(ecode3)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
17690 }
17691 arg3 = static_cast< int >(val3);
17692 ecode4 = SWIG_AsVal_int(obj3, &val4);
17693 if (!SWIG_IsOK(ecode4)) {
17694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
17695 }
17696 arg4 = static_cast< int >(val4);
17697 ecode5 = SWIG_AsVal_int(obj4, &val5);
17698 if (!SWIG_IsOK(ecode5)) {
17699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
17700 }
17701 arg5 = static_cast< int >(val5);
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_Py_Void();
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj = 0;
17717 wxDC *arg1 = (wxDC *) 0 ;
17718 wxRect *arg2 = 0 ;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 wxRect temp2 ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 char * kwnames[] = {
17725 (char *) "self",(char *) "rect", NULL
17726 };
17727
17728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
17729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17730 if (!SWIG_IsOK(res1)) {
17731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxDC *""'");
17732 }
17733 arg1 = reinterpret_cast< wxDC * >(argp1);
17734 {
17735 arg2 = &temp2;
17736 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17737 }
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 (arg1)->DrawCheckMark((wxRect const &)*arg2);
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 resultobj = SWIG_Py_Void();
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj = 0;
17753 wxDC *arg1 = (wxDC *) 0 ;
17754 int arg2 ;
17755 int arg3 ;
17756 int arg4 ;
17757 int arg5 ;
17758 double arg6 ;
17759 double arg7 ;
17760 void *argp1 = 0 ;
17761 int res1 = 0 ;
17762 int val2 ;
17763 int ecode2 = 0 ;
17764 int val3 ;
17765 int ecode3 = 0 ;
17766 int val4 ;
17767 int ecode4 = 0 ;
17768 int val5 ;
17769 int ecode5 = 0 ;
17770 double val6 ;
17771 int ecode6 = 0 ;
17772 double val7 ;
17773 int ecode7 = 0 ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 PyObject * obj2 = 0 ;
17777 PyObject * obj3 = 0 ;
17778 PyObject * obj4 = 0 ;
17779 PyObject * obj5 = 0 ;
17780 PyObject * obj6 = 0 ;
17781 char * kwnames[] = {
17782 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
17783 };
17784
17785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17787 if (!SWIG_IsOK(res1)) {
17788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxDC *""'");
17789 }
17790 arg1 = reinterpret_cast< wxDC * >(argp1);
17791 ecode2 = SWIG_AsVal_int(obj1, &val2);
17792 if (!SWIG_IsOK(ecode2)) {
17793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
17794 }
17795 arg2 = static_cast< int >(val2);
17796 ecode3 = SWIG_AsVal_int(obj2, &val3);
17797 if (!SWIG_IsOK(ecode3)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
17799 }
17800 arg3 = static_cast< int >(val3);
17801 ecode4 = SWIG_AsVal_int(obj3, &val4);
17802 if (!SWIG_IsOK(ecode4)) {
17803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
17804 }
17805 arg4 = static_cast< int >(val4);
17806 ecode5 = SWIG_AsVal_int(obj4, &val5);
17807 if (!SWIG_IsOK(ecode5)) {
17808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
17809 }
17810 arg5 = static_cast< int >(val5);
17811 ecode6 = SWIG_AsVal_double(obj5, &val6);
17812 if (!SWIG_IsOK(ecode6)) {
17813 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
17814 }
17815 arg6 = static_cast< double >(val6);
17816 ecode7 = SWIG_AsVal_double(obj6, &val7);
17817 if (!SWIG_IsOK(ecode7)) {
17818 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
17819 }
17820 arg7 = static_cast< double >(val7);
17821 {
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 resultobj = SWIG_Py_Void();
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = 0;
17836 wxDC *arg1 = (wxDC *) 0 ;
17837 wxPoint *arg2 = 0 ;
17838 wxSize *arg3 = 0 ;
17839 double arg4 ;
17840 double arg5 ;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 wxPoint temp2 ;
17844 wxSize temp3 ;
17845 double val4 ;
17846 int ecode4 = 0 ;
17847 double val5 ;
17848 int ecode5 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 PyObject * obj2 = 0 ;
17852 PyObject * obj3 = 0 ;
17853 PyObject * obj4 = 0 ;
17854 char * kwnames[] = {
17855 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
17856 };
17857
17858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17860 if (!SWIG_IsOK(res1)) {
17861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
17862 }
17863 arg1 = reinterpret_cast< wxDC * >(argp1);
17864 {
17865 arg2 = &temp2;
17866 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17867 }
17868 {
17869 arg3 = &temp3;
17870 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17871 }
17872 ecode4 = SWIG_AsVal_double(obj3, &val4);
17873 if (!SWIG_IsOK(ecode4)) {
17874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
17875 }
17876 arg4 = static_cast< double >(val4);
17877 ecode5 = SWIG_AsVal_double(obj4, &val5);
17878 if (!SWIG_IsOK(ecode5)) {
17879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
17880 }
17881 arg5 = static_cast< double >(val5);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_Py_Void();
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_DC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj = 0;
17897 wxDC *arg1 = (wxDC *) 0 ;
17898 int arg2 ;
17899 int arg3 ;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 int val2 ;
17903 int ecode2 = 0 ;
17904 int val3 ;
17905 int ecode3 = 0 ;
17906 PyObject * obj0 = 0 ;
17907 PyObject * obj1 = 0 ;
17908 PyObject * obj2 = 0 ;
17909 char * kwnames[] = {
17910 (char *) "self",(char *) "x",(char *) "y", NULL
17911 };
17912
17913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17915 if (!SWIG_IsOK(res1)) {
17916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17917 }
17918 arg1 = reinterpret_cast< wxDC * >(argp1);
17919 ecode2 = SWIG_AsVal_int(obj1, &val2);
17920 if (!SWIG_IsOK(ecode2)) {
17921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
17922 }
17923 arg2 = static_cast< int >(val2);
17924 ecode3 = SWIG_AsVal_int(obj2, &val3);
17925 if (!SWIG_IsOK(ecode3)) {
17926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
17927 }
17928 arg3 = static_cast< int >(val3);
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 (arg1)->DrawPoint(arg2,arg3);
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 resultobj = SWIG_Py_Void();
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 SWIGINTERN PyObject *_wrap_DC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj = 0;
17944 wxDC *arg1 = (wxDC *) 0 ;
17945 wxPoint *arg2 = 0 ;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 wxPoint temp2 ;
17949 PyObject * obj0 = 0 ;
17950 PyObject * obj1 = 0 ;
17951 char * kwnames[] = {
17952 (char *) "self",(char *) "pt", NULL
17953 };
17954
17955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPointPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17959 }
17960 arg1 = reinterpret_cast< wxDC * >(argp1);
17961 {
17962 arg2 = &temp2;
17963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17964 }
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 (arg1)->DrawPoint((wxPoint const &)*arg2);
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 resultobj = SWIG_Py_Void();
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_DC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj = 0;
17980 wxDC *arg1 = (wxDC *) 0 ;
17981 int arg2 ;
17982 int arg3 ;
17983 int arg4 ;
17984 int arg5 ;
17985 void *argp1 = 0 ;
17986 int res1 = 0 ;
17987 int val2 ;
17988 int ecode2 = 0 ;
17989 int val3 ;
17990 int ecode3 = 0 ;
17991 int val4 ;
17992 int ecode4 = 0 ;
17993 int val5 ;
17994 int ecode5 = 0 ;
17995 PyObject * obj0 = 0 ;
17996 PyObject * obj1 = 0 ;
17997 PyObject * obj2 = 0 ;
17998 PyObject * obj3 = 0 ;
17999 PyObject * obj4 = 0 ;
18000 char * kwnames[] = {
18001 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18002 };
18003
18004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18006 if (!SWIG_IsOK(res1)) {
18007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18008 }
18009 arg1 = reinterpret_cast< wxDC * >(argp1);
18010 ecode2 = SWIG_AsVal_int(obj1, &val2);
18011 if (!SWIG_IsOK(ecode2)) {
18012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
18013 }
18014 arg2 = static_cast< int >(val2);
18015 ecode3 = SWIG_AsVal_int(obj2, &val3);
18016 if (!SWIG_IsOK(ecode3)) {
18017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
18018 }
18019 arg3 = static_cast< int >(val3);
18020 ecode4 = SWIG_AsVal_int(obj3, &val4);
18021 if (!SWIG_IsOK(ecode4)) {
18022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
18023 }
18024 arg4 = static_cast< int >(val4);
18025 ecode5 = SWIG_AsVal_int(obj4, &val5);
18026 if (!SWIG_IsOK(ecode5)) {
18027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
18028 }
18029 arg5 = static_cast< int >(val5);
18030 {
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
18033 wxPyEndAllowThreads(__tstate);
18034 if (PyErr_Occurred()) SWIG_fail;
18035 }
18036 resultobj = SWIG_Py_Void();
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 SWIGINTERN PyObject *_wrap_DC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18044 PyObject *resultobj = 0;
18045 wxDC *arg1 = (wxDC *) 0 ;
18046 wxRect *arg2 = 0 ;
18047 void *argp1 = 0 ;
18048 int res1 = 0 ;
18049 wxRect temp2 ;
18050 PyObject * obj0 = 0 ;
18051 PyObject * obj1 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "rect", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18060 }
18061 arg1 = reinterpret_cast< wxDC * >(argp1);
18062 {
18063 arg2 = &temp2;
18064 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 (arg1)->DrawRectangle((wxRect const &)*arg2);
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = SWIG_Py_Void();
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18080 PyObject *resultobj = 0;
18081 wxDC *arg1 = (wxDC *) 0 ;
18082 wxPoint *arg2 = 0 ;
18083 wxSize *arg3 = 0 ;
18084 void *argp1 = 0 ;
18085 int res1 = 0 ;
18086 wxPoint temp2 ;
18087 wxSize temp3 ;
18088 PyObject * obj0 = 0 ;
18089 PyObject * obj1 = 0 ;
18090 PyObject * obj2 = 0 ;
18091 char * kwnames[] = {
18092 (char *) "self",(char *) "pt",(char *) "sz", NULL
18093 };
18094
18095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18097 if (!SWIG_IsOK(res1)) {
18098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18099 }
18100 arg1 = reinterpret_cast< wxDC * >(argp1);
18101 {
18102 arg2 = &temp2;
18103 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18104 }
18105 {
18106 arg3 = &temp3;
18107 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18108 }
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 resultobj = SWIG_Py_Void();
18116 return resultobj;
18117 fail:
18118 return NULL;
18119 }
18120
18121
18122 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18123 PyObject *resultobj = 0;
18124 wxDC *arg1 = (wxDC *) 0 ;
18125 int arg2 ;
18126 int arg3 ;
18127 int arg4 ;
18128 int arg5 ;
18129 double arg6 ;
18130 void *argp1 = 0 ;
18131 int res1 = 0 ;
18132 int val2 ;
18133 int ecode2 = 0 ;
18134 int val3 ;
18135 int ecode3 = 0 ;
18136 int val4 ;
18137 int ecode4 = 0 ;
18138 int val5 ;
18139 int ecode5 = 0 ;
18140 double val6 ;
18141 int ecode6 = 0 ;
18142 PyObject * obj0 = 0 ;
18143 PyObject * obj1 = 0 ;
18144 PyObject * obj2 = 0 ;
18145 PyObject * obj3 = 0 ;
18146 PyObject * obj4 = 0 ;
18147 PyObject * obj5 = 0 ;
18148 char * kwnames[] = {
18149 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
18150 };
18151
18152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18154 if (!SWIG_IsOK(res1)) {
18155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18156 }
18157 arg1 = reinterpret_cast< wxDC * >(argp1);
18158 ecode2 = SWIG_AsVal_int(obj1, &val2);
18159 if (!SWIG_IsOK(ecode2)) {
18160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
18161 }
18162 arg2 = static_cast< int >(val2);
18163 ecode3 = SWIG_AsVal_int(obj2, &val3);
18164 if (!SWIG_IsOK(ecode3)) {
18165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
18166 }
18167 arg3 = static_cast< int >(val3);
18168 ecode4 = SWIG_AsVal_int(obj3, &val4);
18169 if (!SWIG_IsOK(ecode4)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
18171 }
18172 arg4 = static_cast< int >(val4);
18173 ecode5 = SWIG_AsVal_int(obj4, &val5);
18174 if (!SWIG_IsOK(ecode5)) {
18175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
18176 }
18177 arg5 = static_cast< int >(val5);
18178 ecode6 = SWIG_AsVal_double(obj5, &val6);
18179 if (!SWIG_IsOK(ecode6)) {
18180 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
18181 }
18182 arg6 = static_cast< double >(val6);
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_Py_Void();
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj = 0;
18198 wxDC *arg1 = (wxDC *) 0 ;
18199 wxRect *arg2 = 0 ;
18200 double arg3 ;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 wxRect temp2 ;
18204 double val3 ;
18205 int ecode3 = 0 ;
18206 PyObject * obj0 = 0 ;
18207 PyObject * obj1 = 0 ;
18208 PyObject * obj2 = 0 ;
18209 char * kwnames[] = {
18210 (char *) "self",(char *) "r",(char *) "radius", NULL
18211 };
18212
18213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18215 if (!SWIG_IsOK(res1)) {
18216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18217 }
18218 arg1 = reinterpret_cast< wxDC * >(argp1);
18219 {
18220 arg2 = &temp2;
18221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18222 }
18223 ecode3 = SWIG_AsVal_double(obj2, &val3);
18224 if (!SWIG_IsOK(ecode3)) {
18225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
18226 }
18227 arg3 = static_cast< double >(val3);
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 resultobj = SWIG_Py_Void();
18235 return resultobj;
18236 fail:
18237 return NULL;
18238 }
18239
18240
18241 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18242 PyObject *resultobj = 0;
18243 wxDC *arg1 = (wxDC *) 0 ;
18244 wxPoint *arg2 = 0 ;
18245 wxSize *arg3 = 0 ;
18246 double arg4 ;
18247 void *argp1 = 0 ;
18248 int res1 = 0 ;
18249 wxPoint temp2 ;
18250 wxSize temp3 ;
18251 double val4 ;
18252 int ecode4 = 0 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 PyObject * obj2 = 0 ;
18256 PyObject * obj3 = 0 ;
18257 char * kwnames[] = {
18258 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
18259 };
18260
18261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18263 if (!SWIG_IsOK(res1)) {
18264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18265 }
18266 arg1 = reinterpret_cast< wxDC * >(argp1);
18267 {
18268 arg2 = &temp2;
18269 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18270 }
18271 {
18272 arg3 = &temp3;
18273 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18274 }
18275 ecode4 = SWIG_AsVal_double(obj3, &val4);
18276 if (!SWIG_IsOK(ecode4)) {
18277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
18278 }
18279 arg4 = static_cast< double >(val4);
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 resultobj = SWIG_Py_Void();
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_DC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxDC *arg1 = (wxDC *) 0 ;
18296 int arg2 ;
18297 int arg3 ;
18298 int arg4 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 int val2 ;
18302 int ecode2 = 0 ;
18303 int val3 ;
18304 int ecode3 = 0 ;
18305 int val4 ;
18306 int ecode4 = 0 ;
18307 PyObject * obj0 = 0 ;
18308 PyObject * obj1 = 0 ;
18309 PyObject * obj2 = 0 ;
18310 PyObject * obj3 = 0 ;
18311 char * kwnames[] = {
18312 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
18313 };
18314
18315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18317 if (!SWIG_IsOK(res1)) {
18318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCircle" "', expected argument " "1"" of type '" "wxDC *""'");
18319 }
18320 arg1 = reinterpret_cast< wxDC * >(argp1);
18321 ecode2 = SWIG_AsVal_int(obj1, &val2);
18322 if (!SWIG_IsOK(ecode2)) {
18323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
18324 }
18325 arg2 = static_cast< int >(val2);
18326 ecode3 = SWIG_AsVal_int(obj2, &val3);
18327 if (!SWIG_IsOK(ecode3)) {
18328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
18329 }
18330 arg3 = static_cast< int >(val3);
18331 ecode4 = SWIG_AsVal_int(obj3, &val4);
18332 if (!SWIG_IsOK(ecode4)) {
18333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
18334 }
18335 arg4 = static_cast< int >(val4);
18336 {
18337 PyThreadState* __tstate = wxPyBeginAllowThreads();
18338 (arg1)->DrawCircle(arg2,arg3,arg4);
18339 wxPyEndAllowThreads(__tstate);
18340 if (PyErr_Occurred()) SWIG_fail;
18341 }
18342 resultobj = SWIG_Py_Void();
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 SWIGINTERN PyObject *_wrap_DC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18350 PyObject *resultobj = 0;
18351 wxDC *arg1 = (wxDC *) 0 ;
18352 wxPoint *arg2 = 0 ;
18353 int arg3 ;
18354 void *argp1 = 0 ;
18355 int res1 = 0 ;
18356 wxPoint temp2 ;
18357 int val3 ;
18358 int ecode3 = 0 ;
18359 PyObject * obj0 = 0 ;
18360 PyObject * obj1 = 0 ;
18361 PyObject * obj2 = 0 ;
18362 char * kwnames[] = {
18363 (char *) "self",(char *) "pt",(char *) "radius", NULL
18364 };
18365
18366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18368 if (!SWIG_IsOK(res1)) {
18369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxDC *""'");
18370 }
18371 arg1 = reinterpret_cast< wxDC * >(argp1);
18372 {
18373 arg2 = &temp2;
18374 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18375 }
18376 ecode3 = SWIG_AsVal_int(obj2, &val3);
18377 if (!SWIG_IsOK(ecode3)) {
18378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
18379 }
18380 arg3 = static_cast< int >(val3);
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
18384 wxPyEndAllowThreads(__tstate);
18385 if (PyErr_Occurred()) SWIG_fail;
18386 }
18387 resultobj = SWIG_Py_Void();
18388 return resultobj;
18389 fail:
18390 return NULL;
18391 }
18392
18393
18394 SWIGINTERN PyObject *_wrap_DC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18395 PyObject *resultobj = 0;
18396 wxDC *arg1 = (wxDC *) 0 ;
18397 int arg2 ;
18398 int arg3 ;
18399 int arg4 ;
18400 int arg5 ;
18401 void *argp1 = 0 ;
18402 int res1 = 0 ;
18403 int val2 ;
18404 int ecode2 = 0 ;
18405 int val3 ;
18406 int ecode3 = 0 ;
18407 int val4 ;
18408 int ecode4 = 0 ;
18409 int val5 ;
18410 int ecode5 = 0 ;
18411 PyObject * obj0 = 0 ;
18412 PyObject * obj1 = 0 ;
18413 PyObject * obj2 = 0 ;
18414 PyObject * obj3 = 0 ;
18415 PyObject * obj4 = 0 ;
18416 char * kwnames[] = {
18417 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18418 };
18419
18420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipse" "', expected argument " "1"" of type '" "wxDC *""'");
18424 }
18425 arg1 = reinterpret_cast< wxDC * >(argp1);
18426 ecode2 = SWIG_AsVal_int(obj1, &val2);
18427 if (!SWIG_IsOK(ecode2)) {
18428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
18429 }
18430 arg2 = static_cast< int >(val2);
18431 ecode3 = SWIG_AsVal_int(obj2, &val3);
18432 if (!SWIG_IsOK(ecode3)) {
18433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
18434 }
18435 arg3 = static_cast< int >(val3);
18436 ecode4 = SWIG_AsVal_int(obj3, &val4);
18437 if (!SWIG_IsOK(ecode4)) {
18438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
18439 }
18440 arg4 = static_cast< int >(val4);
18441 ecode5 = SWIG_AsVal_int(obj4, &val5);
18442 if (!SWIG_IsOK(ecode5)) {
18443 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
18444 }
18445 arg5 = static_cast< int >(val5);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 resultobj = SWIG_Py_Void();
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 SWIGINTERN PyObject *_wrap_DC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj = 0;
18461 wxDC *arg1 = (wxDC *) 0 ;
18462 wxRect *arg2 = 0 ;
18463 void *argp1 = 0 ;
18464 int res1 = 0 ;
18465 wxRect temp2 ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 char * kwnames[] = {
18469 (char *) "self",(char *) "rect", NULL
18470 };
18471
18472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
18473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxDC *""'");
18476 }
18477 arg1 = reinterpret_cast< wxDC * >(argp1);
18478 {
18479 arg2 = &temp2;
18480 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18481 }
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 (arg1)->DrawEllipse((wxRect const &)*arg2);
18485 wxPyEndAllowThreads(__tstate);
18486 if (PyErr_Occurred()) SWIG_fail;
18487 }
18488 resultobj = SWIG_Py_Void();
18489 return resultobj;
18490 fail:
18491 return NULL;
18492 }
18493
18494
18495 SWIGINTERN PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18496 PyObject *resultobj = 0;
18497 wxDC *arg1 = (wxDC *) 0 ;
18498 wxPoint *arg2 = 0 ;
18499 wxSize *arg3 = 0 ;
18500 void *argp1 = 0 ;
18501 int res1 = 0 ;
18502 wxPoint temp2 ;
18503 wxSize temp3 ;
18504 PyObject * obj0 = 0 ;
18505 PyObject * obj1 = 0 ;
18506 PyObject * obj2 = 0 ;
18507 char * kwnames[] = {
18508 (char *) "self",(char *) "pt",(char *) "sz", NULL
18509 };
18510
18511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18513 if (!SWIG_IsOK(res1)) {
18514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18515 }
18516 arg1 = reinterpret_cast< wxDC * >(argp1);
18517 {
18518 arg2 = &temp2;
18519 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18520 }
18521 {
18522 arg3 = &temp3;
18523 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18524 }
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
18528 wxPyEndAllowThreads(__tstate);
18529 if (PyErr_Occurred()) SWIG_fail;
18530 }
18531 resultobj = SWIG_Py_Void();
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_DC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxDC *arg1 = (wxDC *) 0 ;
18541 wxIcon *arg2 = 0 ;
18542 int arg3 ;
18543 int arg4 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 void *argp2 = 0 ;
18547 int res2 = 0 ;
18548 int val3 ;
18549 int ecode3 = 0 ;
18550 int val4 ;
18551 int ecode4 = 0 ;
18552 PyObject * obj0 = 0 ;
18553 PyObject * obj1 = 0 ;
18554 PyObject * obj2 = 0 ;
18555 PyObject * obj3 = 0 ;
18556 char * kwnames[] = {
18557 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
18558 };
18559
18560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIcon" "', expected argument " "1"" of type '" "wxDC *""'");
18564 }
18565 arg1 = reinterpret_cast< wxDC * >(argp1);
18566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
18567 if (!SWIG_IsOK(res2)) {
18568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
18569 }
18570 if (!argp2) {
18571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
18572 }
18573 arg2 = reinterpret_cast< wxIcon * >(argp2);
18574 ecode3 = SWIG_AsVal_int(obj2, &val3);
18575 if (!SWIG_IsOK(ecode3)) {
18576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
18577 }
18578 arg3 = static_cast< int >(val3);
18579 ecode4 = SWIG_AsVal_int(obj3, &val4);
18580 if (!SWIG_IsOK(ecode4)) {
18581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
18582 }
18583 arg4 = static_cast< int >(val4);
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_DC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj = 0;
18599 wxDC *arg1 = (wxDC *) 0 ;
18600 wxIcon *arg2 = 0 ;
18601 wxPoint *arg3 = 0 ;
18602 void *argp1 = 0 ;
18603 int res1 = 0 ;
18604 void *argp2 = 0 ;
18605 int res2 = 0 ;
18606 wxPoint temp3 ;
18607 PyObject * obj0 = 0 ;
18608 PyObject * obj1 = 0 ;
18609 PyObject * obj2 = 0 ;
18610 char * kwnames[] = {
18611 (char *) "self",(char *) "icon",(char *) "pt", NULL
18612 };
18613
18614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18616 if (!SWIG_IsOK(res1)) {
18617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIconPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18618 }
18619 arg1 = reinterpret_cast< wxDC * >(argp1);
18620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
18621 if (!SWIG_IsOK(res2)) {
18622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
18623 }
18624 if (!argp2) {
18625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
18626 }
18627 arg2 = reinterpret_cast< wxIcon * >(argp2);
18628 {
18629 arg3 = &temp3;
18630 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18631 }
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 resultobj = SWIG_Py_Void();
18639 return resultobj;
18640 fail:
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_DC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18646 PyObject *resultobj = 0;
18647 wxDC *arg1 = (wxDC *) 0 ;
18648 wxBitmap *arg2 = 0 ;
18649 int arg3 ;
18650 int arg4 ;
18651 bool arg5 = (bool) false ;
18652 void *argp1 = 0 ;
18653 int res1 = 0 ;
18654 void *argp2 = 0 ;
18655 int res2 = 0 ;
18656 int val3 ;
18657 int ecode3 = 0 ;
18658 int val4 ;
18659 int ecode4 = 0 ;
18660 bool val5 ;
18661 int ecode5 = 0 ;
18662 PyObject * obj0 = 0 ;
18663 PyObject * obj1 = 0 ;
18664 PyObject * obj2 = 0 ;
18665 PyObject * obj3 = 0 ;
18666 PyObject * obj4 = 0 ;
18667 char * kwnames[] = {
18668 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
18669 };
18670
18671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmap" "', expected argument " "1"" of type '" "wxDC *""'");
18675 }
18676 arg1 = reinterpret_cast< wxDC * >(argp1);
18677 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
18678 if (!SWIG_IsOK(res2)) {
18679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18680 }
18681 if (!argp2) {
18682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18683 }
18684 arg2 = reinterpret_cast< wxBitmap * >(argp2);
18685 ecode3 = SWIG_AsVal_int(obj2, &val3);
18686 if (!SWIG_IsOK(ecode3)) {
18687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
18688 }
18689 arg3 = static_cast< int >(val3);
18690 ecode4 = SWIG_AsVal_int(obj3, &val4);
18691 if (!SWIG_IsOK(ecode4)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
18693 }
18694 arg4 = static_cast< int >(val4);
18695 if (obj4) {
18696 ecode5 = SWIG_AsVal_bool(obj4, &val5);
18697 if (!SWIG_IsOK(ecode5)) {
18698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
18699 }
18700 arg5 = static_cast< bool >(val5);
18701 }
18702 {
18703 PyThreadState* __tstate = wxPyBeginAllowThreads();
18704 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 resultobj = SWIG_Py_Void();
18709 return resultobj;
18710 fail:
18711 return NULL;
18712 }
18713
18714
18715 SWIGINTERN PyObject *_wrap_DC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18716 PyObject *resultobj = 0;
18717 wxDC *arg1 = (wxDC *) 0 ;
18718 wxBitmap *arg2 = 0 ;
18719 wxPoint *arg3 = 0 ;
18720 bool arg4 = (bool) false ;
18721 void *argp1 = 0 ;
18722 int res1 = 0 ;
18723 void *argp2 = 0 ;
18724 int res2 = 0 ;
18725 wxPoint temp3 ;
18726 bool val4 ;
18727 int ecode4 = 0 ;
18728 PyObject * obj0 = 0 ;
18729 PyObject * obj1 = 0 ;
18730 PyObject * obj2 = 0 ;
18731 PyObject * obj3 = 0 ;
18732 char * kwnames[] = {
18733 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
18734 };
18735
18736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18740 }
18741 arg1 = reinterpret_cast< wxDC * >(argp1);
18742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
18743 if (!SWIG_IsOK(res2)) {
18744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18745 }
18746 if (!argp2) {
18747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18748 }
18749 arg2 = reinterpret_cast< wxBitmap * >(argp2);
18750 {
18751 arg3 = &temp3;
18752 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18753 }
18754 if (obj3) {
18755 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18756 if (!SWIG_IsOK(ecode4)) {
18757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
18758 }
18759 arg4 = static_cast< bool >(val4);
18760 }
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 resultobj = SWIG_Py_Void();
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 SWIGINTERN PyObject *_wrap_DC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj = 0;
18776 wxDC *arg1 = (wxDC *) 0 ;
18777 wxString *arg2 = 0 ;
18778 int arg3 ;
18779 int arg4 ;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 bool temp2 = false ;
18783 int val3 ;
18784 int ecode3 = 0 ;
18785 int val4 ;
18786 int ecode4 = 0 ;
18787 PyObject * obj0 = 0 ;
18788 PyObject * obj1 = 0 ;
18789 PyObject * obj2 = 0 ;
18790 PyObject * obj3 = 0 ;
18791 char * kwnames[] = {
18792 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
18793 };
18794
18795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18797 if (!SWIG_IsOK(res1)) {
18798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawText" "', expected argument " "1"" of type '" "wxDC *""'");
18799 }
18800 arg1 = reinterpret_cast< wxDC * >(argp1);
18801 {
18802 arg2 = wxString_in_helper(obj1);
18803 if (arg2 == NULL) SWIG_fail;
18804 temp2 = true;
18805 }
18806 ecode3 = SWIG_AsVal_int(obj2, &val3);
18807 if (!SWIG_IsOK(ecode3)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawText" "', expected argument " "3"" of type '" "int""'");
18809 }
18810 arg3 = static_cast< int >(val3);
18811 ecode4 = SWIG_AsVal_int(obj3, &val4);
18812 if (!SWIG_IsOK(ecode4)) {
18813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawText" "', expected argument " "4"" of type '" "int""'");
18814 }
18815 arg4 = static_cast< int >(val4);
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 resultobj = SWIG_Py_Void();
18823 {
18824 if (temp2)
18825 delete arg2;
18826 }
18827 return resultobj;
18828 fail:
18829 {
18830 if (temp2)
18831 delete arg2;
18832 }
18833 return NULL;
18834 }
18835
18836
18837 SWIGINTERN PyObject *_wrap_DC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18838 PyObject *resultobj = 0;
18839 wxDC *arg1 = (wxDC *) 0 ;
18840 wxString *arg2 = 0 ;
18841 wxPoint *arg3 = 0 ;
18842 void *argp1 = 0 ;
18843 int res1 = 0 ;
18844 bool temp2 = false ;
18845 wxPoint temp3 ;
18846 PyObject * obj0 = 0 ;
18847 PyObject * obj1 = 0 ;
18848 PyObject * obj2 = 0 ;
18849 char * kwnames[] = {
18850 (char *) "self",(char *) "text",(char *) "pt", NULL
18851 };
18852
18853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18855 if (!SWIG_IsOK(res1)) {
18856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18857 }
18858 arg1 = reinterpret_cast< wxDC * >(argp1);
18859 {
18860 arg2 = wxString_in_helper(obj1);
18861 if (arg2 == NULL) SWIG_fail;
18862 temp2 = true;
18863 }
18864 {
18865 arg3 = &temp3;
18866 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18867 }
18868 {
18869 PyThreadState* __tstate = wxPyBeginAllowThreads();
18870 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
18871 wxPyEndAllowThreads(__tstate);
18872 if (PyErr_Occurred()) SWIG_fail;
18873 }
18874 resultobj = SWIG_Py_Void();
18875 {
18876 if (temp2)
18877 delete arg2;
18878 }
18879 return resultobj;
18880 fail:
18881 {
18882 if (temp2)
18883 delete arg2;
18884 }
18885 return NULL;
18886 }
18887
18888
18889 SWIGINTERN PyObject *_wrap_DC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj = 0;
18891 wxDC *arg1 = (wxDC *) 0 ;
18892 wxString *arg2 = 0 ;
18893 int arg3 ;
18894 int arg4 ;
18895 double arg5 ;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 bool temp2 = false ;
18899 int val3 ;
18900 int ecode3 = 0 ;
18901 int val4 ;
18902 int ecode4 = 0 ;
18903 double val5 ;
18904 int ecode5 = 0 ;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 PyObject * obj2 = 0 ;
18908 PyObject * obj3 = 0 ;
18909 PyObject * obj4 = 0 ;
18910 char * kwnames[] = {
18911 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
18912 };
18913
18914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18916 if (!SWIG_IsOK(res1)) {
18917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedText" "', expected argument " "1"" of type '" "wxDC *""'");
18918 }
18919 arg1 = reinterpret_cast< wxDC * >(argp1);
18920 {
18921 arg2 = wxString_in_helper(obj1);
18922 if (arg2 == NULL) SWIG_fail;
18923 temp2 = true;
18924 }
18925 ecode3 = SWIG_AsVal_int(obj2, &val3);
18926 if (!SWIG_IsOK(ecode3)) {
18927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
18928 }
18929 arg3 = static_cast< int >(val3);
18930 ecode4 = SWIG_AsVal_int(obj3, &val4);
18931 if (!SWIG_IsOK(ecode4)) {
18932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
18933 }
18934 arg4 = static_cast< int >(val4);
18935 ecode5 = SWIG_AsVal_double(obj4, &val5);
18936 if (!SWIG_IsOK(ecode5)) {
18937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
18938 }
18939 arg5 = static_cast< double >(val5);
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
18943 wxPyEndAllowThreads(__tstate);
18944 if (PyErr_Occurred()) SWIG_fail;
18945 }
18946 resultobj = SWIG_Py_Void();
18947 {
18948 if (temp2)
18949 delete arg2;
18950 }
18951 return resultobj;
18952 fail:
18953 {
18954 if (temp2)
18955 delete arg2;
18956 }
18957 return NULL;
18958 }
18959
18960
18961 SWIGINTERN PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18962 PyObject *resultobj = 0;
18963 wxDC *arg1 = (wxDC *) 0 ;
18964 wxString *arg2 = 0 ;
18965 wxPoint *arg3 = 0 ;
18966 double arg4 ;
18967 void *argp1 = 0 ;
18968 int res1 = 0 ;
18969 bool temp2 = false ;
18970 wxPoint temp3 ;
18971 double val4 ;
18972 int ecode4 = 0 ;
18973 PyObject * obj0 = 0 ;
18974 PyObject * obj1 = 0 ;
18975 PyObject * obj2 = 0 ;
18976 PyObject * obj3 = 0 ;
18977 char * kwnames[] = {
18978 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
18979 };
18980
18981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18985 }
18986 arg1 = reinterpret_cast< wxDC * >(argp1);
18987 {
18988 arg2 = wxString_in_helper(obj1);
18989 if (arg2 == NULL) SWIG_fail;
18990 temp2 = true;
18991 }
18992 {
18993 arg3 = &temp3;
18994 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18995 }
18996 ecode4 = SWIG_AsVal_double(obj3, &val4);
18997 if (!SWIG_IsOK(ecode4)) {
18998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
18999 }
19000 arg4 = static_cast< double >(val4);
19001 {
19002 PyThreadState* __tstate = wxPyBeginAllowThreads();
19003 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 resultobj = SWIG_Py_Void();
19008 {
19009 if (temp2)
19010 delete arg2;
19011 }
19012 return resultobj;
19013 fail:
19014 {
19015 if (temp2)
19016 delete arg2;
19017 }
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_DC_Blit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19023 PyObject *resultobj = 0;
19024 wxDC *arg1 = (wxDC *) 0 ;
19025 int arg2 ;
19026 int arg3 ;
19027 int arg4 ;
19028 int arg5 ;
19029 wxDC *arg6 = (wxDC *) 0 ;
19030 int arg7 ;
19031 int arg8 ;
19032 int arg9 = (int) wxCOPY ;
19033 bool arg10 = (bool) false ;
19034 int arg11 = (int) -1 ;
19035 int arg12 = (int) -1 ;
19036 bool result;
19037 void *argp1 = 0 ;
19038 int res1 = 0 ;
19039 int val2 ;
19040 int ecode2 = 0 ;
19041 int val3 ;
19042 int ecode3 = 0 ;
19043 int val4 ;
19044 int ecode4 = 0 ;
19045 int val5 ;
19046 int ecode5 = 0 ;
19047 void *argp6 = 0 ;
19048 int res6 = 0 ;
19049 int val7 ;
19050 int ecode7 = 0 ;
19051 int val8 ;
19052 int ecode8 = 0 ;
19053 int val9 ;
19054 int ecode9 = 0 ;
19055 bool val10 ;
19056 int ecode10 = 0 ;
19057 int val11 ;
19058 int ecode11 = 0 ;
19059 int val12 ;
19060 int ecode12 = 0 ;
19061 PyObject * obj0 = 0 ;
19062 PyObject * obj1 = 0 ;
19063 PyObject * obj2 = 0 ;
19064 PyObject * obj3 = 0 ;
19065 PyObject * obj4 = 0 ;
19066 PyObject * obj5 = 0 ;
19067 PyObject * obj6 = 0 ;
19068 PyObject * obj7 = 0 ;
19069 PyObject * obj8 = 0 ;
19070 PyObject * obj9 = 0 ;
19071 PyObject * obj10 = 0 ;
19072 PyObject * obj11 = 0 ;
19073 char * kwnames[] = {
19074 (char *) "self",(char *) "xdest",(char *) "ydest",(char *) "width",(char *) "height",(char *) "source",(char *) "xsrc",(char *) "ysrc",(char *) "rop",(char *) "useMask",(char *) "xsrcMask",(char *) "ysrcMask", NULL
19075 };
19076
19077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO|OOOO:DC_Blit",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
19078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Blit" "', expected argument " "1"" of type '" "wxDC *""'");
19081 }
19082 arg1 = reinterpret_cast< wxDC * >(argp1);
19083 ecode2 = SWIG_AsVal_int(obj1, &val2);
19084 if (!SWIG_IsOK(ecode2)) {
19085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_Blit" "', expected argument " "2"" of type '" "int""'");
19086 }
19087 arg2 = static_cast< int >(val2);
19088 ecode3 = SWIG_AsVal_int(obj2, &val3);
19089 if (!SWIG_IsOK(ecode3)) {
19090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_Blit" "', expected argument " "3"" of type '" "int""'");
19091 }
19092 arg3 = static_cast< int >(val3);
19093 ecode4 = SWIG_AsVal_int(obj3, &val4);
19094 if (!SWIG_IsOK(ecode4)) {
19095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_Blit" "', expected argument " "4"" of type '" "int""'");
19096 }
19097 arg4 = static_cast< int >(val4);
19098 ecode5 = SWIG_AsVal_int(obj4, &val5);
19099 if (!SWIG_IsOK(ecode5)) {
19100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_Blit" "', expected argument " "5"" of type '" "int""'");
19101 }
19102 arg5 = static_cast< int >(val5);
19103 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );
19104 if (!SWIG_IsOK(res6)) {
19105 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_Blit" "', expected argument " "6"" of type '" "wxDC *""'");
19106 }
19107 arg6 = reinterpret_cast< wxDC * >(argp6);
19108 ecode7 = SWIG_AsVal_int(obj6, &val7);
19109 if (!SWIG_IsOK(ecode7)) {
19110 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_Blit" "', expected argument " "7"" of type '" "int""'");
19111 }
19112 arg7 = static_cast< int >(val7);
19113 ecode8 = SWIG_AsVal_int(obj7, &val8);
19114 if (!SWIG_IsOK(ecode8)) {
19115 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DC_Blit" "', expected argument " "8"" of type '" "int""'");
19116 }
19117 arg8 = static_cast< int >(val8);
19118 if (obj8) {
19119 ecode9 = SWIG_AsVal_int(obj8, &val9);
19120 if (!SWIG_IsOK(ecode9)) {
19121 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DC_Blit" "', expected argument " "9"" of type '" "int""'");
19122 }
19123 arg9 = static_cast< int >(val9);
19124 }
19125 if (obj9) {
19126 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19127 if (!SWIG_IsOK(ecode10)) {
19128 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DC_Blit" "', expected argument " "10"" of type '" "bool""'");
19129 }
19130 arg10 = static_cast< bool >(val10);
19131 }
19132 if (obj10) {
19133 ecode11 = SWIG_AsVal_int(obj10, &val11);
19134 if (!SWIG_IsOK(ecode11)) {
19135 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DC_Blit" "', expected argument " "11"" of type '" "int""'");
19136 }
19137 arg11 = static_cast< int >(val11);
19138 }
19139 if (obj11) {
19140 ecode12 = SWIG_AsVal_int(obj11, &val12);
19141 if (!SWIG_IsOK(ecode12)) {
19142 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DC_Blit" "', expected argument " "12"" of type '" "int""'");
19143 }
19144 arg12 = static_cast< int >(val12);
19145 }
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 {
19153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19154 }
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_DC_BlitPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxDC *arg1 = (wxDC *) 0 ;
19164 wxPoint *arg2 = 0 ;
19165 wxSize *arg3 = 0 ;
19166 wxDC *arg4 = (wxDC *) 0 ;
19167 wxPoint *arg5 = 0 ;
19168 int arg6 = (int) wxCOPY ;
19169 bool arg7 = (bool) false ;
19170 wxPoint const &arg8_defvalue = wxDefaultPosition ;
19171 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
19172 bool result;
19173 void *argp1 = 0 ;
19174 int res1 = 0 ;
19175 wxPoint temp2 ;
19176 wxSize temp3 ;
19177 void *argp4 = 0 ;
19178 int res4 = 0 ;
19179 wxPoint temp5 ;
19180 int val6 ;
19181 int ecode6 = 0 ;
19182 bool val7 ;
19183 int ecode7 = 0 ;
19184 wxPoint temp8 ;
19185 PyObject * obj0 = 0 ;
19186 PyObject * obj1 = 0 ;
19187 PyObject * obj2 = 0 ;
19188 PyObject * obj3 = 0 ;
19189 PyObject * obj4 = 0 ;
19190 PyObject * obj5 = 0 ;
19191 PyObject * obj6 = 0 ;
19192 PyObject * obj7 = 0 ;
19193 char * kwnames[] = {
19194 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
19195 };
19196
19197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
19198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19199 if (!SWIG_IsOK(res1)) {
19200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_BlitPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19201 }
19202 arg1 = reinterpret_cast< wxDC * >(argp1);
19203 {
19204 arg2 = &temp2;
19205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19206 }
19207 {
19208 arg3 = &temp3;
19209 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19210 }
19211 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxDC, 0 | 0 );
19212 if (!SWIG_IsOK(res4)) {
19213 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DC_BlitPointSize" "', expected argument " "4"" of type '" "wxDC *""'");
19214 }
19215 arg4 = reinterpret_cast< wxDC * >(argp4);
19216 {
19217 arg5 = &temp5;
19218 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
19219 }
19220 if (obj5) {
19221 ecode6 = SWIG_AsVal_int(obj5, &val6);
19222 if (!SWIG_IsOK(ecode6)) {
19223 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_BlitPointSize" "', expected argument " "6"" of type '" "int""'");
19224 }
19225 arg6 = static_cast< int >(val6);
19226 }
19227 if (obj6) {
19228 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19229 if (!SWIG_IsOK(ecode7)) {
19230 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_BlitPointSize" "', expected argument " "7"" of type '" "bool""'");
19231 }
19232 arg7 = static_cast< bool >(val7);
19233 }
19234 if (obj7) {
19235 {
19236 arg8 = &temp8;
19237 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
19238 }
19239 }
19240 {
19241 PyThreadState* __tstate = wxPyBeginAllowThreads();
19242 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 {
19247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_DC_SetClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj = 0;
19257 wxDC *arg1 = (wxDC *) 0 ;
19258 int arg2 ;
19259 int arg3 ;
19260 int arg4 ;
19261 int arg5 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 int val2 ;
19265 int ecode2 = 0 ;
19266 int val3 ;
19267 int ecode3 = 0 ;
19268 int val4 ;
19269 int ecode4 = 0 ;
19270 int val5 ;
19271 int ecode5 = 0 ;
19272 PyObject * obj0 = 0 ;
19273 PyObject * obj1 = 0 ;
19274 PyObject * obj2 = 0 ;
19275 PyObject * obj3 = 0 ;
19276 PyObject * obj4 = 0 ;
19277 char * kwnames[] = {
19278 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19279 };
19280
19281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19283 if (!SWIG_IsOK(res1)) {
19284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
19285 }
19286 arg1 = reinterpret_cast< wxDC * >(argp1);
19287 ecode2 = SWIG_AsVal_int(obj1, &val2);
19288 if (!SWIG_IsOK(ecode2)) {
19289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetClippingRegion" "', expected argument " "2"" of type '" "int""'");
19290 }
19291 arg2 = static_cast< int >(val2);
19292 ecode3 = SWIG_AsVal_int(obj2, &val3);
19293 if (!SWIG_IsOK(ecode3)) {
19294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetClippingRegion" "', expected argument " "3"" of type '" "int""'");
19295 }
19296 arg3 = static_cast< int >(val3);
19297 ecode4 = SWIG_AsVal_int(obj3, &val4);
19298 if (!SWIG_IsOK(ecode4)) {
19299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_SetClippingRegion" "', expected argument " "4"" of type '" "int""'");
19300 }
19301 arg4 = static_cast< int >(val4);
19302 ecode5 = SWIG_AsVal_int(obj4, &val5);
19303 if (!SWIG_IsOK(ecode5)) {
19304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_SetClippingRegion" "', expected argument " "5"" of type '" "int""'");
19305 }
19306 arg5 = static_cast< int >(val5);
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_Py_Void();
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj = 0;
19322 wxDC *arg1 = (wxDC *) 0 ;
19323 wxPoint *arg2 = 0 ;
19324 wxSize *arg3 = 0 ;
19325 void *argp1 = 0 ;
19326 int res1 = 0 ;
19327 wxPoint temp2 ;
19328 wxSize temp3 ;
19329 PyObject * obj0 = 0 ;
19330 PyObject * obj1 = 0 ;
19331 PyObject * obj2 = 0 ;
19332 char * kwnames[] = {
19333 (char *) "self",(char *) "pt",(char *) "sz", NULL
19334 };
19335
19336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19338 if (!SWIG_IsOK(res1)) {
19339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19340 }
19341 arg1 = reinterpret_cast< wxDC * >(argp1);
19342 {
19343 arg2 = &temp2;
19344 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19345 }
19346 {
19347 arg3 = &temp3;
19348 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19349 }
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = SWIG_Py_Void();
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19364 PyObject *resultobj = 0;
19365 wxDC *arg1 = (wxDC *) 0 ;
19366 wxRegion *arg2 = 0 ;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 void *argp2 = 0 ;
19370 int res2 = 0 ;
19371 PyObject * obj0 = 0 ;
19372 PyObject * obj1 = 0 ;
19373 char * kwnames[] = {
19374 (char *) "self",(char *) "region", NULL
19375 };
19376
19377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) SWIG_fail;
19378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19379 if (!SWIG_IsOK(res1)) {
19380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "1"" of type '" "wxDC *""'");
19381 }
19382 arg1 = reinterpret_cast< wxDC * >(argp1);
19383 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
19384 if (!SWIG_IsOK(res2)) {
19385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
19386 }
19387 if (!argp2) {
19388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
19389 }
19390 arg2 = reinterpret_cast< wxRegion * >(argp2);
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 resultobj = SWIG_Py_Void();
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 SWIGINTERN PyObject *_wrap_DC_SetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19405 PyObject *resultobj = 0;
19406 wxDC *arg1 = (wxDC *) 0 ;
19407 wxRect *arg2 = 0 ;
19408 void *argp1 = 0 ;
19409 int res1 = 0 ;
19410 wxRect temp2 ;
19411 PyObject * obj0 = 0 ;
19412 PyObject * obj1 = 0 ;
19413 char * kwnames[] = {
19414 (char *) "self",(char *) "rect", NULL
19415 };
19416
19417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) SWIG_fail;
19418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
19421 }
19422 arg1 = reinterpret_cast< wxDC * >(argp1);
19423 {
19424 arg2 = &temp2;
19425 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19426 }
19427 {
19428 PyThreadState* __tstate = wxPyBeginAllowThreads();
19429 (arg1)->SetClippingRegion((wxRect const &)*arg2);
19430 wxPyEndAllowThreads(__tstate);
19431 if (PyErr_Occurred()) SWIG_fail;
19432 }
19433 resultobj = SWIG_Py_Void();
19434 return resultobj;
19435 fail:
19436 return NULL;
19437 }
19438
19439
19440 SWIGINTERN PyObject *_wrap_DC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19441 PyObject *resultobj = 0;
19442 wxDC *arg1 = (wxDC *) 0 ;
19443 int arg2 ;
19444 wxPoint *arg3 = (wxPoint *) 0 ;
19445 int arg4 = (int) 0 ;
19446 int arg5 = (int) 0 ;
19447 void *argp1 = 0 ;
19448 int res1 = 0 ;
19449 int val4 ;
19450 int ecode4 = 0 ;
19451 int val5 ;
19452 int ecode5 = 0 ;
19453 PyObject * obj0 = 0 ;
19454 PyObject * obj1 = 0 ;
19455 PyObject * obj2 = 0 ;
19456 PyObject * obj3 = 0 ;
19457 char * kwnames[] = {
19458 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
19459 };
19460
19461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19463 if (!SWIG_IsOK(res1)) {
19464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLines" "', expected argument " "1"" of type '" "wxDC *""'");
19465 }
19466 arg1 = reinterpret_cast< wxDC * >(argp1);
19467 {
19468 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19469 if (arg3 == NULL) SWIG_fail;
19470 }
19471 if (obj2) {
19472 ecode4 = SWIG_AsVal_int(obj2, &val4);
19473 if (!SWIG_IsOK(ecode4)) {
19474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLines" "', expected argument " "4"" of type '" "int""'");
19475 }
19476 arg4 = static_cast< int >(val4);
19477 }
19478 if (obj3) {
19479 ecode5 = SWIG_AsVal_int(obj3, &val5);
19480 if (!SWIG_IsOK(ecode5)) {
19481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLines" "', expected argument " "5"" of type '" "int""'");
19482 }
19483 arg5 = static_cast< int >(val5);
19484 }
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
19488 wxPyEndAllowThreads(__tstate);
19489 if (PyErr_Occurred()) SWIG_fail;
19490 }
19491 resultobj = SWIG_Py_Void();
19492 {
19493 if (arg3) delete [] arg3;
19494 }
19495 return resultobj;
19496 fail:
19497 {
19498 if (arg3) delete [] arg3;
19499 }
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *_wrap_DC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj = 0;
19506 wxDC *arg1 = (wxDC *) 0 ;
19507 int arg2 ;
19508 wxPoint *arg3 = (wxPoint *) 0 ;
19509 int arg4 = (int) 0 ;
19510 int arg5 = (int) 0 ;
19511 int arg6 = (int) wxODDEVEN_RULE ;
19512 void *argp1 = 0 ;
19513 int res1 = 0 ;
19514 int val4 ;
19515 int ecode4 = 0 ;
19516 int val5 ;
19517 int ecode5 = 0 ;
19518 int val6 ;
19519 int ecode6 = 0 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 PyObject * obj2 = 0 ;
19523 PyObject * obj3 = 0 ;
19524 PyObject * obj4 = 0 ;
19525 char * kwnames[] = {
19526 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
19527 };
19528
19529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19531 if (!SWIG_IsOK(res1)) {
19532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPolygon" "', expected argument " "1"" of type '" "wxDC *""'");
19533 }
19534 arg1 = reinterpret_cast< wxDC * >(argp1);
19535 {
19536 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19537 if (arg3 == NULL) SWIG_fail;
19538 }
19539 if (obj2) {
19540 ecode4 = SWIG_AsVal_int(obj2, &val4);
19541 if (!SWIG_IsOK(ecode4)) {
19542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
19543 }
19544 arg4 = static_cast< int >(val4);
19545 }
19546 if (obj3) {
19547 ecode5 = SWIG_AsVal_int(obj3, &val5);
19548 if (!SWIG_IsOK(ecode5)) {
19549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
19550 }
19551 arg5 = static_cast< int >(val5);
19552 }
19553 if (obj4) {
19554 ecode6 = SWIG_AsVal_int(obj4, &val6);
19555 if (!SWIG_IsOK(ecode6)) {
19556 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
19557 }
19558 arg6 = static_cast< int >(val6);
19559 }
19560 {
19561 PyThreadState* __tstate = wxPyBeginAllowThreads();
19562 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_Py_Void();
19567 {
19568 if (arg3) delete [] arg3;
19569 }
19570 return resultobj;
19571 fail:
19572 {
19573 if (arg3) delete [] arg3;
19574 }
19575 return NULL;
19576 }
19577
19578
19579 SWIGINTERN PyObject *_wrap_DC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj = 0;
19581 wxDC *arg1 = (wxDC *) 0 ;
19582 wxString *arg2 = 0 ;
19583 wxRect *arg3 = 0 ;
19584 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
19585 int arg5 = (int) -1 ;
19586 void *argp1 = 0 ;
19587 int res1 = 0 ;
19588 bool temp2 = false ;
19589 wxRect temp3 ;
19590 int val4 ;
19591 int ecode4 = 0 ;
19592 int val5 ;
19593 int ecode5 = 0 ;
19594 PyObject * obj0 = 0 ;
19595 PyObject * obj1 = 0 ;
19596 PyObject * obj2 = 0 ;
19597 PyObject * obj3 = 0 ;
19598 PyObject * obj4 = 0 ;
19599 char * kwnames[] = {
19600 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
19601 };
19602
19603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19605 if (!SWIG_IsOK(res1)) {
19606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLabel" "', expected argument " "1"" of type '" "wxDC *""'");
19607 }
19608 arg1 = reinterpret_cast< wxDC * >(argp1);
19609 {
19610 arg2 = wxString_in_helper(obj1);
19611 if (arg2 == NULL) SWIG_fail;
19612 temp2 = true;
19613 }
19614 {
19615 arg3 = &temp3;
19616 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
19617 }
19618 if (obj3) {
19619 ecode4 = SWIG_AsVal_int(obj3, &val4);
19620 if (!SWIG_IsOK(ecode4)) {
19621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
19622 }
19623 arg4 = static_cast< int >(val4);
19624 }
19625 if (obj4) {
19626 ecode5 = SWIG_AsVal_int(obj4, &val5);
19627 if (!SWIG_IsOK(ecode5)) {
19628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
19629 }
19630 arg5 = static_cast< int >(val5);
19631 }
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
19635 wxPyEndAllowThreads(__tstate);
19636 if (PyErr_Occurred()) SWIG_fail;
19637 }
19638 resultobj = SWIG_Py_Void();
19639 {
19640 if (temp2)
19641 delete arg2;
19642 }
19643 return resultobj;
19644 fail:
19645 {
19646 if (temp2)
19647 delete arg2;
19648 }
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_DC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = 0;
19655 wxDC *arg1 = (wxDC *) 0 ;
19656 wxString *arg2 = 0 ;
19657 wxBitmap *arg3 = 0 ;
19658 wxRect *arg4 = 0 ;
19659 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
19660 int arg6 = (int) -1 ;
19661 wxRect result;
19662 void *argp1 = 0 ;
19663 int res1 = 0 ;
19664 bool temp2 = false ;
19665 void *argp3 = 0 ;
19666 int res3 = 0 ;
19667 wxRect temp4 ;
19668 int val5 ;
19669 int ecode5 = 0 ;
19670 int val6 ;
19671 int ecode6 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 PyObject * obj1 = 0 ;
19674 PyObject * obj2 = 0 ;
19675 PyObject * obj3 = 0 ;
19676 PyObject * obj4 = 0 ;
19677 PyObject * obj5 = 0 ;
19678 char * kwnames[] = {
19679 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
19680 };
19681
19682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19684 if (!SWIG_IsOK(res1)) {
19685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawImageLabel" "', expected argument " "1"" of type '" "wxDC *""'");
19686 }
19687 arg1 = reinterpret_cast< wxDC * >(argp1);
19688 {
19689 arg2 = wxString_in_helper(obj1);
19690 if (arg2 == NULL) SWIG_fail;
19691 temp2 = true;
19692 }
19693 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
19694 if (!SWIG_IsOK(res3)) {
19695 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
19696 }
19697 if (!argp3) {
19698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
19699 }
19700 arg3 = reinterpret_cast< wxBitmap * >(argp3);
19701 {
19702 arg4 = &temp4;
19703 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
19704 }
19705 if (obj4) {
19706 ecode5 = SWIG_AsVal_int(obj4, &val5);
19707 if (!SWIG_IsOK(ecode5)) {
19708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
19709 }
19710 arg5 = static_cast< int >(val5);
19711 }
19712 if (obj5) {
19713 ecode6 = SWIG_AsVal_int(obj5, &val6);
19714 if (!SWIG_IsOK(ecode6)) {
19715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
19716 }
19717 arg6 = static_cast< int >(val6);
19718 }
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
19726 {
19727 if (temp2)
19728 delete arg2;
19729 }
19730 return resultobj;
19731 fail:
19732 {
19733 if (temp2)
19734 delete arg2;
19735 }
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_DC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19741 PyObject *resultobj = 0;
19742 wxDC *arg1 = (wxDC *) 0 ;
19743 int arg2 ;
19744 wxPoint *arg3 = (wxPoint *) 0 ;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 PyObject * obj0 = 0 ;
19748 PyObject * obj1 = 0 ;
19749 char * kwnames[] = {
19750 (char *) "self",(char *) "points", NULL
19751 };
19752
19753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
19754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19755 if (!SWIG_IsOK(res1)) {
19756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawSpline" "', expected argument " "1"" of type '" "wxDC *""'");
19757 }
19758 arg1 = reinterpret_cast< wxDC * >(argp1);
19759 {
19760 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19761 if (arg3 == NULL) SWIG_fail;
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 (arg1)->DrawSpline(arg2,arg3);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = SWIG_Py_Void();
19770 {
19771 if (arg3) delete [] arg3;
19772 }
19773 return resultobj;
19774 fail:
19775 {
19776 if (arg3) delete [] arg3;
19777 }
19778 return NULL;
19779 }
19780
19781
19782 SWIGINTERN PyObject *_wrap_DC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19783 PyObject *resultobj = 0;
19784 wxDC *arg1 = (wxDC *) 0 ;
19785 void *argp1 = 0 ;
19786 int res1 = 0 ;
19787 PyObject *swig_obj[1] ;
19788
19789 if (!args) SWIG_fail;
19790 swig_obj[0] = args;
19791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19792 if (!SWIG_IsOK(res1)) {
19793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Clear" "', expected argument " "1"" of type '" "wxDC *""'");
19794 }
19795 arg1 = reinterpret_cast< wxDC * >(argp1);
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 (arg1)->Clear();
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 resultobj = SWIG_Py_Void();
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 SWIGINTERN PyObject *_wrap_DC_StartDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19810 PyObject *resultobj = 0;
19811 wxDC *arg1 = (wxDC *) 0 ;
19812 wxString *arg2 = 0 ;
19813 bool result;
19814 void *argp1 = 0 ;
19815 int res1 = 0 ;
19816 bool temp2 = false ;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 char * kwnames[] = {
19820 (char *) "self",(char *) "message", NULL
19821 };
19822
19823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) SWIG_fail;
19824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19825 if (!SWIG_IsOK(res1)) {
19826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartDoc" "', expected argument " "1"" of type '" "wxDC *""'");
19827 }
19828 arg1 = reinterpret_cast< wxDC * >(argp1);
19829 {
19830 arg2 = wxString_in_helper(obj1);
19831 if (arg2 == NULL) SWIG_fail;
19832 temp2 = true;
19833 }
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19842 }
19843 {
19844 if (temp2)
19845 delete arg2;
19846 }
19847 return resultobj;
19848 fail:
19849 {
19850 if (temp2)
19851 delete arg2;
19852 }
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_DC_EndDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19858 PyObject *resultobj = 0;
19859 wxDC *arg1 = (wxDC *) 0 ;
19860 void *argp1 = 0 ;
19861 int res1 = 0 ;
19862 PyObject *swig_obj[1] ;
19863
19864 if (!args) SWIG_fail;
19865 swig_obj[0] = args;
19866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndDoc" "', expected argument " "1"" of type '" "wxDC *""'");
19869 }
19870 arg1 = reinterpret_cast< wxDC * >(argp1);
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 (arg1)->EndDoc();
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 resultobj = SWIG_Py_Void();
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_DC_StartPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 PyObject *resultobj = 0;
19886 wxDC *arg1 = (wxDC *) 0 ;
19887 void *argp1 = 0 ;
19888 int res1 = 0 ;
19889 PyObject *swig_obj[1] ;
19890
19891 if (!args) SWIG_fail;
19892 swig_obj[0] = args;
19893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19894 if (!SWIG_IsOK(res1)) {
19895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartPage" "', expected argument " "1"" of type '" "wxDC *""'");
19896 }
19897 arg1 = reinterpret_cast< wxDC * >(argp1);
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 (arg1)->StartPage();
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 resultobj = SWIG_Py_Void();
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 SWIGINTERN PyObject *_wrap_DC_EndPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19912 PyObject *resultobj = 0;
19913 wxDC *arg1 = (wxDC *) 0 ;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 PyObject *swig_obj[1] ;
19917
19918 if (!args) SWIG_fail;
19919 swig_obj[0] = args;
19920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19921 if (!SWIG_IsOK(res1)) {
19922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndPage" "', expected argument " "1"" of type '" "wxDC *""'");
19923 }
19924 arg1 = reinterpret_cast< wxDC * >(argp1);
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 (arg1)->EndPage();
19928 wxPyEndAllowThreads(__tstate);
19929 if (PyErr_Occurred()) SWIG_fail;
19930 }
19931 resultobj = SWIG_Py_Void();
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 SWIGINTERN PyObject *_wrap_DC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj = 0;
19940 wxDC *arg1 = (wxDC *) 0 ;
19941 wxFont *arg2 = 0 ;
19942 void *argp1 = 0 ;
19943 int res1 = 0 ;
19944 void *argp2 = 0 ;
19945 int res2 = 0 ;
19946 PyObject * obj0 = 0 ;
19947 PyObject * obj1 = 0 ;
19948 char * kwnames[] = {
19949 (char *) "self",(char *) "font", NULL
19950 };
19951
19952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
19953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19954 if (!SWIG_IsOK(res1)) {
19955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetFont" "', expected argument " "1"" of type '" "wxDC *""'");
19956 }
19957 arg1 = reinterpret_cast< wxDC * >(argp1);
19958 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
19959 if (!SWIG_IsOK(res2)) {
19960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
19961 }
19962 if (!argp2) {
19963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
19964 }
19965 arg2 = reinterpret_cast< wxFont * >(argp2);
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 (arg1)->SetFont((wxFont const &)*arg2);
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_Py_Void();
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 SWIGINTERN PyObject *_wrap_DC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj = 0;
19981 wxDC *arg1 = (wxDC *) 0 ;
19982 wxPen *arg2 = 0 ;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 void *argp2 = 0 ;
19986 int res2 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char * kwnames[] = {
19990 (char *) "self",(char *) "pen", NULL
19991 };
19992
19993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPen" "', expected argument " "1"" of type '" "wxDC *""'");
19997 }
19998 arg1 = reinterpret_cast< wxDC * >(argp1);
19999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
20000 if (!SWIG_IsOK(res2)) {
20001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20002 }
20003 if (!argp2) {
20004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20005 }
20006 arg2 = reinterpret_cast< wxPen * >(argp2);
20007 {
20008 PyThreadState* __tstate = wxPyBeginAllowThreads();
20009 (arg1)->SetPen((wxPen const &)*arg2);
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 resultobj = SWIG_Py_Void();
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 SWIGINTERN PyObject *_wrap_DC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj = 0;
20022 wxDC *arg1 = (wxDC *) 0 ;
20023 wxBrush *arg2 = 0 ;
20024 void *argp1 = 0 ;
20025 int res1 = 0 ;
20026 void *argp2 = 0 ;
20027 int res2 = 0 ;
20028 PyObject * obj0 = 0 ;
20029 PyObject * obj1 = 0 ;
20030 char * kwnames[] = {
20031 (char *) "self",(char *) "brush", NULL
20032 };
20033
20034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
20035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20036 if (!SWIG_IsOK(res1)) {
20037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBrush" "', expected argument " "1"" of type '" "wxDC *""'");
20038 }
20039 arg1 = reinterpret_cast< wxDC * >(argp1);
20040 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20041 if (!SWIG_IsOK(res2)) {
20042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20043 }
20044 if (!argp2) {
20045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20046 }
20047 arg2 = reinterpret_cast< wxBrush * >(argp2);
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 (arg1)->SetBrush((wxBrush const &)*arg2);
20051 wxPyEndAllowThreads(__tstate);
20052 if (PyErr_Occurred()) SWIG_fail;
20053 }
20054 resultobj = SWIG_Py_Void();
20055 return resultobj;
20056 fail:
20057 return NULL;
20058 }
20059
20060
20061 SWIGINTERN PyObject *_wrap_DC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20062 PyObject *resultobj = 0;
20063 wxDC *arg1 = (wxDC *) 0 ;
20064 wxBrush *arg2 = 0 ;
20065 void *argp1 = 0 ;
20066 int res1 = 0 ;
20067 void *argp2 = 0 ;
20068 int res2 = 0 ;
20069 PyObject * obj0 = 0 ;
20070 PyObject * obj1 = 0 ;
20071 char * kwnames[] = {
20072 (char *) "self",(char *) "brush", NULL
20073 };
20074
20075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
20076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20077 if (!SWIG_IsOK(res1)) {
20078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackground" "', expected argument " "1"" of type '" "wxDC *""'");
20079 }
20080 arg1 = reinterpret_cast< wxDC * >(argp1);
20081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20082 if (!SWIG_IsOK(res2)) {
20083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20084 }
20085 if (!argp2) {
20086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20087 }
20088 arg2 = reinterpret_cast< wxBrush * >(argp2);
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 (arg1)->SetBackground((wxBrush const &)*arg2);
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 resultobj = SWIG_Py_Void();
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_DC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj = 0;
20104 wxDC *arg1 = (wxDC *) 0 ;
20105 int arg2 ;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 int val2 ;
20109 int ecode2 = 0 ;
20110 PyObject * obj0 = 0 ;
20111 PyObject * obj1 = 0 ;
20112 char * kwnames[] = {
20113 (char *) "self",(char *) "mode", NULL
20114 };
20115
20116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
20117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20118 if (!SWIG_IsOK(res1)) {
20119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxDC *""'");
20120 }
20121 arg1 = reinterpret_cast< wxDC * >(argp1);
20122 ecode2 = SWIG_AsVal_int(obj1, &val2);
20123 if (!SWIG_IsOK(ecode2)) {
20124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
20125 }
20126 arg2 = static_cast< int >(val2);
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 (arg1)->SetBackgroundMode(arg2);
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 resultobj = SWIG_Py_Void();
20134 return resultobj;
20135 fail:
20136 return NULL;
20137 }
20138
20139
20140 SWIGINTERN PyObject *_wrap_DC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20141 PyObject *resultobj = 0;
20142 wxDC *arg1 = (wxDC *) 0 ;
20143 wxPalette *arg2 = 0 ;
20144 void *argp1 = 0 ;
20145 int res1 = 0 ;
20146 void *argp2 = 0 ;
20147 int res2 = 0 ;
20148 PyObject * obj0 = 0 ;
20149 PyObject * obj1 = 0 ;
20150 char * kwnames[] = {
20151 (char *) "self",(char *) "palette", NULL
20152 };
20153
20154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
20155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20156 if (!SWIG_IsOK(res1)) {
20157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPalette" "', expected argument " "1"" of type '" "wxDC *""'");
20158 }
20159 arg1 = reinterpret_cast< wxDC * >(argp1);
20160 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
20161 if (!SWIG_IsOK(res2)) {
20162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20163 }
20164 if (!argp2) {
20165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20166 }
20167 arg2 = reinterpret_cast< wxPalette * >(argp2);
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 (arg1)->SetPalette((wxPalette const &)*arg2);
20171 wxPyEndAllowThreads(__tstate);
20172 if (PyErr_Occurred()) SWIG_fail;
20173 }
20174 resultobj = SWIG_Py_Void();
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 SWIGINTERN PyObject *_wrap_DC_DestroyClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 PyObject *resultobj = 0;
20183 wxDC *arg1 = (wxDC *) 0 ;
20184 void *argp1 = 0 ;
20185 int res1 = 0 ;
20186 PyObject *swig_obj[1] ;
20187
20188 if (!args) SWIG_fail;
20189 swig_obj[0] = args;
20190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20191 if (!SWIG_IsOK(res1)) {
20192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DestroyClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
20193 }
20194 arg1 = reinterpret_cast< wxDC * >(argp1);
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 (arg1)->DestroyClippingRegion();
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 resultobj = SWIG_Py_Void();
20202 return resultobj;
20203 fail:
20204 return NULL;
20205 }
20206
20207
20208 SWIGINTERN PyObject *_wrap_DC_GetClippingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20209 PyObject *resultobj = 0;
20210 wxDC *arg1 = (wxDC *) 0 ;
20211 int *arg2 = (int *) 0 ;
20212 int *arg3 = (int *) 0 ;
20213 int *arg4 = (int *) 0 ;
20214 int *arg5 = (int *) 0 ;
20215 void *argp1 = 0 ;
20216 int res1 = 0 ;
20217 int temp2 ;
20218 int res2 = SWIG_TMPOBJ ;
20219 int temp3 ;
20220 int res3 = SWIG_TMPOBJ ;
20221 int temp4 ;
20222 int res4 = SWIG_TMPOBJ ;
20223 int temp5 ;
20224 int res5 = SWIG_TMPOBJ ;
20225 PyObject *swig_obj[1] ;
20226
20227 arg2 = &temp2;
20228 arg3 = &temp3;
20229 arg4 = &temp4;
20230 arg5 = &temp5;
20231 if (!args) SWIG_fail;
20232 swig_obj[0] = args;
20233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20234 if (!SWIG_IsOK(res1)) {
20235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingBox" "', expected argument " "1"" of type '" "wxDC const *""'");
20236 }
20237 arg1 = reinterpret_cast< wxDC * >(argp1);
20238 {
20239 PyThreadState* __tstate = wxPyBeginAllowThreads();
20240 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
20241 wxPyEndAllowThreads(__tstate);
20242 if (PyErr_Occurred()) SWIG_fail;
20243 }
20244 resultobj = SWIG_Py_Void();
20245 if (SWIG_IsTmpObj(res2)) {
20246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20247 } else {
20248 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20250 }
20251 if (SWIG_IsTmpObj(res3)) {
20252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20253 } else {
20254 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20256 }
20257 if (SWIG_IsTmpObj(res4)) {
20258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20259 } else {
20260 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20261 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20262 }
20263 if (SWIG_IsTmpObj(res5)) {
20264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20265 } else {
20266 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20268 }
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 SWIGINTERN PyObject *_wrap_DC_GetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20276 PyObject *resultobj = 0;
20277 wxDC *arg1 = (wxDC *) 0 ;
20278 wxRect result;
20279 void *argp1 = 0 ;
20280 int res1 = 0 ;
20281 PyObject *swig_obj[1] ;
20282
20283 if (!args) SWIG_fail;
20284 swig_obj[0] = args;
20285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20286 if (!SWIG_IsOK(res1)) {
20287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
20288 }
20289 arg1 = reinterpret_cast< wxDC * >(argp1);
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 result = wxDC_GetClippingRect(arg1);
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_DC_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxDC *arg1 = (wxDC *) 0 ;
20306 int result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 PyObject *swig_obj[1] ;
20310
20311 if (!args) SWIG_fail;
20312 swig_obj[0] = args;
20313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharHeight" "', expected argument " "1"" of type '" "wxDC const *""'");
20316 }
20317 arg1 = reinterpret_cast< wxDC * >(argp1);
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = (int)((wxDC const *)arg1)->GetCharHeight();
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 resultobj = SWIG_From_int(static_cast< int >(result));
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *_wrap_DC_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20332 PyObject *resultobj = 0;
20333 wxDC *arg1 = (wxDC *) 0 ;
20334 int result;
20335 void *argp1 = 0 ;
20336 int res1 = 0 ;
20337 PyObject *swig_obj[1] ;
20338
20339 if (!args) SWIG_fail;
20340 swig_obj[0] = args;
20341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharWidth" "', expected argument " "1"" of type '" "wxDC const *""'");
20344 }
20345 arg1 = reinterpret_cast< wxDC * >(argp1);
20346 {
20347 PyThreadState* __tstate = wxPyBeginAllowThreads();
20348 result = (int)((wxDC const *)arg1)->GetCharWidth();
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 resultobj = SWIG_From_int(static_cast< int >(result));
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_DC_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj = 0;
20361 wxDC *arg1 = (wxDC *) 0 ;
20362 wxString *arg2 = 0 ;
20363 int *arg3 = (int *) 0 ;
20364 int *arg4 = (int *) 0 ;
20365 void *argp1 = 0 ;
20366 int res1 = 0 ;
20367 bool temp2 = false ;
20368 int temp3 ;
20369 int res3 = SWIG_TMPOBJ ;
20370 int temp4 ;
20371 int res4 = SWIG_TMPOBJ ;
20372 PyObject * obj0 = 0 ;
20373 PyObject * obj1 = 0 ;
20374 char * kwnames[] = {
20375 (char *) "self",(char *) "string", NULL
20376 };
20377
20378 arg3 = &temp3;
20379 arg4 = &temp4;
20380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
20381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20382 if (!SWIG_IsOK(res1)) {
20383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20384 }
20385 arg1 = reinterpret_cast< wxDC * >(argp1);
20386 {
20387 arg2 = wxString_in_helper(obj1);
20388 if (arg2 == NULL) SWIG_fail;
20389 temp2 = true;
20390 }
20391 {
20392 PyThreadState* __tstate = wxPyBeginAllowThreads();
20393 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 resultobj = SWIG_Py_Void();
20398 if (SWIG_IsTmpObj(res3)) {
20399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20400 } else {
20401 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20403 }
20404 if (SWIG_IsTmpObj(res4)) {
20405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20406 } else {
20407 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20409 }
20410 {
20411 if (temp2)
20412 delete arg2;
20413 }
20414 return resultobj;
20415 fail:
20416 {
20417 if (temp2)
20418 delete arg2;
20419 }
20420 return NULL;
20421 }
20422
20423
20424 SWIGINTERN PyObject *_wrap_DC_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj = 0;
20426 wxDC *arg1 = (wxDC *) 0 ;
20427 wxString *arg2 = 0 ;
20428 int *arg3 = (int *) 0 ;
20429 int *arg4 = (int *) 0 ;
20430 int *arg5 = (int *) 0 ;
20431 int *arg6 = (int *) 0 ;
20432 wxFont *arg7 = (wxFont *) NULL ;
20433 void *argp1 = 0 ;
20434 int res1 = 0 ;
20435 bool temp2 = false ;
20436 int temp3 ;
20437 int res3 = SWIG_TMPOBJ ;
20438 int temp4 ;
20439 int res4 = SWIG_TMPOBJ ;
20440 int temp5 ;
20441 int res5 = SWIG_TMPOBJ ;
20442 int temp6 ;
20443 int res6 = SWIG_TMPOBJ ;
20444 void *argp7 = 0 ;
20445 int res7 = 0 ;
20446 PyObject * obj0 = 0 ;
20447 PyObject * obj1 = 0 ;
20448 PyObject * obj2 = 0 ;
20449 char * kwnames[] = {
20450 (char *) "self",(char *) "string",(char *) "font", NULL
20451 };
20452
20453 arg3 = &temp3;
20454 arg4 = &temp4;
20455 arg5 = &temp5;
20456 arg6 = &temp6;
20457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20459 if (!SWIG_IsOK(res1)) {
20460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFullTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20461 }
20462 arg1 = reinterpret_cast< wxDC * >(argp1);
20463 {
20464 arg2 = wxString_in_helper(obj1);
20465 if (arg2 == NULL) SWIG_fail;
20466 temp2 = true;
20467 }
20468 if (obj2) {
20469 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
20470 if (!SWIG_IsOK(res7)) {
20471 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DC_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont *""'");
20472 }
20473 arg7 = reinterpret_cast< wxFont * >(argp7);
20474 }
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 resultobj = SWIG_Py_Void();
20482 if (SWIG_IsTmpObj(res3)) {
20483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20484 } else {
20485 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20487 }
20488 if (SWIG_IsTmpObj(res4)) {
20489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20490 } else {
20491 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20493 }
20494 if (SWIG_IsTmpObj(res5)) {
20495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20496 } else {
20497 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20499 }
20500 if (SWIG_IsTmpObj(res6)) {
20501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
20502 } else {
20503 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
20505 }
20506 {
20507 if (temp2)
20508 delete arg2;
20509 }
20510 return resultobj;
20511 fail:
20512 {
20513 if (temp2)
20514 delete arg2;
20515 }
20516 return NULL;
20517 }
20518
20519
20520 SWIGINTERN PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj = 0;
20522 wxDC *arg1 = (wxDC *) 0 ;
20523 wxString *arg2 = 0 ;
20524 int *arg3 = (int *) 0 ;
20525 int *arg4 = (int *) 0 ;
20526 int *arg5 = (int *) 0 ;
20527 wxFont *arg6 = (wxFont *) NULL ;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 bool temp2 = false ;
20531 int temp3 ;
20532 int res3 = SWIG_TMPOBJ ;
20533 int temp4 ;
20534 int res4 = SWIG_TMPOBJ ;
20535 int temp5 ;
20536 int res5 = SWIG_TMPOBJ ;
20537 void *argp6 = 0 ;
20538 int res6 = 0 ;
20539 PyObject * obj0 = 0 ;
20540 PyObject * obj1 = 0 ;
20541 PyObject * obj2 = 0 ;
20542 char * kwnames[] = {
20543 (char *) "self",(char *) "text",(char *) "font", NULL
20544 };
20545
20546 arg3 = &temp3;
20547 arg4 = &temp4;
20548 arg5 = &temp5;
20549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20551 if (!SWIG_IsOK(res1)) {
20552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20553 }
20554 arg1 = reinterpret_cast< wxDC * >(argp1);
20555 {
20556 arg2 = wxString_in_helper(obj1);
20557 if (arg2 == NULL) SWIG_fail;
20558 temp2 = true;
20559 }
20560 if (obj2) {
20561 res6 = SWIG_ConvertPtr(obj2, &argp6,SWIGTYPE_p_wxFont, 0 | 0 );
20562 if (!SWIG_IsOK(res6)) {
20563 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "6"" of type '" "wxFont *""'");
20564 }
20565 arg6 = reinterpret_cast< wxFont * >(argp6);
20566 }
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 resultobj = SWIG_Py_Void();
20574 if (SWIG_IsTmpObj(res3)) {
20575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20576 } else {
20577 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20579 }
20580 if (SWIG_IsTmpObj(res4)) {
20581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20582 } else {
20583 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20585 }
20586 if (SWIG_IsTmpObj(res5)) {
20587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20588 } else {
20589 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20591 }
20592 {
20593 if (temp2)
20594 delete arg2;
20595 }
20596 return resultobj;
20597 fail:
20598 {
20599 if (temp2)
20600 delete arg2;
20601 }
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_DC_GetPartialTextExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj = 0;
20608 wxDC *arg1 = (wxDC *) 0 ;
20609 wxString *arg2 = 0 ;
20610 wxArrayInt result;
20611 void *argp1 = 0 ;
20612 int res1 = 0 ;
20613 bool temp2 = false ;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char * kwnames[] = {
20617 (char *) "self",(char *) "text", NULL
20618 };
20619
20620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) SWIG_fail;
20621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPartialTextExtents" "', expected argument " "1"" of type '" "wxDC *""'");
20624 }
20625 arg1 = reinterpret_cast< wxDC * >(argp1);
20626 {
20627 arg2 = wxString_in_helper(obj1);
20628 if (arg2 == NULL) SWIG_fail;
20629 temp2 = true;
20630 }
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 {
20638 resultobj = PyList_New(0);
20639 size_t idx;
20640 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
20641 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
20642 PyList_Append(resultobj, val);
20643 Py_DECREF(val);
20644 }
20645 }
20646 {
20647 if (temp2)
20648 delete arg2;
20649 }
20650 return resultobj;
20651 fail:
20652 {
20653 if (temp2)
20654 delete arg2;
20655 }
20656 return NULL;
20657 }
20658
20659
20660 SWIGINTERN PyObject *_wrap_DC_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20661 PyObject *resultobj = 0;
20662 wxDC *arg1 = (wxDC *) 0 ;
20663 wxSize result;
20664 void *argp1 = 0 ;
20665 int res1 = 0 ;
20666 PyObject *swig_obj[1] ;
20667
20668 if (!args) SWIG_fail;
20669 swig_obj[0] = args;
20670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20671 if (!SWIG_IsOK(res1)) {
20672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSize" "', expected argument " "1"" of type '" "wxDC *""'");
20673 }
20674 arg1 = reinterpret_cast< wxDC * >(argp1);
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 result = (arg1)->GetSize();
20678 wxPyEndAllowThreads(__tstate);
20679 if (PyErr_Occurred()) SWIG_fail;
20680 }
20681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 SWIGINTERN PyObject *_wrap_DC_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20689 PyObject *resultobj = 0;
20690 wxDC *arg1 = (wxDC *) 0 ;
20691 int *arg2 = (int *) 0 ;
20692 int *arg3 = (int *) 0 ;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 int temp2 ;
20696 int res2 = SWIG_TMPOBJ ;
20697 int temp3 ;
20698 int res3 = SWIG_TMPOBJ ;
20699 PyObject *swig_obj[1] ;
20700
20701 arg2 = &temp2;
20702 arg3 = &temp3;
20703 if (!args) SWIG_fail;
20704 swig_obj[0] = args;
20705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20706 if (!SWIG_IsOK(res1)) {
20707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeTuple" "', expected argument " "1"" of type '" "wxDC *""'");
20708 }
20709 arg1 = reinterpret_cast< wxDC * >(argp1);
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 (arg1)->GetSize(arg2,arg3);
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 resultobj = SWIG_Py_Void();
20717 if (SWIG_IsTmpObj(res2)) {
20718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20719 } else {
20720 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20722 }
20723 if (SWIG_IsTmpObj(res3)) {
20724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20725 } else {
20726 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 SWIGINTERN PyObject *_wrap_DC_GetSizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20736 PyObject *resultobj = 0;
20737 wxDC *arg1 = (wxDC *) 0 ;
20738 wxSize result;
20739 void *argp1 = 0 ;
20740 int res1 = 0 ;
20741 PyObject *swig_obj[1] ;
20742
20743 if (!args) SWIG_fail;
20744 swig_obj[0] = args;
20745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20746 if (!SWIG_IsOK(res1)) {
20747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMM" "', expected argument " "1"" of type '" "wxDC const *""'");
20748 }
20749 arg1 = reinterpret_cast< wxDC * >(argp1);
20750 {
20751 PyThreadState* __tstate = wxPyBeginAllowThreads();
20752 result = ((wxDC const *)arg1)->GetSizeMM();
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 SWIGINTERN PyObject *_wrap_DC_GetSizeMMTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20764 PyObject *resultobj = 0;
20765 wxDC *arg1 = (wxDC *) 0 ;
20766 int *arg2 = (int *) 0 ;
20767 int *arg3 = (int *) 0 ;
20768 void *argp1 = 0 ;
20769 int res1 = 0 ;
20770 int temp2 ;
20771 int res2 = SWIG_TMPOBJ ;
20772 int temp3 ;
20773 int res3 = SWIG_TMPOBJ ;
20774 PyObject *swig_obj[1] ;
20775
20776 arg2 = &temp2;
20777 arg3 = &temp3;
20778 if (!args) SWIG_fail;
20779 swig_obj[0] = args;
20780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMMTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxDC * >(argp1);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 resultobj = SWIG_Py_Void();
20792 if (SWIG_IsTmpObj(res2)) {
20793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20794 } else {
20795 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20797 }
20798 if (SWIG_IsTmpObj(res3)) {
20799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20800 } else {
20801 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20803 }
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20811 PyObject *resultobj = 0;
20812 wxDC *arg1 = (wxDC *) 0 ;
20813 int arg2 ;
20814 int result;
20815 void *argp1 = 0 ;
20816 int res1 = 0 ;
20817 int val2 ;
20818 int ecode2 = 0 ;
20819 PyObject * obj0 = 0 ;
20820 PyObject * obj1 = 0 ;
20821 char * kwnames[] = {
20822 (char *) "self",(char *) "x", NULL
20823 };
20824
20825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) SWIG_fail;
20826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20827 if (!SWIG_IsOK(res1)) {
20828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalX" "', expected argument " "1"" of type '" "wxDC const *""'");
20829 }
20830 arg1 = reinterpret_cast< wxDC * >(argp1);
20831 ecode2 = SWIG_AsVal_int(obj1, &val2);
20832 if (!SWIG_IsOK(ecode2)) {
20833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalX" "', expected argument " "2"" of type '" "int""'");
20834 }
20835 arg2 = static_cast< int >(val2);
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 resultobj = SWIG_From_int(static_cast< int >(result));
20843 return resultobj;
20844 fail:
20845 return NULL;
20846 }
20847
20848
20849 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20850 PyObject *resultobj = 0;
20851 wxDC *arg1 = (wxDC *) 0 ;
20852 int arg2 ;
20853 int result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 int val2 ;
20857 int ecode2 = 0 ;
20858 PyObject * obj0 = 0 ;
20859 PyObject * obj1 = 0 ;
20860 char * kwnames[] = {
20861 (char *) "self",(char *) "y", NULL
20862 };
20863
20864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) SWIG_fail;
20865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20866 if (!SWIG_IsOK(res1)) {
20867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalY" "', expected argument " "1"" of type '" "wxDC const *""'");
20868 }
20869 arg1 = reinterpret_cast< wxDC * >(argp1);
20870 ecode2 = SWIG_AsVal_int(obj1, &val2);
20871 if (!SWIG_IsOK(ecode2)) {
20872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalY" "', expected argument " "2"" of type '" "int""'");
20873 }
20874 arg2 = static_cast< int >(val2);
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 resultobj = SWIG_From_int(static_cast< int >(result));
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj = 0;
20890 wxDC *arg1 = (wxDC *) 0 ;
20891 int arg2 ;
20892 int result;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 int val2 ;
20896 int ecode2 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 PyObject * obj1 = 0 ;
20899 char * kwnames[] = {
20900 (char *) "self",(char *) "x", NULL
20901 };
20902
20903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) SWIG_fail;
20904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
20907 }
20908 arg1 = reinterpret_cast< wxDC * >(argp1);
20909 ecode2 = SWIG_AsVal_int(obj1, &val2);
20910 if (!SWIG_IsOK(ecode2)) {
20911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "2"" of type '" "int""'");
20912 }
20913 arg2 = static_cast< int >(val2);
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 resultobj = SWIG_From_int(static_cast< int >(result));
20921 return resultobj;
20922 fail:
20923 return NULL;
20924 }
20925
20926
20927 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20928 PyObject *resultobj = 0;
20929 wxDC *arg1 = (wxDC *) 0 ;
20930 int arg2 ;
20931 int result;
20932 void *argp1 = 0 ;
20933 int res1 = 0 ;
20934 int val2 ;
20935 int ecode2 = 0 ;
20936 PyObject * obj0 = 0 ;
20937 PyObject * obj1 = 0 ;
20938 char * kwnames[] = {
20939 (char *) "self",(char *) "y", NULL
20940 };
20941
20942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) SWIG_fail;
20943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20944 if (!SWIG_IsOK(res1)) {
20945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
20946 }
20947 arg1 = reinterpret_cast< wxDC * >(argp1);
20948 ecode2 = SWIG_AsVal_int(obj1, &val2);
20949 if (!SWIG_IsOK(ecode2)) {
20950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "2"" of type '" "int""'");
20951 }
20952 arg2 = static_cast< int >(val2);
20953 {
20954 PyThreadState* __tstate = wxPyBeginAllowThreads();
20955 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 resultobj = SWIG_From_int(static_cast< int >(result));
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj = 0;
20968 wxDC *arg1 = (wxDC *) 0 ;
20969 int arg2 ;
20970 int result;
20971 void *argp1 = 0 ;
20972 int res1 = 0 ;
20973 int val2 ;
20974 int ecode2 = 0 ;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 char * kwnames[] = {
20978 (char *) "self",(char *) "x", NULL
20979 };
20980
20981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) SWIG_fail;
20982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceX" "', expected argument " "1"" of type '" "wxDC const *""'");
20985 }
20986 arg1 = reinterpret_cast< wxDC * >(argp1);
20987 ecode2 = SWIG_AsVal_int(obj1, &val2);
20988 if (!SWIG_IsOK(ecode2)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceX" "', expected argument " "2"" of type '" "int""'");
20990 }
20991 arg2 = static_cast< int >(val2);
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_From_int(static_cast< int >(result));
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21006 PyObject *resultobj = 0;
21007 wxDC *arg1 = (wxDC *) 0 ;
21008 int arg2 ;
21009 int result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 int val2 ;
21013 int ecode2 = 0 ;
21014 PyObject * obj0 = 0 ;
21015 PyObject * obj1 = 0 ;
21016 char * kwnames[] = {
21017 (char *) "self",(char *) "y", NULL
21018 };
21019
21020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) SWIG_fail;
21021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21022 if (!SWIG_IsOK(res1)) {
21023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceY" "', expected argument " "1"" of type '" "wxDC const *""'");
21024 }
21025 arg1 = reinterpret_cast< wxDC * >(argp1);
21026 ecode2 = SWIG_AsVal_int(obj1, &val2);
21027 if (!SWIG_IsOK(ecode2)) {
21028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceY" "', expected argument " "2"" of type '" "int""'");
21029 }
21030 arg2 = static_cast< int >(val2);
21031 {
21032 PyThreadState* __tstate = wxPyBeginAllowThreads();
21033 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
21034 wxPyEndAllowThreads(__tstate);
21035 if (PyErr_Occurred()) SWIG_fail;
21036 }
21037 resultobj = SWIG_From_int(static_cast< int >(result));
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj = 0;
21046 wxDC *arg1 = (wxDC *) 0 ;
21047 int arg2 ;
21048 int result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 int val2 ;
21052 int ecode2 = 0 ;
21053 PyObject * obj0 = 0 ;
21054 PyObject * obj1 = 0 ;
21055 char * kwnames[] = {
21056 (char *) "self",(char *) "x", NULL
21057 };
21058
21059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) SWIG_fail;
21060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21061 if (!SWIG_IsOK(res1)) {
21062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21063 }
21064 arg1 = reinterpret_cast< wxDC * >(argp1);
21065 ecode2 = SWIG_AsVal_int(obj1, &val2);
21066 if (!SWIG_IsOK(ecode2)) {
21067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "2"" of type '" "int""'");
21068 }
21069 arg2 = static_cast< int >(val2);
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 resultobj = SWIG_From_int(static_cast< int >(result));
21077 return resultobj;
21078 fail:
21079 return NULL;
21080 }
21081
21082
21083 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21084 PyObject *resultobj = 0;
21085 wxDC *arg1 = (wxDC *) 0 ;
21086 int arg2 ;
21087 int result;
21088 void *argp1 = 0 ;
21089 int res1 = 0 ;
21090 int val2 ;
21091 int ecode2 = 0 ;
21092 PyObject * obj0 = 0 ;
21093 PyObject * obj1 = 0 ;
21094 char * kwnames[] = {
21095 (char *) "self",(char *) "y", NULL
21096 };
21097
21098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) SWIG_fail;
21099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21100 if (!SWIG_IsOK(res1)) {
21101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21102 }
21103 arg1 = reinterpret_cast< wxDC * >(argp1);
21104 ecode2 = SWIG_AsVal_int(obj1, &val2);
21105 if (!SWIG_IsOK(ecode2)) {
21106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "2"" of type '" "int""'");
21107 }
21108 arg2 = static_cast< int >(val2);
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 resultobj = SWIG_From_int(static_cast< int >(result));
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_DC_CanDrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxDC *arg1 = (wxDC *) 0 ;
21125 bool result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanDrawBitmap" "', expected argument " "1"" of type '" "wxDC const *""'");
21135 }
21136 arg1 = reinterpret_cast< wxDC * >(argp1);
21137 {
21138 PyThreadState* __tstate = wxPyBeginAllowThreads();
21139 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_DC_CanGetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxDC *arg1 = (wxDC *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanGetTextExtent" "', expected argument " "1"" of type '" "wxDC const *""'");
21165 }
21166 arg1 = reinterpret_cast< wxDC * >(argp1);
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_DC_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxDC *arg1 = (wxDC *) 0 ;
21185 int result;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 PyObject *swig_obj[1] ;
21189
21190 if (!args) SWIG_fail;
21191 swig_obj[0] = args;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDepth" "', expected argument " "1"" of type '" "wxDC const *""'");
21195 }
21196 arg1 = reinterpret_cast< wxDC * >(argp1);
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (int)((wxDC const *)arg1)->GetDepth();
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 resultobj = SWIG_From_int(static_cast< int >(result));
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_DC_GetPPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 PyObject *resultobj = 0;
21212 wxDC *arg1 = (wxDC *) 0 ;
21213 wxSize result;
21214 void *argp1 = 0 ;
21215 int res1 = 0 ;
21216 PyObject *swig_obj[1] ;
21217
21218 if (!args) SWIG_fail;
21219 swig_obj[0] = args;
21220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPPI" "', expected argument " "1"" of type '" "wxDC const *""'");
21223 }
21224 arg1 = reinterpret_cast< wxDC * >(argp1);
21225 {
21226 PyThreadState* __tstate = wxPyBeginAllowThreads();
21227 result = ((wxDC const *)arg1)->GetPPI();
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_DC_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21239 PyObject *resultobj = 0;
21240 wxDC *arg1 = (wxDC *) 0 ;
21241 bool result;
21242 void *argp1 = 0 ;
21243 int res1 = 0 ;
21244 PyObject *swig_obj[1] ;
21245
21246 if (!args) SWIG_fail;
21247 swig_obj[0] = args;
21248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21249 if (!SWIG_IsOK(res1)) {
21250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Ok" "', expected argument " "1"" of type '" "wxDC const *""'");
21251 }
21252 arg1 = reinterpret_cast< wxDC * >(argp1);
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 result = (bool)((wxDC const *)arg1)->Ok();
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 {
21260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21261 }
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_DC_GetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269 PyObject *resultobj = 0;
21270 wxDC *arg1 = (wxDC *) 0 ;
21271 int result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 PyObject *swig_obj[1] ;
21275
21276 if (!args) SWIG_fail;
21277 swig_obj[0] = args;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackgroundMode" "', expected argument " "1"" of type '" "wxDC const *""'");
21281 }
21282 arg1 = reinterpret_cast< wxDC * >(argp1);
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 resultobj = SWIG_From_int(static_cast< int >(result));
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 SWIGINTERN PyObject *_wrap_DC_GetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21297 PyObject *resultobj = 0;
21298 wxDC *arg1 = (wxDC *) 0 ;
21299 wxBrush *result = 0 ;
21300 void *argp1 = 0 ;
21301 int res1 = 0 ;
21302 PyObject *swig_obj[1] ;
21303
21304 if (!args) SWIG_fail;
21305 swig_obj[0] = args;
21306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21307 if (!SWIG_IsOK(res1)) {
21308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
21309 }
21310 arg1 = reinterpret_cast< wxDC * >(argp1);
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 {
21314 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
21315 result = (wxBrush *) &_result_ref;
21316 }
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 {
21321 wxBrush* resultptr = new wxBrush(*result);
21322 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
21323 }
21324 return resultobj;
21325 fail:
21326 return NULL;
21327 }
21328
21329
21330 SWIGINTERN PyObject *_wrap_DC_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21331 PyObject *resultobj = 0;
21332 wxDC *arg1 = (wxDC *) 0 ;
21333 wxBrush *result = 0 ;
21334 void *argp1 = 0 ;
21335 int res1 = 0 ;
21336 PyObject *swig_obj[1] ;
21337
21338 if (!args) SWIG_fail;
21339 swig_obj[0] = args;
21340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21341 if (!SWIG_IsOK(res1)) {
21342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBrush" "', expected argument " "1"" of type '" "wxDC const *""'");
21343 }
21344 arg1 = reinterpret_cast< wxDC * >(argp1);
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 {
21348 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
21349 result = (wxBrush *) &_result_ref;
21350 }
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 {
21355 wxBrush* resultptr = new wxBrush(*result);
21356 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
21357 }
21358 return resultobj;
21359 fail:
21360 return NULL;
21361 }
21362
21363
21364 SWIGINTERN PyObject *_wrap_DC_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21365 PyObject *resultobj = 0;
21366 wxDC *arg1 = (wxDC *) 0 ;
21367 wxFont *result = 0 ;
21368 void *argp1 = 0 ;
21369 int res1 = 0 ;
21370 PyObject *swig_obj[1] ;
21371
21372 if (!args) SWIG_fail;
21373 swig_obj[0] = args;
21374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21375 if (!SWIG_IsOK(res1)) {
21376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFont" "', expected argument " "1"" of type '" "wxDC const *""'");
21377 }
21378 arg1 = reinterpret_cast< wxDC * >(argp1);
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 {
21382 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
21383 result = (wxFont *) &_result_ref;
21384 }
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 {
21389 wxFont* resultptr = new wxFont(*result);
21390 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
21391 }
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 SWIGINTERN PyObject *_wrap_DC_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21399 PyObject *resultobj = 0;
21400 wxDC *arg1 = (wxDC *) 0 ;
21401 wxPen *result = 0 ;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 PyObject *swig_obj[1] ;
21405
21406 if (!args) SWIG_fail;
21407 swig_obj[0] = args;
21408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPen" "', expected argument " "1"" of type '" "wxDC const *""'");
21411 }
21412 arg1 = reinterpret_cast< wxDC * >(argp1);
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 {
21416 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
21417 result = (wxPen *) &_result_ref;
21418 }
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 {
21423 wxPen* resultptr = new wxPen(*result);
21424 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
21425 }
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 SWIGINTERN PyObject *_wrap_DC_GetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433 PyObject *resultobj = 0;
21434 wxDC *arg1 = (wxDC *) 0 ;
21435 wxColour *result = 0 ;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
21445 }
21446 arg1 = reinterpret_cast< wxDC * >(argp1);
21447 {
21448 PyThreadState* __tstate = wxPyBeginAllowThreads();
21449 {
21450 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
21451 result = (wxColour *) &_result_ref;
21452 }
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 SWIGINTERN PyObject *_wrap_DC_GetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 PyObject *resultobj = 0;
21465 wxDC *arg1 = (wxDC *) 0 ;
21466 wxColour *result = 0 ;
21467 void *argp1 = 0 ;
21468 int res1 = 0 ;
21469 PyObject *swig_obj[1] ;
21470
21471 if (!args) SWIG_fail;
21472 swig_obj[0] = args;
21473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21474 if (!SWIG_IsOK(res1)) {
21475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextForeground" "', expected argument " "1"" of type '" "wxDC const *""'");
21476 }
21477 arg1 = reinterpret_cast< wxDC * >(argp1);
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 {
21481 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
21482 result = (wxColour *) &_result_ref;
21483 }
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_DC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj = 0;
21496 wxDC *arg1 = (wxDC *) 0 ;
21497 wxColour *arg2 = 0 ;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 wxColour temp2 ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char * kwnames[] = {
21504 (char *) "self",(char *) "colour", NULL
21505 };
21506
21507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
21508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextForeground" "', expected argument " "1"" of type '" "wxDC *""'");
21511 }
21512 arg1 = reinterpret_cast< wxDC * >(argp1);
21513 {
21514 arg2 = &temp2;
21515 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21516 }
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 (arg1)->SetTextForeground((wxColour const &)*arg2);
21520 wxPyEndAllowThreads(__tstate);
21521 if (PyErr_Occurred()) SWIG_fail;
21522 }
21523 resultobj = SWIG_Py_Void();
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 SWIGINTERN PyObject *_wrap_DC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj = 0;
21532 wxDC *arg1 = (wxDC *) 0 ;
21533 wxColour *arg2 = 0 ;
21534 void *argp1 = 0 ;
21535 int res1 = 0 ;
21536 wxColour temp2 ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 char * kwnames[] = {
21540 (char *) "self",(char *) "colour", NULL
21541 };
21542
21543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
21544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21545 if (!SWIG_IsOK(res1)) {
21546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextBackground" "', expected argument " "1"" of type '" "wxDC *""'");
21547 }
21548 arg1 = reinterpret_cast< wxDC * >(argp1);
21549 {
21550 arg2 = &temp2;
21551 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21552 }
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 (arg1)->SetTextBackground((wxColour const &)*arg2);
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 resultobj = SWIG_Py_Void();
21560 return resultobj;
21561 fail:
21562 return NULL;
21563 }
21564
21565
21566 SWIGINTERN PyObject *_wrap_DC_GetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21567 PyObject *resultobj = 0;
21568 wxDC *arg1 = (wxDC *) 0 ;
21569 int result;
21570 void *argp1 = 0 ;
21571 int res1 = 0 ;
21572 PyObject *swig_obj[1] ;
21573
21574 if (!args) SWIG_fail;
21575 swig_obj[0] = args;
21576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21577 if (!SWIG_IsOK(res1)) {
21578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMapMode" "', expected argument " "1"" of type '" "wxDC const *""'");
21579 }
21580 arg1 = reinterpret_cast< wxDC * >(argp1);
21581 {
21582 PyThreadState* __tstate = wxPyBeginAllowThreads();
21583 result = (int)((wxDC const *)arg1)->GetMapMode();
21584 wxPyEndAllowThreads(__tstate);
21585 if (PyErr_Occurred()) SWIG_fail;
21586 }
21587 resultobj = SWIG_From_int(static_cast< int >(result));
21588 return resultobj;
21589 fail:
21590 return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_DC_SetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21595 PyObject *resultobj = 0;
21596 wxDC *arg1 = (wxDC *) 0 ;
21597 int arg2 ;
21598 void *argp1 = 0 ;
21599 int res1 = 0 ;
21600 int val2 ;
21601 int ecode2 = 0 ;
21602 PyObject * obj0 = 0 ;
21603 PyObject * obj1 = 0 ;
21604 char * kwnames[] = {
21605 (char *) "self",(char *) "mode", NULL
21606 };
21607
21608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) SWIG_fail;
21609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21610 if (!SWIG_IsOK(res1)) {
21611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetMapMode" "', expected argument " "1"" of type '" "wxDC *""'");
21612 }
21613 arg1 = reinterpret_cast< wxDC * >(argp1);
21614 ecode2 = SWIG_AsVal_int(obj1, &val2);
21615 if (!SWIG_IsOK(ecode2)) {
21616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetMapMode" "', expected argument " "2"" of type '" "int""'");
21617 }
21618 arg2 = static_cast< int >(val2);
21619 {
21620 PyThreadState* __tstate = wxPyBeginAllowThreads();
21621 (arg1)->SetMapMode(arg2);
21622 wxPyEndAllowThreads(__tstate);
21623 if (PyErr_Occurred()) SWIG_fail;
21624 }
21625 resultobj = SWIG_Py_Void();
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 SWIGINTERN PyObject *_wrap_DC_GetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21633 PyObject *resultobj = 0;
21634 wxDC *arg1 = (wxDC *) 0 ;
21635 double *arg2 = (double *) 0 ;
21636 double *arg3 = (double *) 0 ;
21637 void *argp1 = 0 ;
21638 int res1 = 0 ;
21639 double temp2 ;
21640 int res2 = SWIG_TMPOBJ ;
21641 double temp3 ;
21642 int res3 = SWIG_TMPOBJ ;
21643 PyObject *swig_obj[1] ;
21644
21645 arg2 = &temp2;
21646 arg3 = &temp3;
21647 if (!args) SWIG_fail;
21648 swig_obj[0] = args;
21649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21650 if (!SWIG_IsOK(res1)) {
21651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetUserScale" "', expected argument " "1"" of type '" "wxDC const *""'");
21652 }
21653 arg1 = reinterpret_cast< wxDC * >(argp1);
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_Py_Void();
21661 if (SWIG_IsTmpObj(res2)) {
21662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
21663 } else {
21664 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21666 }
21667 if (SWIG_IsTmpObj(res3)) {
21668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
21669 } else {
21670 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
21672 }
21673 return resultobj;
21674 fail:
21675 return NULL;
21676 }
21677
21678
21679 SWIGINTERN PyObject *_wrap_DC_SetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxDC *arg1 = (wxDC *) 0 ;
21682 double arg2 ;
21683 double arg3 ;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 double val2 ;
21687 int ecode2 = 0 ;
21688 double val3 ;
21689 int ecode3 = 0 ;
21690 PyObject * obj0 = 0 ;
21691 PyObject * obj1 = 0 ;
21692 PyObject * obj2 = 0 ;
21693 char * kwnames[] = {
21694 (char *) "self",(char *) "x",(char *) "y", NULL
21695 };
21696
21697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetUserScale" "', expected argument " "1"" of type '" "wxDC *""'");
21701 }
21702 arg1 = reinterpret_cast< wxDC * >(argp1);
21703 ecode2 = SWIG_AsVal_double(obj1, &val2);
21704 if (!SWIG_IsOK(ecode2)) {
21705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetUserScale" "', expected argument " "2"" of type '" "double""'");
21706 }
21707 arg2 = static_cast< double >(val2);
21708 ecode3 = SWIG_AsVal_double(obj2, &val3);
21709 if (!SWIG_IsOK(ecode3)) {
21710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetUserScale" "', expected argument " "3"" of type '" "double""'");
21711 }
21712 arg3 = static_cast< double >(val3);
21713 {
21714 PyThreadState* __tstate = wxPyBeginAllowThreads();
21715 (arg1)->SetUserScale(arg2,arg3);
21716 wxPyEndAllowThreads(__tstate);
21717 if (PyErr_Occurred()) SWIG_fail;
21718 }
21719 resultobj = SWIG_Py_Void();
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *_wrap_DC_GetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21727 PyObject *resultobj = 0;
21728 wxDC *arg1 = (wxDC *) 0 ;
21729 double *arg2 = (double *) 0 ;
21730 double *arg3 = (double *) 0 ;
21731 void *argp1 = 0 ;
21732 int res1 = 0 ;
21733 double temp2 ;
21734 int res2 = SWIG_TMPOBJ ;
21735 double temp3 ;
21736 int res3 = SWIG_TMPOBJ ;
21737 PyObject *swig_obj[1] ;
21738
21739 arg2 = &temp2;
21740 arg3 = &temp3;
21741 if (!args) SWIG_fail;
21742 swig_obj[0] = args;
21743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
21746 }
21747 arg1 = reinterpret_cast< wxDC * >(argp1);
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 (arg1)->GetLogicalScale(arg2,arg3);
21751 wxPyEndAllowThreads(__tstate);
21752 if (PyErr_Occurred()) SWIG_fail;
21753 }
21754 resultobj = SWIG_Py_Void();
21755 if (SWIG_IsTmpObj(res2)) {
21756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
21757 } else {
21758 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21760 }
21761 if (SWIG_IsTmpObj(res3)) {
21762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
21763 } else {
21764 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
21766 }
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 SWIGINTERN PyObject *_wrap_DC_SetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21774 PyObject *resultobj = 0;
21775 wxDC *arg1 = (wxDC *) 0 ;
21776 double arg2 ;
21777 double arg3 ;
21778 void *argp1 = 0 ;
21779 int res1 = 0 ;
21780 double val2 ;
21781 int ecode2 = 0 ;
21782 double val3 ;
21783 int ecode3 = 0 ;
21784 PyObject * obj0 = 0 ;
21785 PyObject * obj1 = 0 ;
21786 PyObject * obj2 = 0 ;
21787 char * kwnames[] = {
21788 (char *) "self",(char *) "x",(char *) "y", NULL
21789 };
21790
21791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
21795 }
21796 arg1 = reinterpret_cast< wxDC * >(argp1);
21797 ecode2 = SWIG_AsVal_double(obj1, &val2);
21798 if (!SWIG_IsOK(ecode2)) {
21799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalScale" "', expected argument " "2"" of type '" "double""'");
21800 }
21801 arg2 = static_cast< double >(val2);
21802 ecode3 = SWIG_AsVal_double(obj2, &val3);
21803 if (!SWIG_IsOK(ecode3)) {
21804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalScale" "', expected argument " "3"" of type '" "double""'");
21805 }
21806 arg3 = static_cast< double >(val3);
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 (arg1)->SetLogicalScale(arg2,arg3);
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 resultobj = SWIG_Py_Void();
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_DC_GetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 PyObject *resultobj = 0;
21822 wxDC *arg1 = (wxDC *) 0 ;
21823 wxPoint result;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 PyObject *swig_obj[1] ;
21827
21828 if (!args) SWIG_fail;
21829 swig_obj[0] = args;
21830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
21833 }
21834 arg1 = reinterpret_cast< wxDC * >(argp1);
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 result = ((wxDC const *)arg1)->GetLogicalOrigin();
21838 wxPyEndAllowThreads(__tstate);
21839 if (PyErr_Occurred()) SWIG_fail;
21840 }
21841 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21842 return resultobj;
21843 fail:
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 PyObject *resultobj = 0;
21850 wxDC *arg1 = (wxDC *) 0 ;
21851 int *arg2 = (int *) 0 ;
21852 int *arg3 = (int *) 0 ;
21853 void *argp1 = 0 ;
21854 int res1 = 0 ;
21855 int temp2 ;
21856 int res2 = SWIG_TMPOBJ ;
21857 int temp3 ;
21858 int res3 = SWIG_TMPOBJ ;
21859 PyObject *swig_obj[1] ;
21860
21861 arg2 = &temp2;
21862 arg3 = &temp3;
21863 if (!args) SWIG_fail;
21864 swig_obj[0] = args;
21865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21866 if (!SWIG_IsOK(res1)) {
21867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
21868 }
21869 arg1 = reinterpret_cast< wxDC * >(argp1);
21870 {
21871 PyThreadState* __tstate = wxPyBeginAllowThreads();
21872 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 resultobj = SWIG_Py_Void();
21877 if (SWIG_IsTmpObj(res2)) {
21878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
21879 } else {
21880 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
21882 }
21883 if (SWIG_IsTmpObj(res3)) {
21884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21885 } else {
21886 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21888 }
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 SWIGINTERN PyObject *_wrap_DC_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21896 PyObject *resultobj = 0;
21897 wxDC *arg1 = (wxDC *) 0 ;
21898 int arg2 ;
21899 int arg3 ;
21900 void *argp1 = 0 ;
21901 int res1 = 0 ;
21902 int val2 ;
21903 int ecode2 = 0 ;
21904 int val3 ;
21905 int ecode3 = 0 ;
21906 PyObject * obj0 = 0 ;
21907 PyObject * obj1 = 0 ;
21908 PyObject * obj2 = 0 ;
21909 char * kwnames[] = {
21910 (char *) "self",(char *) "x",(char *) "y", NULL
21911 };
21912
21913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21915 if (!SWIG_IsOK(res1)) {
21916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
21917 }
21918 arg1 = reinterpret_cast< wxDC * >(argp1);
21919 ecode2 = SWIG_AsVal_int(obj1, &val2);
21920 if (!SWIG_IsOK(ecode2)) {
21921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
21922 }
21923 arg2 = static_cast< int >(val2);
21924 ecode3 = SWIG_AsVal_int(obj2, &val3);
21925 if (!SWIG_IsOK(ecode3)) {
21926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
21927 }
21928 arg3 = static_cast< int >(val3);
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 (arg1)->SetLogicalOrigin(arg2,arg3);
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 resultobj = SWIG_Py_Void();
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21943 PyObject *resultobj = 0;
21944 wxDC *arg1 = (wxDC *) 0 ;
21945 wxPoint *arg2 = 0 ;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 wxPoint temp2 ;
21949 PyObject * obj0 = 0 ;
21950 PyObject * obj1 = 0 ;
21951 char * kwnames[] = {
21952 (char *) "self",(char *) "point", NULL
21953 };
21954
21955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
21956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21957 if (!SWIG_IsOK(res1)) {
21958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
21959 }
21960 arg1 = reinterpret_cast< wxDC * >(argp1);
21961 {
21962 arg2 = &temp2;
21963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21964 }
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 resultobj = SWIG_Py_Void();
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 SWIGINTERN PyObject *_wrap_DC_GetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21979 PyObject *resultobj = 0;
21980 wxDC *arg1 = (wxDC *) 0 ;
21981 wxPoint result;
21982 void *argp1 = 0 ;
21983 int res1 = 0 ;
21984 PyObject *swig_obj[1] ;
21985
21986 if (!args) SWIG_fail;
21987 swig_obj[0] = args;
21988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21989 if (!SWIG_IsOK(res1)) {
21990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
21991 }
21992 arg1 = reinterpret_cast< wxDC * >(argp1);
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 result = ((wxDC const *)arg1)->GetDeviceOrigin();
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 wxDC *arg1 = (wxDC *) 0 ;
22009 int *arg2 = (int *) 0 ;
22010 int *arg3 = (int *) 0 ;
22011 void *argp1 = 0 ;
22012 int res1 = 0 ;
22013 int temp2 ;
22014 int res2 = SWIG_TMPOBJ ;
22015 int temp3 ;
22016 int res3 = SWIG_TMPOBJ ;
22017 PyObject *swig_obj[1] ;
22018
22019 arg2 = &temp2;
22020 arg3 = &temp3;
22021 if (!args) SWIG_fail;
22022 swig_obj[0] = args;
22023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
22026 }
22027 arg1 = reinterpret_cast< wxDC * >(argp1);
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_Py_Void();
22035 if (SWIG_IsTmpObj(res2)) {
22036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22037 } else {
22038 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22040 }
22041 if (SWIG_IsTmpObj(res3)) {
22042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22043 } else {
22044 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 SWIGINTERN PyObject *_wrap_DC_SetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj = 0;
22055 wxDC *arg1 = (wxDC *) 0 ;
22056 int arg2 ;
22057 int arg3 ;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 int val2 ;
22061 int ecode2 = 0 ;
22062 int val3 ;
22063 int ecode3 = 0 ;
22064 PyObject * obj0 = 0 ;
22065 PyObject * obj1 = 0 ;
22066 PyObject * obj2 = 0 ;
22067 char * kwnames[] = {
22068 (char *) "self",(char *) "x",(char *) "y", NULL
22069 };
22070
22071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22073 if (!SWIG_IsOK(res1)) {
22074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22075 }
22076 arg1 = reinterpret_cast< wxDC * >(argp1);
22077 ecode2 = SWIG_AsVal_int(obj1, &val2);
22078 if (!SWIG_IsOK(ecode2)) {
22079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetDeviceOrigin" "', expected argument " "2"" of type '" "int""'");
22080 }
22081 arg2 = static_cast< int >(val2);
22082 ecode3 = SWIG_AsVal_int(obj2, &val3);
22083 if (!SWIG_IsOK(ecode3)) {
22084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetDeviceOrigin" "', expected argument " "3"" of type '" "int""'");
22085 }
22086 arg3 = static_cast< int >(val3);
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 (arg1)->SetDeviceOrigin(arg2,arg3);
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 resultobj = SWIG_Py_Void();
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 SWIGINTERN PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22101 PyObject *resultobj = 0;
22102 wxDC *arg1 = (wxDC *) 0 ;
22103 wxPoint *arg2 = 0 ;
22104 void *argp1 = 0 ;
22105 int res1 = 0 ;
22106 wxPoint temp2 ;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 char * kwnames[] = {
22110 (char *) "self",(char *) "point", NULL
22111 };
22112
22113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22115 if (!SWIG_IsOK(res1)) {
22116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22117 }
22118 arg1 = reinterpret_cast< wxDC * >(argp1);
22119 {
22120 arg2 = &temp2;
22121 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22122 }
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_Py_Void();
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_DC_SetAxisOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22137 PyObject *resultobj = 0;
22138 wxDC *arg1 = (wxDC *) 0 ;
22139 bool arg2 ;
22140 bool arg3 ;
22141 void *argp1 = 0 ;
22142 int res1 = 0 ;
22143 bool val2 ;
22144 int ecode2 = 0 ;
22145 bool val3 ;
22146 int ecode3 = 0 ;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149 PyObject * obj2 = 0 ;
22150 char * kwnames[] = {
22151 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
22152 };
22153
22154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22156 if (!SWIG_IsOK(res1)) {
22157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetAxisOrientation" "', expected argument " "1"" of type '" "wxDC *""'");
22158 }
22159 arg1 = reinterpret_cast< wxDC * >(argp1);
22160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22161 if (!SWIG_IsOK(ecode2)) {
22162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetAxisOrientation" "', expected argument " "2"" of type '" "bool""'");
22163 }
22164 arg2 = static_cast< bool >(val2);
22165 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22166 if (!SWIG_IsOK(ecode3)) {
22167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetAxisOrientation" "', expected argument " "3"" of type '" "bool""'");
22168 }
22169 arg3 = static_cast< bool >(val3);
22170 {
22171 PyThreadState* __tstate = wxPyBeginAllowThreads();
22172 (arg1)->SetAxisOrientation(arg2,arg3);
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 resultobj = SWIG_Py_Void();
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 SWIGINTERN PyObject *_wrap_DC_GetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22184 PyObject *resultobj = 0;
22185 wxDC *arg1 = (wxDC *) 0 ;
22186 int result;
22187 void *argp1 = 0 ;
22188 int res1 = 0 ;
22189 PyObject *swig_obj[1] ;
22190
22191 if (!args) SWIG_fail;
22192 swig_obj[0] = args;
22193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22194 if (!SWIG_IsOK(res1)) {
22195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalFunction" "', expected argument " "1"" of type '" "wxDC const *""'");
22196 }
22197 arg1 = reinterpret_cast< wxDC * >(argp1);
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 resultobj = SWIG_From_int(static_cast< int >(result));
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_DC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj = 0;
22213 wxDC *arg1 = (wxDC *) 0 ;
22214 int arg2 ;
22215 void *argp1 = 0 ;
22216 int res1 = 0 ;
22217 int val2 ;
22218 int ecode2 = 0 ;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char * kwnames[] = {
22222 (char *) "self",(char *) "function", NULL
22223 };
22224
22225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
22226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22227 if (!SWIG_IsOK(res1)) {
22228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxDC *""'");
22229 }
22230 arg1 = reinterpret_cast< wxDC * >(argp1);
22231 ecode2 = SWIG_AsVal_int(obj1, &val2);
22232 if (!SWIG_IsOK(ecode2)) {
22233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
22234 }
22235 arg2 = static_cast< int >(val2);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 (arg1)->SetLogicalFunction(arg2);
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_Py_Void();
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxDC *arg1 = (wxDC *) 0 ;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 PyObject *swig_obj[1] ;
22255
22256 if (!args) SWIG_fail;
22257 swig_obj[0] = args;
22258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22259 if (!SWIG_IsOK(res1)) {
22260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ComputeScaleAndOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22261 }
22262 arg1 = reinterpret_cast< wxDC * >(argp1);
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 (arg1)->ComputeScaleAndOrigin();
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 resultobj = SWIG_Py_Void();
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj = 0;
22278 wxDC *arg1 = (wxDC *) 0 ;
22279 int arg2 ;
22280 int arg3 ;
22281 void *argp1 = 0 ;
22282 int res1 = 0 ;
22283 int val2 ;
22284 int ecode2 = 0 ;
22285 int val3 ;
22286 int ecode3 = 0 ;
22287 PyObject * obj0 = 0 ;
22288 PyObject * obj1 = 0 ;
22289 PyObject * obj2 = 0 ;
22290 char * kwnames[] = {
22291 (char *) "self",(char *) "x",(char *) "y", NULL
22292 };
22293
22294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22298 }
22299 arg1 = reinterpret_cast< wxDC * >(argp1);
22300 ecode2 = SWIG_AsVal_int(obj1, &val2);
22301 if (!SWIG_IsOK(ecode2)) {
22302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CalcBoundingBox" "', expected argument " "2"" of type '" "int""'");
22303 }
22304 arg2 = static_cast< int >(val2);
22305 ecode3 = SWIG_AsVal_int(obj2, &val3);
22306 if (!SWIG_IsOK(ecode3)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CalcBoundingBox" "', expected argument " "3"" of type '" "int""'");
22308 }
22309 arg3 = static_cast< int >(val3);
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 (arg1)->CalcBoundingBox(arg2,arg3);
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 resultobj = SWIG_Py_Void();
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = 0;
22325 wxDC *arg1 = (wxDC *) 0 ;
22326 wxPoint *arg2 = 0 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 wxPoint temp2 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "self",(char *) "point", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22338 if (!SWIG_IsOK(res1)) {
22339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBoxPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22340 }
22341 arg1 = reinterpret_cast< wxDC * >(argp1);
22342 {
22343 arg2 = &temp2;
22344 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22345 }
22346 {
22347 PyThreadState* __tstate = wxPyBeginAllowThreads();
22348 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
22349 wxPyEndAllowThreads(__tstate);
22350 if (PyErr_Occurred()) SWIG_fail;
22351 }
22352 resultobj = SWIG_Py_Void();
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_DC_ResetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22360 PyObject *resultobj = 0;
22361 wxDC *arg1 = (wxDC *) 0 ;
22362 void *argp1 = 0 ;
22363 int res1 = 0 ;
22364 PyObject *swig_obj[1] ;
22365
22366 if (!args) SWIG_fail;
22367 swig_obj[0] = args;
22368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22369 if (!SWIG_IsOK(res1)) {
22370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ResetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22371 }
22372 arg1 = reinterpret_cast< wxDC * >(argp1);
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 (arg1)->ResetBoundingBox();
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 resultobj = SWIG_Py_Void();
22380 return resultobj;
22381 fail:
22382 return NULL;
22383 }
22384
22385
22386 SWIGINTERN PyObject *_wrap_DC_MinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22387 PyObject *resultobj = 0;
22388 wxDC *arg1 = (wxDC *) 0 ;
22389 int result;
22390 void *argp1 = 0 ;
22391 int res1 = 0 ;
22392 PyObject *swig_obj[1] ;
22393
22394 if (!args) SWIG_fail;
22395 swig_obj[0] = args;
22396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22397 if (!SWIG_IsOK(res1)) {
22398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinX" "', expected argument " "1"" of type '" "wxDC const *""'");
22399 }
22400 arg1 = reinterpret_cast< wxDC * >(argp1);
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 result = (int)((wxDC const *)arg1)->MinX();
22404 wxPyEndAllowThreads(__tstate);
22405 if (PyErr_Occurred()) SWIG_fail;
22406 }
22407 resultobj = SWIG_From_int(static_cast< int >(result));
22408 return resultobj;
22409 fail:
22410 return NULL;
22411 }
22412
22413
22414 SWIGINTERN PyObject *_wrap_DC_MaxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22415 PyObject *resultobj = 0;
22416 wxDC *arg1 = (wxDC *) 0 ;
22417 int result;
22418 void *argp1 = 0 ;
22419 int res1 = 0 ;
22420 PyObject *swig_obj[1] ;
22421
22422 if (!args) SWIG_fail;
22423 swig_obj[0] = args;
22424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22425 if (!SWIG_IsOK(res1)) {
22426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxX" "', expected argument " "1"" of type '" "wxDC const *""'");
22427 }
22428 arg1 = reinterpret_cast< wxDC * >(argp1);
22429 {
22430 PyThreadState* __tstate = wxPyBeginAllowThreads();
22431 result = (int)((wxDC const *)arg1)->MaxX();
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 resultobj = SWIG_From_int(static_cast< int >(result));
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *_wrap_DC_MinY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *resultobj = 0;
22444 wxDC *arg1 = (wxDC *) 0 ;
22445 int result;
22446 void *argp1 = 0 ;
22447 int res1 = 0 ;
22448 PyObject *swig_obj[1] ;
22449
22450 if (!args) SWIG_fail;
22451 swig_obj[0] = args;
22452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22453 if (!SWIG_IsOK(res1)) {
22454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinY" "', expected argument " "1"" of type '" "wxDC const *""'");
22455 }
22456 arg1 = reinterpret_cast< wxDC * >(argp1);
22457 {
22458 PyThreadState* __tstate = wxPyBeginAllowThreads();
22459 result = (int)((wxDC const *)arg1)->MinY();
22460 wxPyEndAllowThreads(__tstate);
22461 if (PyErr_Occurred()) SWIG_fail;
22462 }
22463 resultobj = SWIG_From_int(static_cast< int >(result));
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 SWIGINTERN PyObject *_wrap_DC_MaxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22471 PyObject *resultobj = 0;
22472 wxDC *arg1 = (wxDC *) 0 ;
22473 int result;
22474 void *argp1 = 0 ;
22475 int res1 = 0 ;
22476 PyObject *swig_obj[1] ;
22477
22478 if (!args) SWIG_fail;
22479 swig_obj[0] = args;
22480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22481 if (!SWIG_IsOK(res1)) {
22482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxY" "', expected argument " "1"" of type '" "wxDC const *""'");
22483 }
22484 arg1 = reinterpret_cast< wxDC * >(argp1);
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (int)((wxDC const *)arg1)->MaxY();
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_From_int(static_cast< int >(result));
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_DC_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxDC *arg1 = (wxDC *) 0 ;
22501 int *arg2 = (int *) 0 ;
22502 int *arg3 = (int *) 0 ;
22503 int *arg4 = (int *) 0 ;
22504 int *arg5 = (int *) 0 ;
22505 void *argp1 = 0 ;
22506 int res1 = 0 ;
22507 int temp2 ;
22508 int res2 = SWIG_TMPOBJ ;
22509 int temp3 ;
22510 int res3 = SWIG_TMPOBJ ;
22511 int temp4 ;
22512 int res4 = SWIG_TMPOBJ ;
22513 int temp5 ;
22514 int res5 = SWIG_TMPOBJ ;
22515 PyObject *swig_obj[1] ;
22516
22517 arg2 = &temp2;
22518 arg3 = &temp3;
22519 arg4 = &temp4;
22520 arg5 = &temp5;
22521 if (!args) SWIG_fail;
22522 swig_obj[0] = args;
22523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22524 if (!SWIG_IsOK(res1)) {
22525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22526 }
22527 arg1 = reinterpret_cast< wxDC * >(argp1);
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_Py_Void();
22535 if (SWIG_IsTmpObj(res2)) {
22536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22537 } else {
22538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22540 }
22541 if (SWIG_IsTmpObj(res3)) {
22542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22543 } else {
22544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22546 }
22547 if (SWIG_IsTmpObj(res4)) {
22548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
22549 } else {
22550 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
22552 }
22553 if (SWIG_IsTmpObj(res5)) {
22554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
22555 } else {
22556 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
22558 }
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 SWIGINTERN PyObject *_wrap_DC__DrawPointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj = 0;
22567 wxDC *arg1 = (wxDC *) 0 ;
22568 PyObject *arg2 = (PyObject *) 0 ;
22569 PyObject *arg3 = (PyObject *) 0 ;
22570 PyObject *arg4 = (PyObject *) 0 ;
22571 PyObject *result = 0 ;
22572 void *argp1 = 0 ;
22573 int res1 = 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 PyObject * obj2 = 0 ;
22577 PyObject * obj3 = 0 ;
22578 char * kwnames[] = {
22579 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22580 };
22581
22582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22584 if (!SWIG_IsOK(res1)) {
22585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPointList" "', expected argument " "1"" of type '" "wxDC *""'");
22586 }
22587 arg1 = reinterpret_cast< wxDC * >(argp1);
22588 arg2 = obj1;
22589 arg3 = obj2;
22590 arg4 = obj3;
22591 {
22592 PyThreadState* __tstate = wxPyBeginAllowThreads();
22593 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 resultobj = result;
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 SWIGINTERN PyObject *_wrap_DC__DrawLineList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22605 PyObject *resultobj = 0;
22606 wxDC *arg1 = (wxDC *) 0 ;
22607 PyObject *arg2 = (PyObject *) 0 ;
22608 PyObject *arg3 = (PyObject *) 0 ;
22609 PyObject *arg4 = (PyObject *) 0 ;
22610 PyObject *result = 0 ;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 PyObject * obj0 = 0 ;
22614 PyObject * obj1 = 0 ;
22615 PyObject * obj2 = 0 ;
22616 PyObject * obj3 = 0 ;
22617 char * kwnames[] = {
22618 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22619 };
22620
22621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22623 if (!SWIG_IsOK(res1)) {
22624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawLineList" "', expected argument " "1"" of type '" "wxDC *""'");
22625 }
22626 arg1 = reinterpret_cast< wxDC * >(argp1);
22627 arg2 = obj1;
22628 arg3 = obj2;
22629 arg4 = obj3;
22630 {
22631 PyThreadState* __tstate = wxPyBeginAllowThreads();
22632 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
22633 wxPyEndAllowThreads(__tstate);
22634 if (PyErr_Occurred()) SWIG_fail;
22635 }
22636 resultobj = result;
22637 return resultobj;
22638 fail:
22639 return NULL;
22640 }
22641
22642
22643 SWIGINTERN PyObject *_wrap_DC__DrawRectangleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22644 PyObject *resultobj = 0;
22645 wxDC *arg1 = (wxDC *) 0 ;
22646 PyObject *arg2 = (PyObject *) 0 ;
22647 PyObject *arg3 = (PyObject *) 0 ;
22648 PyObject *arg4 = (PyObject *) 0 ;
22649 PyObject *result = 0 ;
22650 void *argp1 = 0 ;
22651 int res1 = 0 ;
22652 PyObject * obj0 = 0 ;
22653 PyObject * obj1 = 0 ;
22654 PyObject * obj2 = 0 ;
22655 PyObject * obj3 = 0 ;
22656 char * kwnames[] = {
22657 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22658 };
22659
22660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawRectangleList" "', expected argument " "1"" of type '" "wxDC *""'");
22664 }
22665 arg1 = reinterpret_cast< wxDC * >(argp1);
22666 arg2 = obj1;
22667 arg3 = obj2;
22668 arg4 = obj3;
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 resultobj = result;
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 SWIGINTERN PyObject *_wrap_DC__DrawEllipseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22683 PyObject *resultobj = 0;
22684 wxDC *arg1 = (wxDC *) 0 ;
22685 PyObject *arg2 = (PyObject *) 0 ;
22686 PyObject *arg3 = (PyObject *) 0 ;
22687 PyObject *arg4 = (PyObject *) 0 ;
22688 PyObject *result = 0 ;
22689 void *argp1 = 0 ;
22690 int res1 = 0 ;
22691 PyObject * obj0 = 0 ;
22692 PyObject * obj1 = 0 ;
22693 PyObject * obj2 = 0 ;
22694 PyObject * obj3 = 0 ;
22695 char * kwnames[] = {
22696 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22697 };
22698
22699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22701 if (!SWIG_IsOK(res1)) {
22702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawEllipseList" "', expected argument " "1"" of type '" "wxDC *""'");
22703 }
22704 arg1 = reinterpret_cast< wxDC * >(argp1);
22705 arg2 = obj1;
22706 arg3 = obj2;
22707 arg4 = obj3;
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 resultobj = result;
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 SWIGINTERN PyObject *_wrap_DC__DrawPolygonList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22722 PyObject *resultobj = 0;
22723 wxDC *arg1 = (wxDC *) 0 ;
22724 PyObject *arg2 = (PyObject *) 0 ;
22725 PyObject *arg3 = (PyObject *) 0 ;
22726 PyObject *arg4 = (PyObject *) 0 ;
22727 PyObject *result = 0 ;
22728 void *argp1 = 0 ;
22729 int res1 = 0 ;
22730 PyObject * obj0 = 0 ;
22731 PyObject * obj1 = 0 ;
22732 PyObject * obj2 = 0 ;
22733 PyObject * obj3 = 0 ;
22734 char * kwnames[] = {
22735 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22736 };
22737
22738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22740 if (!SWIG_IsOK(res1)) {
22741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPolygonList" "', expected argument " "1"" of type '" "wxDC *""'");
22742 }
22743 arg1 = reinterpret_cast< wxDC * >(argp1);
22744 arg2 = obj1;
22745 arg3 = obj2;
22746 arg4 = obj3;
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
22750 wxPyEndAllowThreads(__tstate);
22751 if (PyErr_Occurred()) SWIG_fail;
22752 }
22753 resultobj = result;
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_DC__DrawTextList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj = 0;
22762 wxDC *arg1 = (wxDC *) 0 ;
22763 PyObject *arg2 = (PyObject *) 0 ;
22764 PyObject *arg3 = (PyObject *) 0 ;
22765 PyObject *arg4 = (PyObject *) 0 ;
22766 PyObject *arg5 = (PyObject *) 0 ;
22767 PyObject *result = 0 ;
22768 void *argp1 = 0 ;
22769 int res1 = 0 ;
22770 PyObject * obj0 = 0 ;
22771 PyObject * obj1 = 0 ;
22772 PyObject * obj2 = 0 ;
22773 PyObject * obj3 = 0 ;
22774 PyObject * obj4 = 0 ;
22775 char * kwnames[] = {
22776 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
22777 };
22778
22779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22781 if (!SWIG_IsOK(res1)) {
22782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawTextList" "', expected argument " "1"" of type '" "wxDC *""'");
22783 }
22784 arg1 = reinterpret_cast< wxDC * >(argp1);
22785 arg2 = obj1;
22786 arg3 = obj2;
22787 arg4 = obj3;
22788 arg5 = obj4;
22789 {
22790 PyThreadState* __tstate = wxPyBeginAllowThreads();
22791 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
22792 wxPyEndAllowThreads(__tstate);
22793 if (PyErr_Occurred()) SWIG_fail;
22794 }
22795 resultobj = result;
22796 return resultobj;
22797 fail:
22798 return NULL;
22799 }
22800
22801
22802 SWIGINTERN PyObject *DC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 PyObject *obj;
22804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22805 SWIG_TypeNewClientData(SWIGTYPE_p_wxDC, SWIG_NewClientData(obj));
22806 return SWIG_Py_Void();
22807 }
22808
22809 SWIGINTERN PyObject *_wrap_new_MemoryDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *resultobj = 0;
22811 wxMemoryDC *result = 0 ;
22812
22813 if (!SWIG_Python_UnpackTuple(args,"new_MemoryDC",0,0,0)) SWIG_fail;
22814 {
22815 if (!wxPyCheckForApp()) SWIG_fail;
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 result = (wxMemoryDC *)new wxMemoryDC();
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_NEW | 0 );
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 SWIGINTERN PyObject *_wrap_new_MemoryDCFromDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22829 PyObject *resultobj = 0;
22830 wxDC *arg1 = (wxDC *) 0 ;
22831 wxMemoryDC *result = 0 ;
22832 void *argp1 = 0 ;
22833 int res1 = 0 ;
22834 PyObject * obj0 = 0 ;
22835 char * kwnames[] = {
22836 (char *) "oldDC", NULL
22837 };
22838
22839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) SWIG_fail;
22840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22841 if (!SWIG_IsOK(res1)) {
22842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryDCFromDC" "', expected argument " "1"" of type '" "wxDC *""'");
22843 }
22844 arg1 = reinterpret_cast< wxDC * >(argp1);
22845 {
22846 if (!wxPyCheckForApp()) SWIG_fail;
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 result = (wxMemoryDC *)new wxMemoryDC(arg1);
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_OWN | 0 );
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_MemoryDC_SelectObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22860 PyObject *resultobj = 0;
22861 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
22862 wxBitmap *arg2 = 0 ;
22863 void *argp1 = 0 ;
22864 int res1 = 0 ;
22865 void *argp2 = 0 ;
22866 int res2 = 0 ;
22867 PyObject * obj0 = 0 ;
22868 PyObject * obj1 = 0 ;
22869 char * kwnames[] = {
22870 (char *) "self",(char *) "bitmap", NULL
22871 };
22872
22873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) SWIG_fail;
22874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryDC, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryDC_SelectObject" "', expected argument " "1"" of type '" "wxMemoryDC *""'");
22877 }
22878 arg1 = reinterpret_cast< wxMemoryDC * >(argp1);
22879 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
22880 if (!SWIG_IsOK(res2)) {
22881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22882 }
22883 if (!argp2) {
22884 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22885 }
22886 arg2 = reinterpret_cast< wxBitmap * >(argp2);
22887 {
22888 PyThreadState* __tstate = wxPyBeginAllowThreads();
22889 (arg1)->SelectObject((wxBitmap const &)*arg2);
22890 wxPyEndAllowThreads(__tstate);
22891 if (PyErr_Occurred()) SWIG_fail;
22892 }
22893 resultobj = SWIG_Py_Void();
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *MemoryDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 PyObject *obj;
22902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22903 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryDC, SWIG_NewClientData(obj));
22904 return SWIG_Py_Void();
22905 }
22906
22907 SWIGINTERN PyObject *MemoryDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22908 return SWIG_Python_InitShadowInstance(args);
22909 }
22910
22911 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
22912 PyObject *resultobj = 0;
22913 wxDC *arg1 = (wxDC *) 0 ;
22914 wxBitmap const &arg2_defvalue = wxNullBitmap ;
22915 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
22916 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
22917 wxBufferedDC *result = 0 ;
22918 void *argp1 = 0 ;
22919 int res1 = 0 ;
22920 void *argp2 = 0 ;
22921 int res2 = 0 ;
22922 int val3 ;
22923 int ecode3 = 0 ;
22924
22925 if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
22926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22927 if (!SWIG_IsOK(res1)) {
22928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
22929 }
22930 arg1 = reinterpret_cast< wxDC * >(argp1);
22931 if (swig_obj[1]) {
22932 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
22933 if (!SWIG_IsOK(res2)) {
22934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22935 }
22936 if (!argp2) {
22937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22938 }
22939 arg2 = reinterpret_cast< wxBitmap * >(argp2);
22940 }
22941 if (swig_obj[2]) {
22942 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
22943 if (!SWIG_IsOK(ecode3)) {
22944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
22945 }
22946 arg3 = static_cast< int >(val3);
22947 }
22948 {
22949 if (!wxPyCheckForApp()) SWIG_fail;
22950 PyThreadState* __tstate = wxPyBeginAllowThreads();
22951 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
22952 wxPyEndAllowThreads(__tstate);
22953 if (PyErr_Occurred()) SWIG_fail;
22954 }
22955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
22963 PyObject *resultobj = 0;
22964 wxDC *arg1 = (wxDC *) 0 ;
22965 wxSize *arg2 = 0 ;
22966 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
22967 wxBufferedDC *result = 0 ;
22968 void *argp1 = 0 ;
22969 int res1 = 0 ;
22970 wxSize temp2 ;
22971 int val3 ;
22972 int ecode3 = 0 ;
22973
22974 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
22975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22976 if (!SWIG_IsOK(res1)) {
22977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
22978 }
22979 arg1 = reinterpret_cast< wxDC * >(argp1);
22980 {
22981 arg2 = &temp2;
22982 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
22983 }
22984 if (swig_obj[2]) {
22985 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
22986 if (!SWIG_IsOK(ecode3)) {
22987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
22988 }
22989 arg3 = static_cast< int >(val3);
22990 }
22991 {
22992 if (!wxPyCheckForApp()) SWIG_fail;
22993 PyThreadState* __tstate = wxPyBeginAllowThreads();
22994 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 SWIGINTERN PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
23006 int argc;
23007 PyObject *argv[4];
23008
23009 if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferedDC",0,3,argv))) SWIG_fail;
23010 --argc;
23011 if ((argc >= 1) && (argc <= 3)) {
23012 int _v = 0;
23013 if (argc > 1) {
23014 {
23015 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxBitmap, 0);
23016 _v = SWIG_CheckState(res);
23017 }
23018 if (!_v) goto check_1;
23019 }
23020 return _wrap_new_BufferedDC__SWIG_0(self, argc, argv);
23021 }
23022 check_1:
23023
23024 if ((argc >= 2) && (argc <= 3)) {
23025 return _wrap_new_BufferedDC__SWIG_1(self, argc, argv);
23026 }
23027
23028 fail:
23029 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_delete_BufferedDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 PyObject *resultobj = 0;
23036 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 PyObject *swig_obj[1] ;
23040
23041 if (!args) SWIG_fail;
23042 swig_obj[0] = args;
23043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_DISOWN | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferedDC" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23046 }
23047 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 delete arg1;
23051
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_Py_Void();
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_BufferedDC_UnMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 PyObject *swig_obj[1] ;
23068
23069 if (!args) SWIG_fail;
23070 swig_obj[0] = args;
23071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, 0 | 0 );
23072 if (!SWIG_IsOK(res1)) {
23073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferedDC_UnMask" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23074 }
23075 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 (arg1)->UnMask();
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 resultobj = SWIG_Py_Void();
23083 return resultobj;
23084 fail:
23085 return NULL;
23086 }
23087
23088
23089 SWIGINTERN PyObject *BufferedDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23090 PyObject *obj;
23091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23092 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedDC, SWIG_NewClientData(obj));
23093 return SWIG_Py_Void();
23094 }
23095
23096 SWIGINTERN PyObject *BufferedDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23097 return SWIG_Python_InitShadowInstance(args);
23098 }
23099
23100 SWIGINTERN PyObject *_wrap_new_BufferedPaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23101 PyObject *resultobj = 0;
23102 wxWindow *arg1 = (wxWindow *) 0 ;
23103 wxBitmap const &arg2_defvalue = wxNullBitmap ;
23104 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
23105 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
23106 wxBufferedPaintDC *result = 0 ;
23107 void *argp1 = 0 ;
23108 int res1 = 0 ;
23109 void *argp2 = 0 ;
23110 int res2 = 0 ;
23111 int val3 ;
23112 int ecode3 = 0 ;
23113 PyObject * obj0 = 0 ;
23114 PyObject * obj1 = 0 ;
23115 PyObject * obj2 = 0 ;
23116 char * kwnames[] = {
23117 (char *) "window",(char *) "buffer",(char *) "style", NULL
23118 };
23119
23120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedPaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23124 }
23125 arg1 = reinterpret_cast< wxWindow * >(argp1);
23126 if (obj1) {
23127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23128 if (!SWIG_IsOK(res2)) {
23129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23130 }
23131 if (!argp2) {
23132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23133 }
23134 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23135 }
23136 if (obj2) {
23137 ecode3 = SWIG_AsVal_int(obj2, &val3);
23138 if (!SWIG_IsOK(ecode3)) {
23139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedPaintDC" "', expected argument " "3"" of type '" "int""'");
23140 }
23141 arg3 = static_cast< int >(val3);
23142 }
23143 {
23144 if (!wxPyCheckForApp()) SWIG_fail;
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
23147 wxPyEndAllowThreads(__tstate);
23148 if (PyErr_Occurred()) SWIG_fail;
23149 }
23150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedPaintDC, SWIG_POINTER_NEW | 0 );
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *BufferedPaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *obj;
23159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23160 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedPaintDC, SWIG_NewClientData(obj));
23161 return SWIG_Py_Void();
23162 }
23163
23164 SWIGINTERN PyObject *BufferedPaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23165 return SWIG_Python_InitShadowInstance(args);
23166 }
23167
23168 SWIGINTERN PyObject *_wrap_new_ScreenDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *resultobj = 0;
23170 wxScreenDC *result = 0 ;
23171
23172 if (!SWIG_Python_UnpackTuple(args,"new_ScreenDC",0,0,0)) SWIG_fail;
23173 {
23174 if (!wxPyCheckForApp()) SWIG_fail;
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (wxScreenDC *)new wxScreenDC();
23177 wxPyEndAllowThreads(__tstate);
23178 if (PyErr_Occurred()) SWIG_fail;
23179 }
23180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScreenDC, SWIG_POINTER_NEW | 0 );
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23188 PyObject *resultobj = 0;
23189 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23190 wxWindow *arg2 = (wxWindow *) 0 ;
23191 bool result;
23192 void *argp1 = 0 ;
23193 int res1 = 0 ;
23194 void *argp2 = 0 ;
23195 int res2 = 0 ;
23196 PyObject * obj0 = 0 ;
23197 PyObject * obj1 = 0 ;
23198 char * kwnames[] = {
23199 (char *) "self",(char *) "window", NULL
23200 };
23201
23202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) SWIG_fail;
23203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23204 if (!SWIG_IsOK(res1)) {
23205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23206 }
23207 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23209 if (!SWIG_IsOK(res2)) {
23210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "2"" of type '" "wxWindow *""'");
23211 }
23212 arg2 = reinterpret_cast< wxWindow * >(argp2);
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23221 }
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj = 0;
23230 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23231 wxRect *arg2 = (wxRect *) NULL ;
23232 bool result;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 void *argp2 = 0 ;
23236 int res2 = 0 ;
23237 PyObject * obj0 = 0 ;
23238 PyObject * obj1 = 0 ;
23239 char * kwnames[] = {
23240 (char *) "self",(char *) "rect", NULL
23241 };
23242
23243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) SWIG_fail;
23244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23245 if (!SWIG_IsOK(res1)) {
23246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23247 }
23248 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23249 if (obj1) {
23250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23251 if (!SWIG_IsOK(res2)) {
23252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "2"" of type '" "wxRect *""'");
23253 }
23254 arg2 = reinterpret_cast< wxRect * >(argp2);
23255 }
23256 {
23257 PyThreadState* __tstate = wxPyBeginAllowThreads();
23258 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23259 wxPyEndAllowThreads(__tstate);
23260 if (PyErr_Occurred()) SWIG_fail;
23261 }
23262 {
23263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23264 }
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 SWIGINTERN PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23272 PyObject *resultobj = 0;
23273 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23274 bool result;
23275 void *argp1 = 0 ;
23276 int res1 = 0 ;
23277 PyObject *swig_obj[1] ;
23278
23279 if (!args) SWIG_fail;
23280 swig_obj[0] = args;
23281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23282 if (!SWIG_IsOK(res1)) {
23283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_EndDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23284 }
23285 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)(arg1)->EndDrawingOnTop();
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23294 }
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 SWIGINTERN PyObject *ScreenDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23302 PyObject *obj;
23303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23304 SWIG_TypeNewClientData(SWIGTYPE_p_wxScreenDC, SWIG_NewClientData(obj));
23305 return SWIG_Py_Void();
23306 }
23307
23308 SWIGINTERN PyObject *ScreenDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23309 return SWIG_Python_InitShadowInstance(args);
23310 }
23311
23312 SWIGINTERN PyObject *_wrap_new_ClientDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj = 0;
23314 wxWindow *arg1 = (wxWindow *) 0 ;
23315 wxClientDC *result = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 PyObject * obj0 = 0 ;
23319 char * kwnames[] = {
23320 (char *) "win", NULL
23321 };
23322
23323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) SWIG_fail;
23324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23325 if (!SWIG_IsOK(res1)) {
23326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23327 }
23328 arg1 = reinterpret_cast< wxWindow * >(argp1);
23329 {
23330 if (!wxPyCheckForApp()) SWIG_fail;
23331 PyThreadState* __tstate = wxPyBeginAllowThreads();
23332 result = (wxClientDC *)new wxClientDC(arg1);
23333 wxPyEndAllowThreads(__tstate);
23334 if (PyErr_Occurred()) SWIG_fail;
23335 }
23336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClientDC, SWIG_POINTER_NEW | 0 );
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 SWIGINTERN PyObject *ClientDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23344 PyObject *obj;
23345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23346 SWIG_TypeNewClientData(SWIGTYPE_p_wxClientDC, SWIG_NewClientData(obj));
23347 return SWIG_Py_Void();
23348 }
23349
23350 SWIGINTERN PyObject *ClientDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23351 return SWIG_Python_InitShadowInstance(args);
23352 }
23353
23354 SWIGINTERN PyObject *_wrap_new_PaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23355 PyObject *resultobj = 0;
23356 wxWindow *arg1 = (wxWindow *) 0 ;
23357 wxPaintDC *result = 0 ;
23358 void *argp1 = 0 ;
23359 int res1 = 0 ;
23360 PyObject * obj0 = 0 ;
23361 char * kwnames[] = {
23362 (char *) "win", NULL
23363 };
23364
23365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) SWIG_fail;
23366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23367 if (!SWIG_IsOK(res1)) {
23368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23369 }
23370 arg1 = reinterpret_cast< wxWindow * >(argp1);
23371 {
23372 if (!wxPyCheckForApp()) SWIG_fail;
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 result = (wxPaintDC *)new wxPaintDC(arg1);
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintDC, SWIG_POINTER_NEW | 0 );
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 SWIGINTERN PyObject *PaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23386 PyObject *obj;
23387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23388 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintDC, SWIG_NewClientData(obj));
23389 return SWIG_Py_Void();
23390 }
23391
23392 SWIGINTERN PyObject *PaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 return SWIG_Python_InitShadowInstance(args);
23394 }
23395
23396 SWIGINTERN PyObject *_wrap_new_WindowDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj = 0;
23398 wxWindow *arg1 = (wxWindow *) 0 ;
23399 wxWindowDC *result = 0 ;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 PyObject * obj0 = 0 ;
23403 char * kwnames[] = {
23404 (char *) "win", NULL
23405 };
23406
23407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) SWIG_fail;
23408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23409 if (!SWIG_IsOK(res1)) {
23410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23411 }
23412 arg1 = reinterpret_cast< wxWindow * >(argp1);
23413 {
23414 if (!wxPyCheckForApp()) SWIG_fail;
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (wxWindowDC *)new wxWindowDC(arg1);
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDC, SWIG_POINTER_NEW | 0 );
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *WindowDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *obj;
23429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23430 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDC, SWIG_NewClientData(obj));
23431 return SWIG_Py_Void();
23432 }
23433
23434 SWIGINTERN PyObject *WindowDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 return SWIG_Python_InitShadowInstance(args);
23436 }
23437
23438 SWIGINTERN PyObject *_wrap_new_MirrorDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23439 PyObject *resultobj = 0;
23440 wxDC *arg1 = 0 ;
23441 bool arg2 ;
23442 wxMirrorDC *result = 0 ;
23443 void *argp1 = 0 ;
23444 int res1 = 0 ;
23445 bool val2 ;
23446 int ecode2 = 0 ;
23447 PyObject * obj0 = 0 ;
23448 PyObject * obj1 = 0 ;
23449 char * kwnames[] = {
23450 (char *) "dc",(char *) "mirror", NULL
23451 };
23452
23453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) SWIG_fail;
23454 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDC, 0 );
23455 if (!SWIG_IsOK(res1)) {
23456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
23457 }
23458 if (!argp1) {
23459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
23460 }
23461 arg1 = reinterpret_cast< wxDC * >(argp1);
23462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23463 if (!SWIG_IsOK(ecode2)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MirrorDC" "', expected argument " "2"" of type '" "bool""'");
23465 }
23466 arg2 = static_cast< bool >(val2);
23467 {
23468 if (!wxPyCheckForApp()) SWIG_fail;
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
23471 wxPyEndAllowThreads(__tstate);
23472 if (PyErr_Occurred()) SWIG_fail;
23473 }
23474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMirrorDC, SWIG_POINTER_NEW | 0 );
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *MirrorDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23482 PyObject *obj;
23483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23484 SWIG_TypeNewClientData(SWIGTYPE_p_wxMirrorDC, SWIG_NewClientData(obj));
23485 return SWIG_Py_Void();
23486 }
23487
23488 SWIGINTERN PyObject *MirrorDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23489 return SWIG_Python_InitShadowInstance(args);
23490 }
23491
23492 SWIGINTERN PyObject *_wrap_new_PostScriptDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 wxPrintData *arg1 = 0 ;
23495 wxPostScriptDC *result = 0 ;
23496 void *argp1 = 0 ;
23497 int res1 = 0 ;
23498 PyObject * obj0 = 0 ;
23499 char * kwnames[] = {
23500 (char *) "printData", NULL
23501 };
23502
23503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) SWIG_fail;
23504 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23507 }
23508 if (!argp1) {
23509 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23510 }
23511 arg1 = reinterpret_cast< wxPrintData * >(argp1);
23512 {
23513 if (!wxPyCheckForApp()) SWIG_fail;
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_NEW | 0 );
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 SWIGINTERN PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23527 PyObject *resultobj = 0;
23528 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
23529 wxPrintData *result = 0 ;
23530 void *argp1 = 0 ;
23531 int res1 = 0 ;
23532 PyObject *swig_obj[1] ;
23533
23534 if (!args) SWIG_fail;
23535 swig_obj[0] = args;
23536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
23537 if (!SWIG_IsOK(res1)) {
23538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_GetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
23539 }
23540 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 {
23544 wxPrintData &_result_ref = (arg1)->GetPrintData();
23545 result = (wxPrintData *) &_result_ref;
23546 }
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj = 0;
23559 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
23560 wxPrintData *arg2 = 0 ;
23561 void *argp1 = 0 ;
23562 int res1 = 0 ;
23563 void *argp2 = 0 ;
23564 int res2 = 0 ;
23565 PyObject * obj0 = 0 ;
23566 PyObject * obj1 = 0 ;
23567 char * kwnames[] = {
23568 (char *) "self",(char *) "data", NULL
23569 };
23570
23571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;
23572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
23573 if (!SWIG_IsOK(res1)) {
23574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
23575 }
23576 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
23577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);
23578 if (!SWIG_IsOK(res2)) {
23579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
23580 }
23581 if (!argp2) {
23582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
23583 }
23584 arg2 = reinterpret_cast< wxPrintData * >(argp2);
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 (arg1)->SetPrintData((wxPrintData const &)*arg2);
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 resultobj = SWIG_Py_Void();
23592 return resultobj;
23593 fail:
23594 return NULL;
23595 }
23596
23597
23598 SWIGINTERN PyObject *_wrap_PostScriptDC_SetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23599 PyObject *resultobj = 0;
23600 int arg1 ;
23601 int val1 ;
23602 int ecode1 = 0 ;
23603 PyObject * obj0 = 0 ;
23604 char * kwnames[] = {
23605 (char *) "ppi", NULL
23606 };
23607
23608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) SWIG_fail;
23609 ecode1 = SWIG_AsVal_int(obj0, &val1);
23610 if (!SWIG_IsOK(ecode1)) {
23611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PostScriptDC_SetResolution" "', expected argument " "1"" of type '" "int""'");
23612 }
23613 arg1 = static_cast< int >(val1);
23614 {
23615 PyThreadState* __tstate = wxPyBeginAllowThreads();
23616 wxPostScriptDC::SetResolution(arg1);
23617 wxPyEndAllowThreads(__tstate);
23618 if (PyErr_Occurred()) SWIG_fail;
23619 }
23620 resultobj = SWIG_Py_Void();
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 SWIGINTERN PyObject *_wrap_PostScriptDC_GetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23628 PyObject *resultobj = 0;
23629 int result;
23630
23631 if (!SWIG_Python_UnpackTuple(args,"PostScriptDC_GetResolution",0,0,0)) SWIG_fail;
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (int)wxPostScriptDC::GetResolution();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 resultobj = SWIG_From_int(static_cast< int >(result));
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 SWIGINTERN PyObject *PostScriptDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 PyObject *obj;
23647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23648 SWIG_TypeNewClientData(SWIGTYPE_p_wxPostScriptDC, SWIG_NewClientData(obj));
23649 return SWIG_Py_Void();
23650 }
23651
23652 SWIGINTERN PyObject *PostScriptDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23653 return SWIG_Python_InitShadowInstance(args);
23654 }
23655
23656 SWIGINTERN PyObject *_wrap_new_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23657 PyObject *resultobj = 0;
23658 wxString const &arg1_defvalue = wxPyEmptyString ;
23659 wxString *arg1 = (wxString *) &arg1_defvalue ;
23660 wxMetaFile *result = 0 ;
23661 bool temp1 = false ;
23662 PyObject * obj0 = 0 ;
23663 char * kwnames[] = {
23664 (char *) "filename", NULL
23665 };
23666
23667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) SWIG_fail;
23668 if (obj0) {
23669 {
23670 arg1 = wxString_in_helper(obj0);
23671 if (arg1 == NULL) SWIG_fail;
23672 temp1 = true;
23673 }
23674 }
23675 {
23676 if (!wxPyCheckForApp()) SWIG_fail;
23677 PyThreadState* __tstate = wxPyBeginAllowThreads();
23678 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, SWIG_POINTER_NEW | 0 );
23683 {
23684 if (temp1)
23685 delete arg1;
23686 }
23687 return resultobj;
23688 fail:
23689 {
23690 if (temp1)
23691 delete arg1;
23692 }
23693 return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *_wrap_delete_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698 PyObject *resultobj = 0;
23699 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23700 void *argp1 = 0 ;
23701 int res1 = 0 ;
23702 PyObject *swig_obj[1] ;
23703
23704 if (!args) SWIG_fail;
23705 swig_obj[0] = args;
23706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, SWIG_POINTER_DISOWN | 0 );
23707 if (!SWIG_IsOK(res1)) {
23708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaFile" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23709 }
23710 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 delete arg1;
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_Py_Void();
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 SWIGINTERN PyObject *_wrap_MetaFile_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23726 PyObject *resultobj = 0;
23727 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23728 bool result;
23729 void *argp1 = 0 ;
23730 int res1 = 0 ;
23731 PyObject *swig_obj[1] ;
23732
23733 if (!args) SWIG_fail;
23734 swig_obj[0] = args;
23735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_Ok" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23738 }
23739 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = (bool)(arg1)->Ok();
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 {
23747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23748 }
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *_wrap_MetaFile_SetClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23756 PyObject *resultobj = 0;
23757 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23758 int arg2 = (int) 0 ;
23759 int arg3 = (int) 0 ;
23760 bool result;
23761 void *argp1 = 0 ;
23762 int res1 = 0 ;
23763 int val2 ;
23764 int ecode2 = 0 ;
23765 int val3 ;
23766 int ecode3 = 0 ;
23767 PyObject * obj0 = 0 ;
23768 PyObject * obj1 = 0 ;
23769 PyObject * obj2 = 0 ;
23770 char * kwnames[] = {
23771 (char *) "self",(char *) "width",(char *) "height", NULL
23772 };
23773
23774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
23776 if (!SWIG_IsOK(res1)) {
23777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_SetClipboard" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23778 }
23779 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23780 if (obj1) {
23781 ecode2 = SWIG_AsVal_int(obj1, &val2);
23782 if (!SWIG_IsOK(ecode2)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MetaFile_SetClipboard" "', expected argument " "2"" of type '" "int""'");
23784 }
23785 arg2 = static_cast< int >(val2);
23786 }
23787 if (obj2) {
23788 ecode3 = SWIG_AsVal_int(obj2, &val3);
23789 if (!SWIG_IsOK(ecode3)) {
23790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MetaFile_SetClipboard" "', expected argument " "3"" of type '" "int""'");
23791 }
23792 arg3 = static_cast< int >(val3);
23793 }
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = (bool)(arg1)->SetClipboard(arg2,arg3);
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_MetaFile_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23812 wxSize result;
23813 void *argp1 = 0 ;
23814 int res1 = 0 ;
23815 PyObject *swig_obj[1] ;
23816
23817 if (!args) SWIG_fail;
23818 swig_obj[0] = args;
23819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
23820 if (!SWIG_IsOK(res1)) {
23821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetSize" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23822 }
23823 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (arg1)->GetSize();
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 SWIGINTERN PyObject *_wrap_MetaFile_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23838 PyObject *resultobj = 0;
23839 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23840 int result;
23841 void *argp1 = 0 ;
23842 int res1 = 0 ;
23843 PyObject *swig_obj[1] ;
23844
23845 if (!args) SWIG_fail;
23846 swig_obj[0] = args;
23847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
23848 if (!SWIG_IsOK(res1)) {
23849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetWidth" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23850 }
23851 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (int)(arg1)->GetWidth();
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_From_int(static_cast< int >(result));
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_MetaFile_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
23868 int result;
23869 void *argp1 = 0 ;
23870 int res1 = 0 ;
23871 PyObject *swig_obj[1] ;
23872
23873 if (!args) SWIG_fail;
23874 swig_obj[0] = args;
23875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetHeight" "', expected argument " "1"" of type '" "wxMetaFile *""'");
23878 }
23879 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (int)(arg1)->GetHeight();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_From_int(static_cast< int >(result));
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *MetaFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23894 PyObject *obj;
23895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23896 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFile, SWIG_NewClientData(obj));
23897 return SWIG_Py_Void();
23898 }
23899
23900 SWIGINTERN PyObject *MetaFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23901 return SWIG_Python_InitShadowInstance(args);
23902 }
23903
23904 SWIGINTERN PyObject *_wrap_new_MetaFileDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj = 0;
23906 wxString const &arg1_defvalue = wxPyEmptyString ;
23907 wxString *arg1 = (wxString *) &arg1_defvalue ;
23908 int arg2 = (int) 0 ;
23909 int arg3 = (int) 0 ;
23910 wxString const &arg4_defvalue = wxPyEmptyString ;
23911 wxString *arg4 = (wxString *) &arg4_defvalue ;
23912 wxMetaFileDC *result = 0 ;
23913 bool temp1 = false ;
23914 int val2 ;
23915 int ecode2 = 0 ;
23916 int val3 ;
23917 int ecode3 = 0 ;
23918 bool temp4 = false ;
23919 PyObject * obj0 = 0 ;
23920 PyObject * obj1 = 0 ;
23921 PyObject * obj2 = 0 ;
23922 PyObject * obj3 = 0 ;
23923 char * kwnames[] = {
23924 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
23925 };
23926
23927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23928 if (obj0) {
23929 {
23930 arg1 = wxString_in_helper(obj0);
23931 if (arg1 == NULL) SWIG_fail;
23932 temp1 = true;
23933 }
23934 }
23935 if (obj1) {
23936 ecode2 = SWIG_AsVal_int(obj1, &val2);
23937 if (!SWIG_IsOK(ecode2)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MetaFileDC" "', expected argument " "2"" of type '" "int""'");
23939 }
23940 arg2 = static_cast< int >(val2);
23941 }
23942 if (obj2) {
23943 ecode3 = SWIG_AsVal_int(obj2, &val3);
23944 if (!SWIG_IsOK(ecode3)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MetaFileDC" "', expected argument " "3"" of type '" "int""'");
23946 }
23947 arg3 = static_cast< int >(val3);
23948 }
23949 if (obj3) {
23950 {
23951 arg4 = wxString_in_helper(obj3);
23952 if (arg4 == NULL) SWIG_fail;
23953 temp4 = true;
23954 }
23955 }
23956 {
23957 if (!wxPyCheckForApp()) SWIG_fail;
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_NEW | 0 );
23964 {
23965 if (temp1)
23966 delete arg1;
23967 }
23968 {
23969 if (temp4)
23970 delete arg4;
23971 }
23972 return resultobj;
23973 fail:
23974 {
23975 if (temp1)
23976 delete arg1;
23977 }
23978 {
23979 if (temp4)
23980 delete arg4;
23981 }
23982 return NULL;
23983 }
23984
23985
23986 SWIGINTERN PyObject *_wrap_MetaFileDC_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23987 PyObject *resultobj = 0;
23988 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
23989 wxMetaFile *result = 0 ;
23990 void *argp1 = 0 ;
23991 int res1 = 0 ;
23992 PyObject *swig_obj[1] ;
23993
23994 if (!args) SWIG_fail;
23995 swig_obj[0] = args;
23996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFileDC, 0 | 0 );
23997 if (!SWIG_IsOK(res1)) {
23998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFileDC_Close" "', expected argument " "1"" of type '" "wxMetaFileDC *""'");
23999 }
24000 arg1 = reinterpret_cast< wxMetaFileDC * >(argp1);
24001 {
24002 PyThreadState* __tstate = wxPyBeginAllowThreads();
24003 result = (wxMetaFile *)(arg1)->Close();
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, 0 | 0 );
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 SWIGINTERN PyObject *MetaFileDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24015 PyObject *obj;
24016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24017 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFileDC, SWIG_NewClientData(obj));
24018 return SWIG_Py_Void();
24019 }
24020
24021 SWIGINTERN PyObject *MetaFileDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 return SWIG_Python_InitShadowInstance(args);
24023 }
24024
24025 SWIGINTERN PyObject *_wrap_new_PrinterDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24026 PyObject *resultobj = 0;
24027 wxPrintData *arg1 = 0 ;
24028 wxPrinterDC *result = 0 ;
24029 void *argp1 = 0 ;
24030 int res1 = 0 ;
24031 PyObject * obj0 = 0 ;
24032 char * kwnames[] = {
24033 (char *) "printData", NULL
24034 };
24035
24036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) SWIG_fail;
24037 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
24038 if (!SWIG_IsOK(res1)) {
24039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24040 }
24041 if (!argp1) {
24042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24043 }
24044 arg1 = reinterpret_cast< wxPrintData * >(argp1);
24045 {
24046 if (!wxPyCheckForApp()) SWIG_fail;
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrinterDC, SWIG_POINTER_NEW | 0 );
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 SWIGINTERN PyObject *PrinterDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24060 PyObject *obj;
24061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24062 SWIG_TypeNewClientData(SWIGTYPE_p_wxPrinterDC, SWIG_NewClientData(obj));
24063 return SWIG_Py_Void();
24064 }
24065
24066 SWIGINTERN PyObject *PrinterDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24067 return SWIG_Python_InitShadowInstance(args);
24068 }
24069
24070 SWIGINTERN PyObject *_wrap_new_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24071 PyObject *resultobj = 0;
24072 int arg1 ;
24073 int arg2 ;
24074 int arg3 = (int) true ;
24075 int arg4 = (int) 1 ;
24076 wxImageList *result = 0 ;
24077 int val1 ;
24078 int ecode1 = 0 ;
24079 int val2 ;
24080 int ecode2 = 0 ;
24081 int val3 ;
24082 int ecode3 = 0 ;
24083 int val4 ;
24084 int ecode4 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 PyObject * obj2 = 0 ;
24088 PyObject * obj3 = 0 ;
24089 char * kwnames[] = {
24090 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
24091 };
24092
24093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24094 ecode1 = SWIG_AsVal_int(obj0, &val1);
24095 if (!SWIG_IsOK(ecode1)) {
24096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageList" "', expected argument " "1"" of type '" "int""'");
24097 }
24098 arg1 = static_cast< int >(val1);
24099 ecode2 = SWIG_AsVal_int(obj1, &val2);
24100 if (!SWIG_IsOK(ecode2)) {
24101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageList" "', expected argument " "2"" of type '" "int""'");
24102 }
24103 arg2 = static_cast< int >(val2);
24104 if (obj2) {
24105 ecode3 = SWIG_AsVal_int(obj2, &val3);
24106 if (!SWIG_IsOK(ecode3)) {
24107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageList" "', expected argument " "3"" of type '" "int""'");
24108 }
24109 arg3 = static_cast< int >(val3);
24110 }
24111 if (obj3) {
24112 ecode4 = SWIG_AsVal_int(obj3, &val4);
24113 if (!SWIG_IsOK(ecode4)) {
24114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImageList" "', expected argument " "4"" of type '" "int""'");
24115 }
24116 arg4 = static_cast< int >(val4);
24117 }
24118 {
24119 if (!wxPyCheckForApp()) SWIG_fail;
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 {
24126 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
24127 }
24128 return resultobj;
24129 fail:
24130 return NULL;
24131 }
24132
24133
24134 SWIGINTERN PyObject *_wrap_delete_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24135 PyObject *resultobj = 0;
24136 wxImageList *arg1 = (wxImageList *) 0 ;
24137 void *argp1 = 0 ;
24138 int res1 = 0 ;
24139 PyObject *swig_obj[1] ;
24140
24141 if (!args) SWIG_fail;
24142 swig_obj[0] = args;
24143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN | 0 );
24144 if (!SWIG_IsOK(res1)) {
24145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageList" "', expected argument " "1"" of type '" "wxImageList *""'");
24146 }
24147 arg1 = reinterpret_cast< wxImageList * >(argp1);
24148 {
24149 PyThreadState* __tstate = wxPyBeginAllowThreads();
24150 delete arg1;
24151
24152 wxPyEndAllowThreads(__tstate);
24153 if (PyErr_Occurred()) SWIG_fail;
24154 }
24155 resultobj = SWIG_Py_Void();
24156 return resultobj;
24157 fail:
24158 return NULL;
24159 }
24160
24161
24162 SWIGINTERN PyObject *_wrap_ImageList_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24163 PyObject *resultobj = 0;
24164 wxImageList *arg1 = (wxImageList *) 0 ;
24165 wxBitmap *arg2 = 0 ;
24166 wxBitmap const &arg3_defvalue = wxNullBitmap ;
24167 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
24168 int result;
24169 void *argp1 = 0 ;
24170 int res1 = 0 ;
24171 void *argp2 = 0 ;
24172 int res2 = 0 ;
24173 void *argp3 = 0 ;
24174 int res3 = 0 ;
24175 PyObject * obj0 = 0 ;
24176 PyObject * obj1 = 0 ;
24177 PyObject * obj2 = 0 ;
24178 char * kwnames[] = {
24179 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
24180 };
24181
24182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Add" "', expected argument " "1"" of type '" "wxImageList *""'");
24186 }
24187 arg1 = reinterpret_cast< wxImageList * >(argp1);
24188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
24189 if (!SWIG_IsOK(res2)) {
24190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24191 }
24192 if (!argp2) {
24193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24194 }
24195 arg2 = reinterpret_cast< wxBitmap * >(argp2);
24196 if (obj2) {
24197 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
24198 if (!SWIG_IsOK(res3)) {
24199 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24200 }
24201 if (!argp3) {
24202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24203 }
24204 arg3 = reinterpret_cast< wxBitmap * >(argp3);
24205 }
24206 {
24207 PyThreadState* __tstate = wxPyBeginAllowThreads();
24208 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
24209 wxPyEndAllowThreads(__tstate);
24210 if (PyErr_Occurred()) SWIG_fail;
24211 }
24212 resultobj = SWIG_From_int(static_cast< int >(result));
24213 return resultobj;
24214 fail:
24215 return NULL;
24216 }
24217
24218
24219 SWIGINTERN PyObject *_wrap_ImageList_AddWithColourMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24220 PyObject *resultobj = 0;
24221 wxImageList *arg1 = (wxImageList *) 0 ;
24222 wxBitmap *arg2 = 0 ;
24223 wxColour *arg3 = 0 ;
24224 int result;
24225 void *argp1 = 0 ;
24226 int res1 = 0 ;
24227 void *argp2 = 0 ;
24228 int res2 = 0 ;
24229 wxColour temp3 ;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 PyObject * obj2 = 0 ;
24233 char * kwnames[] = {
24234 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
24235 };
24236
24237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24239 if (!SWIG_IsOK(res1)) {
24240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddWithColourMask" "', expected argument " "1"" of type '" "wxImageList *""'");
24241 }
24242 arg1 = reinterpret_cast< wxImageList * >(argp1);
24243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
24244 if (!SWIG_IsOK(res2)) {
24245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24246 }
24247 if (!argp2) {
24248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24249 }
24250 arg2 = reinterpret_cast< wxBitmap * >(argp2);
24251 {
24252 arg3 = &temp3;
24253 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
24254 }
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
24258 wxPyEndAllowThreads(__tstate);
24259 if (PyErr_Occurred()) SWIG_fail;
24260 }
24261 resultobj = SWIG_From_int(static_cast< int >(result));
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 SWIGINTERN PyObject *_wrap_ImageList_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24269 PyObject *resultobj = 0;
24270 wxImageList *arg1 = (wxImageList *) 0 ;
24271 wxIcon *arg2 = 0 ;
24272 int result;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 void *argp2 = 0 ;
24276 int res2 = 0 ;
24277 PyObject * obj0 = 0 ;
24278 PyObject * obj1 = 0 ;
24279 char * kwnames[] = {
24280 (char *) "self",(char *) "icon", NULL
24281 };
24282
24283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
24284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24285 if (!SWIG_IsOK(res1)) {
24286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddIcon" "', expected argument " "1"" of type '" "wxImageList *""'");
24287 }
24288 arg1 = reinterpret_cast< wxImageList * >(argp1);
24289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
24290 if (!SWIG_IsOK(res2)) {
24291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
24292 }
24293 if (!argp2) {
24294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
24295 }
24296 arg2 = reinterpret_cast< wxIcon * >(argp2);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (int)(arg1)->Add((wxIcon const &)*arg2);
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 resultobj = SWIG_From_int(static_cast< int >(result));
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_ImageList_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24311 PyObject *resultobj = 0;
24312 wxImageList *arg1 = (wxImageList *) 0 ;
24313 int arg2 ;
24314 SwigValueWrapper<wxBitmap > result;
24315 void *argp1 = 0 ;
24316 int res1 = 0 ;
24317 int val2 ;
24318 int ecode2 = 0 ;
24319 PyObject * obj0 = 0 ;
24320 PyObject * obj1 = 0 ;
24321 char * kwnames[] = {
24322 (char *) "self",(char *) "index", NULL
24323 };
24324
24325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
24326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24327 if (!SWIG_IsOK(res1)) {
24328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetBitmap" "', expected argument " "1"" of type '" "wxImageList const *""'");
24329 }
24330 arg1 = reinterpret_cast< wxImageList * >(argp1);
24331 ecode2 = SWIG_AsVal_int(obj1, &val2);
24332 if (!SWIG_IsOK(ecode2)) {
24333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetBitmap" "', expected argument " "2"" of type '" "int""'");
24334 }
24335 arg2 = static_cast< int >(val2);
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
24339 wxPyEndAllowThreads(__tstate);
24340 if (PyErr_Occurred()) SWIG_fail;
24341 }
24342 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_ImageList_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj = 0;
24351 wxImageList *arg1 = (wxImageList *) 0 ;
24352 int arg2 ;
24353 wxIcon result;
24354 void *argp1 = 0 ;
24355 int res1 = 0 ;
24356 int val2 ;
24357 int ecode2 = 0 ;
24358 PyObject * obj0 = 0 ;
24359 PyObject * obj1 = 0 ;
24360 char * kwnames[] = {
24361 (char *) "self",(char *) "index", NULL
24362 };
24363
24364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
24365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetIcon" "', expected argument " "1"" of type '" "wxImageList const *""'");
24368 }
24369 arg1 = reinterpret_cast< wxImageList * >(argp1);
24370 ecode2 = SWIG_AsVal_int(obj1, &val2);
24371 if (!SWIG_IsOK(ecode2)) {
24372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetIcon" "', expected argument " "2"" of type '" "int""'");
24373 }
24374 arg2 = static_cast< int >(val2);
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 result = ((wxImageList const *)arg1)->GetIcon(arg2);
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_ImageList_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24389 PyObject *resultobj = 0;
24390 wxImageList *arg1 = (wxImageList *) 0 ;
24391 int arg2 ;
24392 wxBitmap *arg3 = 0 ;
24393 wxBitmap const &arg4_defvalue = wxNullBitmap ;
24394 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
24395 bool result;
24396 void *argp1 = 0 ;
24397 int res1 = 0 ;
24398 int val2 ;
24399 int ecode2 = 0 ;
24400 void *argp3 = 0 ;
24401 int res3 = 0 ;
24402 void *argp4 = 0 ;
24403 int res4 = 0 ;
24404 PyObject * obj0 = 0 ;
24405 PyObject * obj1 = 0 ;
24406 PyObject * obj2 = 0 ;
24407 PyObject * obj3 = 0 ;
24408 char * kwnames[] = {
24409 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
24410 };
24411
24412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Replace" "', expected argument " "1"" of type '" "wxImageList *""'");
24416 }
24417 arg1 = reinterpret_cast< wxImageList * >(argp1);
24418 ecode2 = SWIG_AsVal_int(obj1, &val2);
24419 if (!SWIG_IsOK(ecode2)) {
24420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Replace" "', expected argument " "2"" of type '" "int""'");
24421 }
24422 arg2 = static_cast< int >(val2);
24423 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
24424 if (!SWIG_IsOK(res3)) {
24425 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24426 }
24427 if (!argp3) {
24428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24429 }
24430 arg3 = reinterpret_cast< wxBitmap * >(argp3);
24431 if (obj3) {
24432 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 | 0);
24433 if (!SWIG_IsOK(res4)) {
24434 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
24435 }
24436 if (!argp4) {
24437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
24438 }
24439 arg4 = reinterpret_cast< wxBitmap * >(argp4);
24440 }
24441 {
24442 PyThreadState* __tstate = wxPyBeginAllowThreads();
24443 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
24444 wxPyEndAllowThreads(__tstate);
24445 if (PyErr_Occurred()) SWIG_fail;
24446 }
24447 {
24448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24449 }
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 SWIGINTERN PyObject *_wrap_ImageList_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24457 PyObject *resultobj = 0;
24458 wxImageList *arg1 = (wxImageList *) 0 ;
24459 int arg2 ;
24460 wxDC *arg3 = 0 ;
24461 int arg4 ;
24462 int arg5 ;
24463 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
24464 bool arg7 = (bool) (bool)false ;
24465 bool result;
24466 void *argp1 = 0 ;
24467 int res1 = 0 ;
24468 int val2 ;
24469 int ecode2 = 0 ;
24470 void *argp3 = 0 ;
24471 int res3 = 0 ;
24472 int val4 ;
24473 int ecode4 = 0 ;
24474 int val5 ;
24475 int ecode5 = 0 ;
24476 int val6 ;
24477 int ecode6 = 0 ;
24478 bool val7 ;
24479 int ecode7 = 0 ;
24480 PyObject * obj0 = 0 ;
24481 PyObject * obj1 = 0 ;
24482 PyObject * obj2 = 0 ;
24483 PyObject * obj3 = 0 ;
24484 PyObject * obj4 = 0 ;
24485 PyObject * obj5 = 0 ;
24486 PyObject * obj6 = 0 ;
24487 char * kwnames[] = {
24488 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
24489 };
24490
24491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24493 if (!SWIG_IsOK(res1)) {
24494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Draw" "', expected argument " "1"" of type '" "wxImageList *""'");
24495 }
24496 arg1 = reinterpret_cast< wxImageList * >(argp1);
24497 ecode2 = SWIG_AsVal_int(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Draw" "', expected argument " "2"" of type '" "int""'");
24500 }
24501 arg2 = static_cast< int >(val2);
24502 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24503 if (!SWIG_IsOK(res3)) {
24504 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
24505 }
24506 if (!argp3) {
24507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
24508 }
24509 arg3 = reinterpret_cast< wxDC * >(argp3);
24510 ecode4 = SWIG_AsVal_int(obj3, &val4);
24511 if (!SWIG_IsOK(ecode4)) {
24512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageList_Draw" "', expected argument " "4"" of type '" "int""'");
24513 }
24514 arg4 = static_cast< int >(val4);
24515 ecode5 = SWIG_AsVal_int(obj4, &val5);
24516 if (!SWIG_IsOK(ecode5)) {
24517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageList_Draw" "', expected argument " "5"" of type '" "int""'");
24518 }
24519 arg5 = static_cast< int >(val5);
24520 if (obj5) {
24521 ecode6 = SWIG_AsVal_int(obj5, &val6);
24522 if (!SWIG_IsOK(ecode6)) {
24523 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageList_Draw" "', expected argument " "6"" of type '" "int""'");
24524 }
24525 arg6 = static_cast< int >(val6);
24526 }
24527 if (obj6) {
24528 ecode7 = SWIG_AsVal_bool(obj6, &val7);
24529 if (!SWIG_IsOK(ecode7)) {
24530 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageList_Draw" "', expected argument " "7"" of type '" "bool""'");
24531 }
24532 arg7 = static_cast< bool >(val7);
24533 }
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 {
24541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24542 }
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 SWIGINTERN PyObject *_wrap_ImageList_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24550 PyObject *resultobj = 0;
24551 wxImageList *arg1 = (wxImageList *) 0 ;
24552 int result;
24553 void *argp1 = 0 ;
24554 int res1 = 0 ;
24555 PyObject *swig_obj[1] ;
24556
24557 if (!args) SWIG_fail;
24558 swig_obj[0] = args;
24559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24560 if (!SWIG_IsOK(res1)) {
24561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetImageCount" "', expected argument " "1"" of type '" "wxImageList *""'");
24562 }
24563 arg1 = reinterpret_cast< wxImageList * >(argp1);
24564 {
24565 PyThreadState* __tstate = wxPyBeginAllowThreads();
24566 result = (int)(arg1)->GetImageCount();
24567 wxPyEndAllowThreads(__tstate);
24568 if (PyErr_Occurred()) SWIG_fail;
24569 }
24570 resultobj = SWIG_From_int(static_cast< int >(result));
24571 return resultobj;
24572 fail:
24573 return NULL;
24574 }
24575
24576
24577 SWIGINTERN PyObject *_wrap_ImageList_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24578 PyObject *resultobj = 0;
24579 wxImageList *arg1 = (wxImageList *) 0 ;
24580 int arg2 ;
24581 bool result;
24582 void *argp1 = 0 ;
24583 int res1 = 0 ;
24584 int val2 ;
24585 int ecode2 = 0 ;
24586 PyObject * obj0 = 0 ;
24587 PyObject * obj1 = 0 ;
24588 char * kwnames[] = {
24589 (char *) "self",(char *) "index", NULL
24590 };
24591
24592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
24593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Remove" "', expected argument " "1"" of type '" "wxImageList *""'");
24596 }
24597 arg1 = reinterpret_cast< wxImageList * >(argp1);
24598 ecode2 = SWIG_AsVal_int(obj1, &val2);
24599 if (!SWIG_IsOK(ecode2)) {
24600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Remove" "', expected argument " "2"" of type '" "int""'");
24601 }
24602 arg2 = static_cast< int >(val2);
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (bool)(arg1)->Remove(arg2);
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 {
24610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24611 }
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_ImageList_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24619 PyObject *resultobj = 0;
24620 wxImageList *arg1 = (wxImageList *) 0 ;
24621 bool result;
24622 void *argp1 = 0 ;
24623 int res1 = 0 ;
24624 PyObject *swig_obj[1] ;
24625
24626 if (!args) SWIG_fail;
24627 swig_obj[0] = args;
24628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24629 if (!SWIG_IsOK(res1)) {
24630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_RemoveAll" "', expected argument " "1"" of type '" "wxImageList *""'");
24631 }
24632 arg1 = reinterpret_cast< wxImageList * >(argp1);
24633 {
24634 PyThreadState* __tstate = wxPyBeginAllowThreads();
24635 result = (bool)(arg1)->RemoveAll();
24636 wxPyEndAllowThreads(__tstate);
24637 if (PyErr_Occurred()) SWIG_fail;
24638 }
24639 {
24640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24641 }
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_ImageList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = 0;
24650 wxImageList *arg1 = (wxImageList *) 0 ;
24651 int arg2 ;
24652 int *arg3 = 0 ;
24653 int *arg4 = 0 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 int temp3 ;
24659 int res3 = SWIG_TMPOBJ ;
24660 int temp4 ;
24661 int res4 = SWIG_TMPOBJ ;
24662 PyObject * obj0 = 0 ;
24663 PyObject * obj1 = 0 ;
24664 char * kwnames[] = {
24665 (char *) "self",(char *) "index", NULL
24666 };
24667
24668 arg3 = &temp3;
24669 arg4 = &temp4;
24670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
24671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24672 if (!SWIG_IsOK(res1)) {
24673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetSize" "', expected argument " "1"" of type '" "wxImageList *""'");
24674 }
24675 arg1 = reinterpret_cast< wxImageList * >(argp1);
24676 ecode2 = SWIG_AsVal_int(obj1, &val2);
24677 if (!SWIG_IsOK(ecode2)) {
24678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetSize" "', expected argument " "2"" of type '" "int""'");
24679 }
24680 arg2 = static_cast< int >(val2);
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 (arg1)->GetSize(arg2,*arg3,*arg4);
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 resultobj = SWIG_Py_Void();
24688 if (SWIG_IsTmpObj(res3)) {
24689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
24690 } else {
24691 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
24693 }
24694 if (SWIG_IsTmpObj(res4)) {
24695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
24696 } else {
24697 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
24699 }
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 SWIGINTERN PyObject *ImageList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24707 PyObject *obj;
24708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24709 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageList, SWIG_NewClientData(obj));
24710 return SWIG_Py_Void();
24711 }
24712
24713 SWIGINTERN PyObject *ImageList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24714 return SWIG_Python_InitShadowInstance(args);
24715 }
24716
24717 SWIGINTERN PyObject *_wrap_new_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24718 PyObject *resultobj = 0;
24719 wxStockGDI *result = 0 ;
24720
24721 if (!SWIG_Python_UnpackTuple(args,"new_StockGDI",0,0,0)) SWIG_fail;
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 result = (wxStockGDI *)new wxStockGDI();
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, SWIG_POINTER_NEW | 0 );
24729 return resultobj;
24730 fail:
24731 return NULL;
24732 }
24733
24734
24735 SWIGINTERN PyObject *_wrap_delete_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 PyObject *resultobj = 0;
24737 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
24738 void *argp1 = 0 ;
24739 int res1 = 0 ;
24740 PyObject *swig_obj[1] ;
24741
24742 if (!args) SWIG_fail;
24743 swig_obj[0] = args;
24744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStockGDI, SWIG_POINTER_DISOWN | 0 );
24745 if (!SWIG_IsOK(res1)) {
24746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StockGDI" "', expected argument " "1"" of type '" "wxStockGDI *""'");
24747 }
24748 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 delete arg1;
24752
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 resultobj = SWIG_Py_Void();
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 SWIGINTERN PyObject *_wrap_StockGDI_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24764 PyObject *resultobj = 0;
24765
24766 if (!SWIG_Python_UnpackTuple(args,"StockGDI_DeleteAll",0,0,0)) SWIG_fail;
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 wxStockGDI::DeleteAll();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 resultobj = SWIG_Py_Void();
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_StockGDI_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24781 PyObject *resultobj = 0;
24782 wxStockGDI *result = 0 ;
24783
24784 if (!SWIG_Python_UnpackTuple(args,"StockGDI_instance",0,0,0)) SWIG_fail;
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 {
24788 wxStockGDI &_result_ref = wxStockGDI::instance();
24789 result = (wxStockGDI *) &_result_ref;
24790 }
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, 0 | 0 );
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 SWIGINTERN PyObject *_wrap_StockGDI_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj = 0;
24803 wxStockGDI::Item arg1 ;
24804 wxBrush *result = 0 ;
24805 int val1 ;
24806 int ecode1 = 0 ;
24807 PyObject * obj0 = 0 ;
24808 char * kwnames[] = {
24809 (char *) "item", NULL
24810 };
24811
24812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetBrush",kwnames,&obj0)) SWIG_fail;
24813 ecode1 = SWIG_AsVal_int(obj0, &val1);
24814 if (!SWIG_IsOK(ecode1)) {
24815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetBrush" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24816 }
24817 arg1 = static_cast< wxStockGDI::Item >(val1);
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 result = (wxBrush *)wxStockGDI::GetBrush(arg1);
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_StockGDI_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = 0;
24833 wxStockGDI::Item arg1 ;
24834 wxColour *result = 0 ;
24835 int val1 ;
24836 int ecode1 = 0 ;
24837 PyObject * obj0 = 0 ;
24838 char * kwnames[] = {
24839 (char *) "item", NULL
24840 };
24841
24842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetColour",kwnames,&obj0)) SWIG_fail;
24843 ecode1 = SWIG_AsVal_int(obj0, &val1);
24844 if (!SWIG_IsOK(ecode1)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetColour" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24846 }
24847 arg1 = static_cast< wxStockGDI::Item >(val1);
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (wxColour *)wxStockGDI::GetColour(arg1);
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_StockGDI_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj = 0;
24863 wxStockGDI::Item arg1 ;
24864 wxCursor *result = 0 ;
24865 int val1 ;
24866 int ecode1 = 0 ;
24867 PyObject * obj0 = 0 ;
24868 char * kwnames[] = {
24869 (char *) "item", NULL
24870 };
24871
24872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetCursor",kwnames,&obj0)) SWIG_fail;
24873 ecode1 = SWIG_AsVal_int(obj0, &val1);
24874 if (!SWIG_IsOK(ecode1)) {
24875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetCursor" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24876 }
24877 arg1 = static_cast< wxStockGDI::Item >(val1);
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 result = (wxCursor *)wxStockGDI::GetCursor(arg1);
24881 wxPyEndAllowThreads(__tstate);
24882 if (PyErr_Occurred()) SWIG_fail;
24883 }
24884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, 0 | 0 );
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_StockGDI_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24892 PyObject *resultobj = 0;
24893 wxStockGDI::Item arg1 ;
24894 wxPen *result = 0 ;
24895 int val1 ;
24896 int ecode1 = 0 ;
24897 PyObject * obj0 = 0 ;
24898 char * kwnames[] = {
24899 (char *) "item", NULL
24900 };
24901
24902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetPen",kwnames,&obj0)) SWIG_fail;
24903 ecode1 = SWIG_AsVal_int(obj0, &val1);
24904 if (!SWIG_IsOK(ecode1)) {
24905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetPen" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24906 }
24907 arg1 = static_cast< wxStockGDI::Item >(val1);
24908 {
24909 PyThreadState* __tstate = wxPyBeginAllowThreads();
24910 result = (wxPen *)wxStockGDI::GetPen(arg1);
24911 wxPyEndAllowThreads(__tstate);
24912 if (PyErr_Occurred()) SWIG_fail;
24913 }
24914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_StockGDI_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24922 PyObject *resultobj = 0;
24923 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
24924 wxStockGDI::Item arg2 ;
24925 wxFont *result = 0 ;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 int val2 ;
24929 int ecode2 = 0 ;
24930 PyObject * obj0 = 0 ;
24931 PyObject * obj1 = 0 ;
24932 char * kwnames[] = {
24933 (char *) "self",(char *) "item", NULL
24934 };
24935
24936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StockGDI_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
24937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStockGDI, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StockGDI_GetFont" "', expected argument " "1"" of type '" "wxStockGDI *""'");
24940 }
24941 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
24942 ecode2 = SWIG_AsVal_int(obj1, &val2);
24943 if (!SWIG_IsOK(ecode2)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StockGDI_GetFont" "', expected argument " "2"" of type '" "wxStockGDI::Item""'");
24945 }
24946 arg2 = static_cast< wxStockGDI::Item >(val2);
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (wxFont *)(arg1)->GetFont(arg2);
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 SWIGINTERN PyObject *StockGDI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24961 PyObject *obj;
24962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24963 SWIG_TypeNewClientData(SWIGTYPE_p_wxStockGDI, SWIG_NewClientData(obj));
24964 return SWIG_Py_Void();
24965 }
24966
24967 SWIGINTERN PyObject *StockGDI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24968 return SWIG_Python_InitShadowInstance(args);
24969 }
24970
24971 SWIGINTERN int NullBitmap_set(PyObject *) {
24972 SWIG_Error(SWIG_AttributeError,"Variable NullBitmap is read-only.");
24973 return 1;
24974 }
24975
24976
24977 SWIGINTERN PyObject *NullBitmap_get(void) {
24978 PyObject *pyobj = 0;
24979
24980 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0 );
24981 return pyobj;
24982 }
24983
24984
24985 SWIGINTERN int NullIcon_set(PyObject *) {
24986 SWIG_Error(SWIG_AttributeError,"Variable NullIcon is read-only.");
24987 return 1;
24988 }
24989
24990
24991 SWIGINTERN PyObject *NullIcon_get(void) {
24992 PyObject *pyobj = 0;
24993
24994 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullIcon), SWIGTYPE_p_wxIcon, 0 );
24995 return pyobj;
24996 }
24997
24998
24999 SWIGINTERN int NullCursor_set(PyObject *) {
25000 SWIG_Error(SWIG_AttributeError,"Variable NullCursor is read-only.");
25001 return 1;
25002 }
25003
25004
25005 SWIGINTERN PyObject *NullCursor_get(void) {
25006 PyObject *pyobj = 0;
25007
25008 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullCursor), SWIGTYPE_p_wxCursor, 0 );
25009 return pyobj;
25010 }
25011
25012
25013 SWIGINTERN int NullPen_set(PyObject *) {
25014 SWIG_Error(SWIG_AttributeError,"Variable NullPen is read-only.");
25015 return 1;
25016 }
25017
25018
25019 SWIGINTERN PyObject *NullPen_get(void) {
25020 PyObject *pyobj = 0;
25021
25022 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPen), SWIGTYPE_p_wxPen, 0 );
25023 return pyobj;
25024 }
25025
25026
25027 SWIGINTERN int NullBrush_set(PyObject *) {
25028 SWIG_Error(SWIG_AttributeError,"Variable NullBrush is read-only.");
25029 return 1;
25030 }
25031
25032
25033 SWIGINTERN PyObject *NullBrush_get(void) {
25034 PyObject *pyobj = 0;
25035
25036 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBrush), SWIGTYPE_p_wxBrush, 0 );
25037 return pyobj;
25038 }
25039
25040
25041 SWIGINTERN int NullPalette_set(PyObject *) {
25042 SWIG_Error(SWIG_AttributeError,"Variable NullPalette is read-only.");
25043 return 1;
25044 }
25045
25046
25047 SWIGINTERN PyObject *NullPalette_get(void) {
25048 PyObject *pyobj = 0;
25049
25050 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPalette), SWIGTYPE_p_wxPalette, 0 );
25051 return pyobj;
25052 }
25053
25054
25055 SWIGINTERN int NullFont_set(PyObject *) {
25056 SWIG_Error(SWIG_AttributeError,"Variable NullFont is read-only.");
25057 return 1;
25058 }
25059
25060
25061 SWIGINTERN PyObject *NullFont_get(void) {
25062 PyObject *pyobj = 0;
25063
25064 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullFont), SWIGTYPE_p_wxFont, 0 );
25065 return pyobj;
25066 }
25067
25068
25069 SWIGINTERN int NullColour_set(PyObject *) {
25070 SWIG_Error(SWIG_AttributeError,"Variable NullColour is read-only.");
25071 return 1;
25072 }
25073
25074
25075 SWIGINTERN PyObject *NullColour_get(void) {
25076 PyObject *pyobj = 0;
25077
25078 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullColour), SWIGTYPE_p_wxColour, 0 );
25079 return pyobj;
25080 }
25081
25082
25083 SWIGINTERN PyObject *_wrap_new_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25084 PyObject *resultobj = 0;
25085 wxGDIObjListBase *result = 0 ;
25086
25087 if (!SWIG_Python_UnpackTuple(args,"new_GDIObjListBase",0,0,0)) SWIG_fail;
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (wxGDIObjListBase *)new wxGDIObjListBase();
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_NEW | 0 );
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *_wrap_delete_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *resultobj = 0;
25103 wxGDIObjListBase *arg1 = (wxGDIObjListBase *) 0 ;
25104 void *argp1 = 0 ;
25105 int res1 = 0 ;
25106 PyObject *swig_obj[1] ;
25107
25108 if (!args) SWIG_fail;
25109 swig_obj[0] = args;
25110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_DISOWN | 0 );
25111 if (!SWIG_IsOK(res1)) {
25112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObjListBase" "', expected argument " "1"" of type '" "wxGDIObjListBase *""'");
25113 }
25114 arg1 = reinterpret_cast< wxGDIObjListBase * >(argp1);
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 delete arg1;
25118
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 resultobj = SWIG_Py_Void();
25123 return resultobj;
25124 fail:
25125 return NULL;
25126 }
25127
25128
25129 SWIGINTERN PyObject *GDIObjListBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 PyObject *obj;
25131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25132 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObjListBase, SWIG_NewClientData(obj));
25133 return SWIG_Py_Void();
25134 }
25135
25136 SWIGINTERN PyObject *GDIObjListBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25137 return SWIG_Python_InitShadowInstance(args);
25138 }
25139
25140 SWIGINTERN PyObject *_wrap_PenList_FindOrCreatePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj = 0;
25142 wxPenList *arg1 = (wxPenList *) 0 ;
25143 wxColour *arg2 = 0 ;
25144 int arg3 ;
25145 int arg4 ;
25146 wxPen *result = 0 ;
25147 void *argp1 = 0 ;
25148 int res1 = 0 ;
25149 wxColour temp2 ;
25150 int val3 ;
25151 int ecode3 = 0 ;
25152 int val4 ;
25153 int ecode4 = 0 ;
25154 PyObject * obj0 = 0 ;
25155 PyObject * obj1 = 0 ;
25156 PyObject * obj2 = 0 ;
25157 PyObject * obj3 = 0 ;
25158 char * kwnames[] = {
25159 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
25160 };
25161
25162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_FindOrCreatePen" "', expected argument " "1"" of type '" "wxPenList *""'");
25166 }
25167 arg1 = reinterpret_cast< wxPenList * >(argp1);
25168 {
25169 arg2 = &temp2;
25170 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25171 }
25172 ecode3 = SWIG_AsVal_int(obj2, &val3);
25173 if (!SWIG_IsOK(ecode3)) {
25174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PenList_FindOrCreatePen" "', expected argument " "3"" of type '" "int""'");
25175 }
25176 arg3 = static_cast< int >(val3);
25177 ecode4 = SWIG_AsVal_int(obj3, &val4);
25178 if (!SWIG_IsOK(ecode4)) {
25179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PenList_FindOrCreatePen" "', expected argument " "4"" of type '" "int""'");
25180 }
25181 arg4 = static_cast< int >(val4);
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *_wrap_PenList_AddPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj = 0;
25197 wxPenList *arg1 = (wxPenList *) 0 ;
25198 wxPen *arg2 = (wxPen *) 0 ;
25199 void *argp1 = 0 ;
25200 int res1 = 0 ;
25201 void *argp2 = 0 ;
25202 int res2 = 0 ;
25203 PyObject * obj0 = 0 ;
25204 PyObject * obj1 = 0 ;
25205 char * kwnames[] = {
25206 (char *) "self",(char *) "pen", NULL
25207 };
25208
25209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) SWIG_fail;
25210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25211 if (!SWIG_IsOK(res1)) {
25212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_AddPen" "', expected argument " "1"" of type '" "wxPenList *""'");
25213 }
25214 arg1 = reinterpret_cast< wxPenList * >(argp1);
25215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25216 if (!SWIG_IsOK(res2)) {
25217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_AddPen" "', expected argument " "2"" of type '" "wxPen *""'");
25218 }
25219 arg2 = reinterpret_cast< wxPen * >(argp2);
25220 {
25221 PyThreadState* __tstate = wxPyBeginAllowThreads();
25222 (arg1)->AddPen(arg2);
25223 wxPyEndAllowThreads(__tstate);
25224 if (PyErr_Occurred()) SWIG_fail;
25225 }
25226 resultobj = SWIG_Py_Void();
25227 return resultobj;
25228 fail:
25229 return NULL;
25230 }
25231
25232
25233 SWIGINTERN PyObject *_wrap_PenList_RemovePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj = 0;
25235 wxPenList *arg1 = (wxPenList *) 0 ;
25236 wxPen *arg2 = (wxPen *) 0 ;
25237 void *argp1 = 0 ;
25238 int res1 = 0 ;
25239 void *argp2 = 0 ;
25240 int res2 = 0 ;
25241 PyObject * obj0 = 0 ;
25242 PyObject * obj1 = 0 ;
25243 char * kwnames[] = {
25244 (char *) "self",(char *) "pen", NULL
25245 };
25246
25247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) SWIG_fail;
25248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25249 if (!SWIG_IsOK(res1)) {
25250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_RemovePen" "', expected argument " "1"" of type '" "wxPenList *""'");
25251 }
25252 arg1 = reinterpret_cast< wxPenList * >(argp1);
25253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25254 if (!SWIG_IsOK(res2)) {
25255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_RemovePen" "', expected argument " "2"" of type '" "wxPen *""'");
25256 }
25257 arg2 = reinterpret_cast< wxPen * >(argp2);
25258 {
25259 PyThreadState* __tstate = wxPyBeginAllowThreads();
25260 (arg1)->RemovePen(arg2);
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 resultobj = SWIG_Py_Void();
25265 return resultobj;
25266 fail:
25267 return NULL;
25268 }
25269
25270
25271 SWIGINTERN PyObject *PenList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25272 PyObject *obj;
25273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25274 SWIG_TypeNewClientData(SWIGTYPE_p_wxPenList, SWIG_NewClientData(obj));
25275 return SWIG_Py_Void();
25276 }
25277
25278 SWIGINTERN PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj = 0;
25280 wxBrushList *arg1 = (wxBrushList *) 0 ;
25281 wxColour *arg2 = 0 ;
25282 int arg3 = (int) wxSOLID ;
25283 wxBrush *result = 0 ;
25284 void *argp1 = 0 ;
25285 int res1 = 0 ;
25286 wxColour temp2 ;
25287 int val3 ;
25288 int ecode3 = 0 ;
25289 PyObject * obj0 = 0 ;
25290 PyObject * obj1 = 0 ;
25291 PyObject * obj2 = 0 ;
25292 char * kwnames[] = {
25293 (char *) "self",(char *) "colour",(char *) "style", NULL
25294 };
25295
25296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25298 if (!SWIG_IsOK(res1)) {
25299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25300 }
25301 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25302 {
25303 arg2 = &temp2;
25304 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25305 }
25306 if (obj2) {
25307 ecode3 = SWIG_AsVal_int(obj2, &val3);
25308 if (!SWIG_IsOK(ecode3)) {
25309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "3"" of type '" "int""'");
25310 }
25311 arg3 = static_cast< int >(val3);
25312 }
25313 {
25314 PyThreadState* __tstate = wxPyBeginAllowThreads();
25315 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
25316 wxPyEndAllowThreads(__tstate);
25317 if (PyErr_Occurred()) SWIG_fail;
25318 }
25319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
25320 return resultobj;
25321 fail:
25322 return NULL;
25323 }
25324
25325
25326 SWIGINTERN PyObject *_wrap_BrushList_AddBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj = 0;
25328 wxBrushList *arg1 = (wxBrushList *) 0 ;
25329 wxBrush *arg2 = (wxBrush *) 0 ;
25330 void *argp1 = 0 ;
25331 int res1 = 0 ;
25332 void *argp2 = 0 ;
25333 int res2 = 0 ;
25334 PyObject * obj0 = 0 ;
25335 PyObject * obj1 = 0 ;
25336 char * kwnames[] = {
25337 (char *) "self",(char *) "brush", NULL
25338 };
25339
25340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) SWIG_fail;
25341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25342 if (!SWIG_IsOK(res1)) {
25343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_AddBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25344 }
25345 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
25347 if (!SWIG_IsOK(res2)) {
25348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_AddBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
25349 }
25350 arg2 = reinterpret_cast< wxBrush * >(argp2);
25351 {
25352 PyThreadState* __tstate = wxPyBeginAllowThreads();
25353 (arg1)->AddBrush(arg2);
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 resultobj = SWIG_Py_Void();
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 SWIGINTERN PyObject *_wrap_BrushList_RemoveBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj = 0;
25366 wxBrushList *arg1 = (wxBrushList *) 0 ;
25367 wxBrush *arg2 = (wxBrush *) 0 ;
25368 void *argp1 = 0 ;
25369 int res1 = 0 ;
25370 void *argp2 = 0 ;
25371 int res2 = 0 ;
25372 PyObject * obj0 = 0 ;
25373 PyObject * obj1 = 0 ;
25374 char * kwnames[] = {
25375 (char *) "self",(char *) "brush", NULL
25376 };
25377
25378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) SWIG_fail;
25379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25380 if (!SWIG_IsOK(res1)) {
25381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_RemoveBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25382 }
25383 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
25385 if (!SWIG_IsOK(res2)) {
25386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_RemoveBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
25387 }
25388 arg2 = reinterpret_cast< wxBrush * >(argp2);
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 (arg1)->RemoveBrush(arg2);
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 resultobj = SWIG_Py_Void();
25396 return resultobj;
25397 fail:
25398 return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *BrushList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 PyObject *obj;
25404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25405 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrushList, SWIG_NewClientData(obj));
25406 return SWIG_Py_Void();
25407 }
25408
25409 SWIGINTERN PyObject *_wrap_FontList_FindOrCreateFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj = 0;
25411 wxFontList *arg1 = (wxFontList *) 0 ;
25412 int arg2 ;
25413 int arg3 ;
25414 int arg4 ;
25415 int arg5 ;
25416 bool arg6 = (bool) false ;
25417 wxString const &arg7_defvalue = wxPyEmptyString ;
25418 wxString *arg7 = (wxString *) &arg7_defvalue ;
25419 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
25420 wxFont *result = 0 ;
25421 void *argp1 = 0 ;
25422 int res1 = 0 ;
25423 int val2 ;
25424 int ecode2 = 0 ;
25425 int val3 ;
25426 int ecode3 = 0 ;
25427 int val4 ;
25428 int ecode4 = 0 ;
25429 int val5 ;
25430 int ecode5 = 0 ;
25431 bool val6 ;
25432 int ecode6 = 0 ;
25433 bool temp7 = false ;
25434 int val8 ;
25435 int ecode8 = 0 ;
25436 PyObject * obj0 = 0 ;
25437 PyObject * obj1 = 0 ;
25438 PyObject * obj2 = 0 ;
25439 PyObject * obj3 = 0 ;
25440 PyObject * obj4 = 0 ;
25441 PyObject * obj5 = 0 ;
25442 PyObject * obj6 = 0 ;
25443 PyObject * obj7 = 0 ;
25444 char * kwnames[] = {
25445 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
25446 };
25447
25448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25450 if (!SWIG_IsOK(res1)) {
25451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_FindOrCreateFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25452 }
25453 arg1 = reinterpret_cast< wxFontList * >(argp1);
25454 ecode2 = SWIG_AsVal_int(obj1, &val2);
25455 if (!SWIG_IsOK(ecode2)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontList_FindOrCreateFont" "', expected argument " "2"" of type '" "int""'");
25457 }
25458 arg2 = static_cast< int >(val2);
25459 ecode3 = SWIG_AsVal_int(obj2, &val3);
25460 if (!SWIG_IsOK(ecode3)) {
25461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontList_FindOrCreateFont" "', expected argument " "3"" of type '" "int""'");
25462 }
25463 arg3 = static_cast< int >(val3);
25464 ecode4 = SWIG_AsVal_int(obj3, &val4);
25465 if (!SWIG_IsOK(ecode4)) {
25466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontList_FindOrCreateFont" "', expected argument " "4"" of type '" "int""'");
25467 }
25468 arg4 = static_cast< int >(val4);
25469 ecode5 = SWIG_AsVal_int(obj4, &val5);
25470 if (!SWIG_IsOK(ecode5)) {
25471 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FontList_FindOrCreateFont" "', expected argument " "5"" of type '" "int""'");
25472 }
25473 arg5 = static_cast< int >(val5);
25474 if (obj5) {
25475 ecode6 = SWIG_AsVal_bool(obj5, &val6);
25476 if (!SWIG_IsOK(ecode6)) {
25477 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FontList_FindOrCreateFont" "', expected argument " "6"" of type '" "bool""'");
25478 }
25479 arg6 = static_cast< bool >(val6);
25480 }
25481 if (obj6) {
25482 {
25483 arg7 = wxString_in_helper(obj6);
25484 if (arg7 == NULL) SWIG_fail;
25485 temp7 = true;
25486 }
25487 }
25488 if (obj7) {
25489 ecode8 = SWIG_AsVal_int(obj7, &val8);
25490 if (!SWIG_IsOK(ecode8)) {
25491 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FontList_FindOrCreateFont" "', expected argument " "8"" of type '" "wxFontEncoding""'");
25492 }
25493 arg8 = static_cast< wxFontEncoding >(val8);
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,arg8);
25498 wxPyEndAllowThreads(__tstate);
25499 if (PyErr_Occurred()) SWIG_fail;
25500 }
25501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
25502 {
25503 if (temp7)
25504 delete arg7;
25505 }
25506 return resultobj;
25507 fail:
25508 {
25509 if (temp7)
25510 delete arg7;
25511 }
25512 return NULL;
25513 }
25514
25515
25516 SWIGINTERN PyObject *_wrap_FontList_AddFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj = 0;
25518 wxFontList *arg1 = (wxFontList *) 0 ;
25519 wxFont *arg2 = (wxFont *) 0 ;
25520 void *argp1 = 0 ;
25521 int res1 = 0 ;
25522 void *argp2 = 0 ;
25523 int res2 = 0 ;
25524 PyObject * obj0 = 0 ;
25525 PyObject * obj1 = 0 ;
25526 char * kwnames[] = {
25527 (char *) "self",(char *) "font", NULL
25528 };
25529
25530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) SWIG_fail;
25531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_AddFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25534 }
25535 arg1 = reinterpret_cast< wxFontList * >(argp1);
25536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
25537 if (!SWIG_IsOK(res2)) {
25538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_AddFont" "', expected argument " "2"" of type '" "wxFont *""'");
25539 }
25540 arg2 = reinterpret_cast< wxFont * >(argp2);
25541 {
25542 PyThreadState* __tstate = wxPyBeginAllowThreads();
25543 (arg1)->AddFont(arg2);
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 resultobj = SWIG_Py_Void();
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 SWIGINTERN PyObject *_wrap_FontList_RemoveFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj = 0;
25556 wxFontList *arg1 = (wxFontList *) 0 ;
25557 wxFont *arg2 = (wxFont *) 0 ;
25558 void *argp1 = 0 ;
25559 int res1 = 0 ;
25560 void *argp2 = 0 ;
25561 int res2 = 0 ;
25562 PyObject * obj0 = 0 ;
25563 PyObject * obj1 = 0 ;
25564 char * kwnames[] = {
25565 (char *) "self",(char *) "font", NULL
25566 };
25567
25568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) SWIG_fail;
25569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25570 if (!SWIG_IsOK(res1)) {
25571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_RemoveFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25572 }
25573 arg1 = reinterpret_cast< wxFontList * >(argp1);
25574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
25575 if (!SWIG_IsOK(res2)) {
25576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_RemoveFont" "', expected argument " "2"" of type '" "wxFont *""'");
25577 }
25578 arg2 = reinterpret_cast< wxFont * >(argp2);
25579 {
25580 PyThreadState* __tstate = wxPyBeginAllowThreads();
25581 (arg1)->RemoveFont(arg2);
25582 wxPyEndAllowThreads(__tstate);
25583 if (PyErr_Occurred()) SWIG_fail;
25584 }
25585 resultobj = SWIG_Py_Void();
25586 return resultobj;
25587 fail:
25588 return NULL;
25589 }
25590
25591
25592 SWIGINTERN PyObject *FontList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25593 PyObject *obj;
25594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25595 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontList, SWIG_NewClientData(obj));
25596 return SWIG_Py_Void();
25597 }
25598
25599 SWIGINTERN PyObject *_wrap_new_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25600 PyObject *resultobj = 0;
25601 wxColourDatabase *result = 0 ;
25602
25603 if (!SWIG_Python_UnpackTuple(args,"new_ColourDatabase",0,0,0)) SWIG_fail;
25604 {
25605 if (!wxPyCheckForApp()) SWIG_fail;
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 result = (wxColourDatabase *)new wxColourDatabase();
25608 wxPyEndAllowThreads(__tstate);
25609 if (PyErr_Occurred()) SWIG_fail;
25610 }
25611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_NEW | 0 );
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *_wrap_delete_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25619 PyObject *resultobj = 0;
25620 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25621 void *argp1 = 0 ;
25622 int res1 = 0 ;
25623 PyObject *swig_obj[1] ;
25624
25625 if (!args) SWIG_fail;
25626 swig_obj[0] = args;
25627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_DISOWN | 0 );
25628 if (!SWIG_IsOK(res1)) {
25629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDatabase" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25630 }
25631 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 delete arg1;
25635
25636 wxPyEndAllowThreads(__tstate);
25637 if (PyErr_Occurred()) SWIG_fail;
25638 }
25639 resultobj = SWIG_Py_Void();
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_ColourDatabase_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25647 PyObject *resultobj = 0;
25648 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25649 wxString *arg2 = 0 ;
25650 wxColour result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 bool temp2 = false ;
25654 PyObject * obj0 = 0 ;
25655 PyObject * obj1 = 0 ;
25656 char * kwnames[] = {
25657 (char *) "self",(char *) "name", NULL
25658 };
25659
25660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) SWIG_fail;
25661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25662 if (!SWIG_IsOK(res1)) {
25663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Find" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
25664 }
25665 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25666 {
25667 arg2 = wxString_in_helper(obj1);
25668 if (arg2 == NULL) SWIG_fail;
25669 temp2 = true;
25670 }
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25678 {
25679 if (temp2)
25680 delete arg2;
25681 }
25682 return resultobj;
25683 fail:
25684 {
25685 if (temp2)
25686 delete arg2;
25687 }
25688 return NULL;
25689 }
25690
25691
25692 SWIGINTERN PyObject *_wrap_ColourDatabase_FindName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25693 PyObject *resultobj = 0;
25694 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25695 wxColour *arg2 = 0 ;
25696 wxString result;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 wxColour temp2 ;
25700 PyObject * obj0 = 0 ;
25701 PyObject * obj1 = 0 ;
25702 char * kwnames[] = {
25703 (char *) "self",(char *) "colour", NULL
25704 };
25705
25706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) SWIG_fail;
25707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25708 if (!SWIG_IsOK(res1)) {
25709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_FindName" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
25710 }
25711 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25712 {
25713 arg2 = &temp2;
25714 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25715 }
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
25719 wxPyEndAllowThreads(__tstate);
25720 if (PyErr_Occurred()) SWIG_fail;
25721 }
25722 {
25723 #if wxUSE_UNICODE
25724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25725 #else
25726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25727 #endif
25728 }
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 SWIGINTERN PyObject *_wrap_ColourDatabase_AddColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj = 0;
25737 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25738 wxString *arg2 = 0 ;
25739 wxColour *arg3 = 0 ;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 bool temp2 = false ;
25743 wxColour temp3 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 PyObject * obj2 = 0 ;
25747 char * kwnames[] = {
25748 (char *) "self",(char *) "name",(char *) "colour", NULL
25749 };
25750
25751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25753 if (!SWIG_IsOK(res1)) {
25754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_AddColour" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25755 }
25756 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25757 {
25758 arg2 = wxString_in_helper(obj1);
25759 if (arg2 == NULL) SWIG_fail;
25760 temp2 = true;
25761 }
25762 {
25763 arg3 = &temp3;
25764 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
25765 }
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 resultobj = SWIG_Py_Void();
25773 {
25774 if (temp2)
25775 delete arg2;
25776 }
25777 return resultobj;
25778 fail:
25779 {
25780 if (temp2)
25781 delete arg2;
25782 }
25783 return NULL;
25784 }
25785
25786
25787 SWIGINTERN PyObject *_wrap_ColourDatabase_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25788 PyObject *resultobj = 0;
25789 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25790 wxString *arg2 = 0 ;
25791 int arg3 ;
25792 int arg4 ;
25793 int arg5 ;
25794 void *argp1 = 0 ;
25795 int res1 = 0 ;
25796 bool temp2 = false ;
25797 int val3 ;
25798 int ecode3 = 0 ;
25799 int val4 ;
25800 int ecode4 = 0 ;
25801 int val5 ;
25802 int ecode5 = 0 ;
25803 PyObject * obj0 = 0 ;
25804 PyObject * obj1 = 0 ;
25805 PyObject * obj2 = 0 ;
25806 PyObject * obj3 = 0 ;
25807 PyObject * obj4 = 0 ;
25808 char * kwnames[] = {
25809 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
25810 };
25811
25812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25814 if (!SWIG_IsOK(res1)) {
25815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Append" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25816 }
25817 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25818 {
25819 arg2 = wxString_in_helper(obj1);
25820 if (arg2 == NULL) SWIG_fail;
25821 temp2 = true;
25822 }
25823 ecode3 = SWIG_AsVal_int(obj2, &val3);
25824 if (!SWIG_IsOK(ecode3)) {
25825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourDatabase_Append" "', expected argument " "3"" of type '" "int""'");
25826 }
25827 arg3 = static_cast< int >(val3);
25828 ecode4 = SWIG_AsVal_int(obj3, &val4);
25829 if (!SWIG_IsOK(ecode4)) {
25830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourDatabase_Append" "', expected argument " "4"" of type '" "int""'");
25831 }
25832 arg4 = static_cast< int >(val4);
25833 ecode5 = SWIG_AsVal_int(obj4, &val5);
25834 if (!SWIG_IsOK(ecode5)) {
25835 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourDatabase_Append" "', expected argument " "5"" of type '" "int""'");
25836 }
25837 arg5 = static_cast< int >(val5);
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 resultobj = SWIG_Py_Void();
25845 {
25846 if (temp2)
25847 delete arg2;
25848 }
25849 return resultobj;
25850 fail:
25851 {
25852 if (temp2)
25853 delete arg2;
25854 }
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *ColourDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25860 PyObject *obj;
25861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25862 SWIG_TypeNewClientData(SWIGTYPE_p_wxColourDatabase, SWIG_NewClientData(obj));
25863 return SWIG_Py_Void();
25864 }
25865
25866 SWIGINTERN PyObject *ColourDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25867 return SWIG_Python_InitShadowInstance(args);
25868 }
25869
25870 SWIGINTERN PyObject *_wrap__wxPyInitTheFontList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25871 PyObject *resultobj = 0;
25872 wxFontList *result = 0 ;
25873
25874 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheFontList",0,0,0)) SWIG_fail;
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 result = (wxFontList *)_wxPyInitTheFontList();
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontList, 0 | 0 );
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap__wxPyInitThePenList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25889 PyObject *resultobj = 0;
25890 wxPenList *result = 0 ;
25891
25892 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitThePenList",0,0,0)) SWIG_fail;
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 result = (wxPenList *)_wxPyInitThePenList();
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPenList, 0 | 0 );
25900 return resultobj;
25901 fail:
25902 return NULL;
25903 }
25904
25905
25906 SWIGINTERN PyObject *_wrap__wxPyInitTheBrushList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25907 PyObject *resultobj = 0;
25908 wxBrushList *result = 0 ;
25909
25910 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheBrushList",0,0,0)) SWIG_fail;
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 result = (wxBrushList *)_wxPyInitTheBrushList();
25914 wxPyEndAllowThreads(__tstate);
25915 if (PyErr_Occurred()) SWIG_fail;
25916 }
25917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrushList, 0 | 0 );
25918 return resultobj;
25919 fail:
25920 return NULL;
25921 }
25922
25923
25924 SWIGINTERN PyObject *_wrap__wxPyInitTheColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25925 PyObject *resultobj = 0;
25926 wxColourDatabase *result = 0 ;
25927
25928 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheColourDatabase",0,0,0)) SWIG_fail;
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 result = (wxColourDatabase *)_wxPyInitTheColourDatabase();
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *_wrap_new_Effects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25943 PyObject *resultobj = 0;
25944 wxEffects *result = 0 ;
25945
25946 if (!SWIG_Python_UnpackTuple(args,"new_Effects",0,0,0)) SWIG_fail;
25947 {
25948 PyThreadState* __tstate = wxPyBeginAllowThreads();
25949 result = (wxEffects *)new wxEffects();
25950 wxPyEndAllowThreads(__tstate);
25951 if (PyErr_Occurred()) SWIG_fail;
25952 }
25953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEffects, SWIG_POINTER_NEW | 0 );
25954 return resultobj;
25955 fail:
25956 return NULL;
25957 }
25958
25959
25960 SWIGINTERN PyObject *_wrap_Effects_GetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25961 PyObject *resultobj = 0;
25962 wxEffects *arg1 = (wxEffects *) 0 ;
25963 wxColour result;
25964 void *argp1 = 0 ;
25965 int res1 = 0 ;
25966 PyObject *swig_obj[1] ;
25967
25968 if (!args) SWIG_fail;
25969 swig_obj[0] = args;
25970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25971 if (!SWIG_IsOK(res1)) {
25972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetHighlightColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
25973 }
25974 arg1 = reinterpret_cast< wxEffects * >(argp1);
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 result = ((wxEffects const *)arg1)->GetHighlightColour();
25978 wxPyEndAllowThreads(__tstate);
25979 if (PyErr_Occurred()) SWIG_fail;
25980 }
25981 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25982 return resultobj;
25983 fail:
25984 return NULL;
25985 }
25986
25987
25988 SWIGINTERN PyObject *_wrap_Effects_GetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25989 PyObject *resultobj = 0;
25990 wxEffects *arg1 = (wxEffects *) 0 ;
25991 wxColour result;
25992 void *argp1 = 0 ;
25993 int res1 = 0 ;
25994 PyObject *swig_obj[1] ;
25995
25996 if (!args) SWIG_fail;
25997 swig_obj[0] = args;
25998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25999 if (!SWIG_IsOK(res1)) {
26000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetLightShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26001 }
26002 arg1 = reinterpret_cast< wxEffects * >(argp1);
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 result = ((wxEffects const *)arg1)->GetLightShadow();
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_Effects_GetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *resultobj = 0;
26018 wxEffects *arg1 = (wxEffects *) 0 ;
26019 wxColour result;
26020 void *argp1 = 0 ;
26021 int res1 = 0 ;
26022 PyObject *swig_obj[1] ;
26023
26024 if (!args) SWIG_fail;
26025 swig_obj[0] = args;
26026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetFaceColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
26029 }
26030 arg1 = reinterpret_cast< wxEffects * >(argp1);
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = ((wxEffects const *)arg1)->GetFaceColour();
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_Effects_GetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *resultobj = 0;
26046 wxEffects *arg1 = (wxEffects *) 0 ;
26047 wxColour result;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 PyObject *swig_obj[1] ;
26051
26052 if (!args) SWIG_fail;
26053 swig_obj[0] = args;
26054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetMediumShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26057 }
26058 arg1 = reinterpret_cast< wxEffects * >(argp1);
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 result = ((wxEffects const *)arg1)->GetMediumShadow();
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_Effects_GetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26073 PyObject *resultobj = 0;
26074 wxEffects *arg1 = (wxEffects *) 0 ;
26075 wxColour result;
26076 void *argp1 = 0 ;
26077 int res1 = 0 ;
26078 PyObject *swig_obj[1] ;
26079
26080 if (!args) SWIG_fail;
26081 swig_obj[0] = args;
26082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26083 if (!SWIG_IsOK(res1)) {
26084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetDarkShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26085 }
26086 arg1 = reinterpret_cast< wxEffects * >(argp1);
26087 {
26088 PyThreadState* __tstate = wxPyBeginAllowThreads();
26089 result = ((wxEffects const *)arg1)->GetDarkShadow();
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 SWIGINTERN PyObject *_wrap_Effects_SetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxEffects *arg1 = (wxEffects *) 0 ;
26103 wxColour *arg2 = 0 ;
26104 void *argp1 = 0 ;
26105 int res1 = 0 ;
26106 wxColour temp2 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "c", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetHighlightColour" "', expected argument " "1"" of type '" "wxEffects *""'");
26117 }
26118 arg1 = reinterpret_cast< wxEffects * >(argp1);
26119 {
26120 arg2 = &temp2;
26121 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26122 }
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 (arg1)->SetHighlightColour((wxColour const &)*arg2);
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_Py_Void();
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_Effects_SetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxEffects *arg1 = (wxEffects *) 0 ;
26139 wxColour *arg2 = 0 ;
26140 void *argp1 = 0 ;
26141 int res1 = 0 ;
26142 wxColour temp2 ;
26143 PyObject * obj0 = 0 ;
26144 PyObject * obj1 = 0 ;
26145 char * kwnames[] = {
26146 (char *) "self",(char *) "c", NULL
26147 };
26148
26149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26151 if (!SWIG_IsOK(res1)) {
26152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetLightShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26153 }
26154 arg1 = reinterpret_cast< wxEffects * >(argp1);
26155 {
26156 arg2 = &temp2;
26157 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26158 }
26159 {
26160 PyThreadState* __tstate = wxPyBeginAllowThreads();
26161 (arg1)->SetLightShadow((wxColour const &)*arg2);
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 resultobj = SWIG_Py_Void();
26166 return resultobj;
26167 fail:
26168 return NULL;
26169 }
26170
26171
26172 SWIGINTERN PyObject *_wrap_Effects_SetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26173 PyObject *resultobj = 0;
26174 wxEffects *arg1 = (wxEffects *) 0 ;
26175 wxColour *arg2 = 0 ;
26176 void *argp1 = 0 ;
26177 int res1 = 0 ;
26178 wxColour temp2 ;
26179 PyObject * obj0 = 0 ;
26180 PyObject * obj1 = 0 ;
26181 char * kwnames[] = {
26182 (char *) "self",(char *) "c", NULL
26183 };
26184
26185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetFaceColour" "', expected argument " "1"" of type '" "wxEffects *""'");
26189 }
26190 arg1 = reinterpret_cast< wxEffects * >(argp1);
26191 {
26192 arg2 = &temp2;
26193 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26194 }
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 (arg1)->SetFaceColour((wxColour const &)*arg2);
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 resultobj = SWIG_Py_Void();
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_Effects_SetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj = 0;
26210 wxEffects *arg1 = (wxEffects *) 0 ;
26211 wxColour *arg2 = 0 ;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 wxColour temp2 ;
26215 PyObject * obj0 = 0 ;
26216 PyObject * obj1 = 0 ;
26217 char * kwnames[] = {
26218 (char *) "self",(char *) "c", NULL
26219 };
26220
26221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetMediumShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26225 }
26226 arg1 = reinterpret_cast< wxEffects * >(argp1);
26227 {
26228 arg2 = &temp2;
26229 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26230 }
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 (arg1)->SetMediumShadow((wxColour const &)*arg2);
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 resultobj = SWIG_Py_Void();
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_Effects_SetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj = 0;
26246 wxEffects *arg1 = (wxEffects *) 0 ;
26247 wxColour *arg2 = 0 ;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 wxColour temp2 ;
26251 PyObject * obj0 = 0 ;
26252 PyObject * obj1 = 0 ;
26253 char * kwnames[] = {
26254 (char *) "self",(char *) "c", NULL
26255 };
26256
26257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26259 if (!SWIG_IsOK(res1)) {
26260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetDarkShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26261 }
26262 arg1 = reinterpret_cast< wxEffects * >(argp1);
26263 {
26264 arg2 = &temp2;
26265 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 (arg1)->SetDarkShadow((wxColour const &)*arg2);
26270 wxPyEndAllowThreads(__tstate);
26271 if (PyErr_Occurred()) SWIG_fail;
26272 }
26273 resultobj = SWIG_Py_Void();
26274 return resultobj;
26275 fail:
26276 return NULL;
26277 }
26278
26279
26280 SWIGINTERN PyObject *_wrap_Effects_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26281 PyObject *resultobj = 0;
26282 wxEffects *arg1 = (wxEffects *) 0 ;
26283 wxColour *arg2 = 0 ;
26284 wxColour *arg3 = 0 ;
26285 wxColour *arg4 = 0 ;
26286 wxColour *arg5 = 0 ;
26287 wxColour *arg6 = 0 ;
26288 void *argp1 = 0 ;
26289 int res1 = 0 ;
26290 wxColour temp2 ;
26291 wxColour temp3 ;
26292 wxColour temp4 ;
26293 wxColour temp5 ;
26294 wxColour temp6 ;
26295 PyObject * obj0 = 0 ;
26296 PyObject * obj1 = 0 ;
26297 PyObject * obj2 = 0 ;
26298 PyObject * obj3 = 0 ;
26299 PyObject * obj4 = 0 ;
26300 PyObject * obj5 = 0 ;
26301 char * kwnames[] = {
26302 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
26303 };
26304
26305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26307 if (!SWIG_IsOK(res1)) {
26308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_Set" "', expected argument " "1"" of type '" "wxEffects *""'");
26309 }
26310 arg1 = reinterpret_cast< wxEffects * >(argp1);
26311 {
26312 arg2 = &temp2;
26313 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26314 }
26315 {
26316 arg3 = &temp3;
26317 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26318 }
26319 {
26320 arg4 = &temp4;
26321 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
26322 }
26323 {
26324 arg5 = &temp5;
26325 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
26326 }
26327 {
26328 arg6 = &temp6;
26329 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
26330 }
26331 {
26332 PyThreadState* __tstate = wxPyBeginAllowThreads();
26333 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
26334 wxPyEndAllowThreads(__tstate);
26335 if (PyErr_Occurred()) SWIG_fail;
26336 }
26337 resultobj = SWIG_Py_Void();
26338 return resultobj;
26339 fail:
26340 return NULL;
26341 }
26342
26343
26344 SWIGINTERN PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26345 PyObject *resultobj = 0;
26346 wxEffects *arg1 = (wxEffects *) 0 ;
26347 wxDC *arg2 = 0 ;
26348 wxRect *arg3 = 0 ;
26349 int arg4 = (int) 1 ;
26350 void *argp1 = 0 ;
26351 int res1 = 0 ;
26352 void *argp2 = 0 ;
26353 int res2 = 0 ;
26354 wxRect temp3 ;
26355 int val4 ;
26356 int ecode4 = 0 ;
26357 PyObject * obj0 = 0 ;
26358 PyObject * obj1 = 0 ;
26359 PyObject * obj2 = 0 ;
26360 PyObject * obj3 = 0 ;
26361 char * kwnames[] = {
26362 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
26363 };
26364
26365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26367 if (!SWIG_IsOK(res1)) {
26368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "1"" of type '" "wxEffects *""'");
26369 }
26370 arg1 = reinterpret_cast< wxEffects * >(argp1);
26371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
26372 if (!SWIG_IsOK(res2)) {
26373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
26374 }
26375 if (!argp2) {
26376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
26377 }
26378 arg2 = reinterpret_cast< wxDC * >(argp2);
26379 {
26380 arg3 = &temp3;
26381 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
26382 }
26383 if (obj3) {
26384 ecode4 = SWIG_AsVal_int(obj3, &val4);
26385 if (!SWIG_IsOK(ecode4)) {
26386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "4"" of type '" "int""'");
26387 }
26388 arg4 = static_cast< int >(val4);
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
26393 wxPyEndAllowThreads(__tstate);
26394 if (PyErr_Occurred()) SWIG_fail;
26395 }
26396 resultobj = SWIG_Py_Void();
26397 return resultobj;
26398 fail:
26399 return NULL;
26400 }
26401
26402
26403 SWIGINTERN PyObject *_wrap_Effects_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj = 0;
26405 wxEffects *arg1 = (wxEffects *) 0 ;
26406 wxRect *arg2 = 0 ;
26407 wxDC *arg3 = 0 ;
26408 wxBitmap *arg4 = 0 ;
26409 bool result;
26410 void *argp1 = 0 ;
26411 int res1 = 0 ;
26412 wxRect temp2 ;
26413 void *argp3 = 0 ;
26414 int res3 = 0 ;
26415 void *argp4 = 0 ;
26416 int res4 = 0 ;
26417 PyObject * obj0 = 0 ;
26418 PyObject * obj1 = 0 ;
26419 PyObject * obj2 = 0 ;
26420 PyObject * obj3 = 0 ;
26421 char * kwnames[] = {
26422 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
26423 };
26424
26425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26427 if (!SWIG_IsOK(res1)) {
26428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_TileBitmap" "', expected argument " "1"" of type '" "wxEffects *""'");
26429 }
26430 arg1 = reinterpret_cast< wxEffects * >(argp1);
26431 {
26432 arg2 = &temp2;
26433 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26434 }
26435 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26436 if (!SWIG_IsOK(res3)) {
26437 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
26438 }
26439 if (!argp3) {
26440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
26441 }
26442 arg3 = reinterpret_cast< wxDC * >(argp3);
26443 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 );
26444 if (!SWIG_IsOK(res4)) {
26445 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
26446 }
26447 if (!argp4) {
26448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
26449 }
26450 arg4 = reinterpret_cast< wxBitmap * >(argp4);
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 {
26458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26459 }
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 SWIGINTERN PyObject *Effects_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26467 PyObject *obj;
26468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26469 SWIG_TypeNewClientData(SWIGTYPE_p_wxEffects, SWIG_NewClientData(obj));
26470 return SWIG_Py_Void();
26471 }
26472
26473 SWIGINTERN PyObject *Effects_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26474 return SWIG_Python_InitShadowInstance(args);
26475 }
26476
26477 SWIGINTERN PyObject *_wrap_new_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26478 PyObject *resultobj = 0;
26479 int arg1 ;
26480 int arg2 ;
26481 bool arg3 ;
26482 wxSplitterRenderParams *result = 0 ;
26483 int val1 ;
26484 int ecode1 = 0 ;
26485 int val2 ;
26486 int ecode2 = 0 ;
26487 bool val3 ;
26488 int ecode3 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 PyObject * obj2 = 0 ;
26492 char * kwnames[] = {
26493 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
26494 };
26495
26496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26497 ecode1 = SWIG_AsVal_int(obj0, &val1);
26498 if (!SWIG_IsOK(ecode1)) {
26499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplitterRenderParams" "', expected argument " "1"" of type '" "int""'");
26500 }
26501 arg1 = static_cast< int >(val1);
26502 ecode2 = SWIG_AsVal_int(obj1, &val2);
26503 if (!SWIG_IsOK(ecode2)) {
26504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SplitterRenderParams" "', expected argument " "2"" of type '" "int""'");
26505 }
26506 arg2 = static_cast< int >(val2);
26507 ecode3 = SWIG_AsVal_bool(obj2, &val3);
26508 if (!SWIG_IsOK(ecode3)) {
26509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SplitterRenderParams" "', expected argument " "3"" of type '" "bool""'");
26510 }
26511 arg3 = static_cast< bool >(val3);
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_NEW | 0 );
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 SWIGINTERN PyObject *_wrap_delete_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26526 PyObject *resultobj = 0;
26527 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26528 void *argp1 = 0 ;
26529 int res1 = 0 ;
26530 PyObject *swig_obj[1] ;
26531
26532 if (!args) SWIG_fail;
26533 swig_obj[0] = args;
26534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_DISOWN | 0 );
26535 if (!SWIG_IsOK(res1)) {
26536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplitterRenderParams" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26537 }
26538 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26539 {
26540 PyThreadState* __tstate = wxPyBeginAllowThreads();
26541 delete arg1;
26542
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 resultobj = SWIG_Py_Void();
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26554 PyObject *resultobj = 0;
26555 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26556 int result;
26557 void *argp1 = 0 ;
26558 int res1 = 0 ;
26559 PyObject *swig_obj[1] ;
26560
26561 if (!args) SWIG_fail;
26562 swig_obj[0] = args;
26563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26564 if (!SWIG_IsOK(res1)) {
26565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_widthSash_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26566 }
26567 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26568 result = (int)(int) ((arg1)->widthSash);
26569 resultobj = SWIG_From_int(static_cast< int >(result));
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 SWIGINTERN PyObject *_wrap_SplitterRenderParams_border_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577 PyObject *resultobj = 0;
26578 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26579 int result;
26580 void *argp1 = 0 ;
26581 int res1 = 0 ;
26582 PyObject *swig_obj[1] ;
26583
26584 if (!args) SWIG_fail;
26585 swig_obj[0] = args;
26586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26587 if (!SWIG_IsOK(res1)) {
26588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_border_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26589 }
26590 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26591 result = (int)(int) ((arg1)->border);
26592 resultobj = SWIG_From_int(static_cast< int >(result));
26593 return resultobj;
26594 fail:
26595 return NULL;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26600 PyObject *resultobj = 0;
26601 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26602 bool result;
26603 void *argp1 = 0 ;
26604 int res1 = 0 ;
26605 PyObject *swig_obj[1] ;
26606
26607 if (!args) SWIG_fail;
26608 swig_obj[0] = args;
26609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26610 if (!SWIG_IsOK(res1)) {
26611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_isHotSensitive_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26612 }
26613 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26614 result = (bool)(bool) ((arg1)->isHotSensitive);
26615 resultobj = SWIG_From_bool(static_cast< bool >(result));
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *SplitterRenderParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 PyObject *obj;
26624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26625 SWIG_TypeNewClientData(SWIGTYPE_p_wxSplitterRenderParams, SWIG_NewClientData(obj));
26626 return SWIG_Py_Void();
26627 }
26628
26629 SWIGINTERN PyObject *SplitterRenderParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26630 return SWIG_Python_InitShadowInstance(args);
26631 }
26632
26633 SWIGINTERN PyObject *_wrap_new_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26634 PyObject *resultobj = 0;
26635 int arg1 ;
26636 int arg2 ;
26637 wxRendererVersion *result = 0 ;
26638 int val1 ;
26639 int ecode1 = 0 ;
26640 int val2 ;
26641 int ecode2 = 0 ;
26642 PyObject * obj0 = 0 ;
26643 PyObject * obj1 = 0 ;
26644 char * kwnames[] = {
26645 (char *) "version_",(char *) "age_", NULL
26646 };
26647
26648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) SWIG_fail;
26649 ecode1 = SWIG_AsVal_int(obj0, &val1);
26650 if (!SWIG_IsOK(ecode1)) {
26651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RendererVersion" "', expected argument " "1"" of type '" "int""'");
26652 }
26653 arg1 = static_cast< int >(val1);
26654 ecode2 = SWIG_AsVal_int(obj1, &val2);
26655 if (!SWIG_IsOK(ecode2)) {
26656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RendererVersion" "', expected argument " "2"" of type '" "int""'");
26657 }
26658 arg2 = static_cast< int >(val2);
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_NEW | 0 );
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 SWIGINTERN PyObject *_wrap_delete_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26673 PyObject *resultobj = 0;
26674 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26675 void *argp1 = 0 ;
26676 int res1 = 0 ;
26677 PyObject *swig_obj[1] ;
26678
26679 if (!args) SWIG_fail;
26680 swig_obj[0] = args;
26681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_DISOWN | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RendererVersion" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26684 }
26685 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26686 {
26687 PyThreadState* __tstate = wxPyBeginAllowThreads();
26688 delete arg1;
26689
26690 wxPyEndAllowThreads(__tstate);
26691 if (PyErr_Occurred()) SWIG_fail;
26692 }
26693 resultobj = SWIG_Py_Void();
26694 return resultobj;
26695 fail:
26696 return NULL;
26697 }
26698
26699
26700 SWIGINTERN PyObject *_wrap_RendererVersion_IsCompatible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26701 PyObject *resultobj = 0;
26702 wxRendererVersion *arg1 = 0 ;
26703 bool result;
26704 void *argp1 = 0 ;
26705 int res1 = 0 ;
26706 PyObject * obj0 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "ver", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRendererVersion, 0 | 0);
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
26715 }
26716 if (!argp1) {
26717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
26718 }
26719 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26728 }
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 SWIGINTERN PyObject *_wrap_RendererVersion_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26736 PyObject *resultobj = 0;
26737 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26738 int result;
26739 void *argp1 = 0 ;
26740 int res1 = 0 ;
26741 PyObject *swig_obj[1] ;
26742
26743 if (!args) SWIG_fail;
26744 swig_obj[0] = args;
26745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
26746 if (!SWIG_IsOK(res1)) {
26747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_version_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26748 }
26749 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26750 result = (int)(int) ((arg1)->version);
26751 resultobj = SWIG_From_int(static_cast< int >(result));
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *_wrap_RendererVersion_age_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *resultobj = 0;
26760 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26761 int result;
26762 void *argp1 = 0 ;
26763 int res1 = 0 ;
26764 PyObject *swig_obj[1] ;
26765
26766 if (!args) SWIG_fail;
26767 swig_obj[0] = args;
26768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_age_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26771 }
26772 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26773 result = (int)(int) ((arg1)->age);
26774 resultobj = SWIG_From_int(static_cast< int >(result));
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *RendererVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *obj;
26783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26784 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererVersion, SWIG_NewClientData(obj));
26785 return SWIG_Py_Void();
26786 }
26787
26788 SWIGINTERN PyObject *RendererVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26789 return SWIG_Python_InitShadowInstance(args);
26790 }
26791
26792 SWIGINTERN PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj = 0;
26794 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26795 wxWindow *arg2 = (wxWindow *) 0 ;
26796 wxDC *arg3 = 0 ;
26797 wxRect *arg4 = 0 ;
26798 int arg5 = (int) 0 ;
26799 void *argp1 = 0 ;
26800 int res1 = 0 ;
26801 void *argp2 = 0 ;
26802 int res2 = 0 ;
26803 void *argp3 = 0 ;
26804 int res3 = 0 ;
26805 wxRect temp4 ;
26806 int val5 ;
26807 int ecode5 = 0 ;
26808 PyObject * obj0 = 0 ;
26809 PyObject * obj1 = 0 ;
26810 PyObject * obj2 = 0 ;
26811 PyObject * obj3 = 0 ;
26812 PyObject * obj4 = 0 ;
26813 char * kwnames[] = {
26814 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26815 };
26816
26817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26819 if (!SWIG_IsOK(res1)) {
26820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26821 }
26822 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26824 if (!SWIG_IsOK(res2)) {
26825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "2"" of type '" "wxWindow *""'");
26826 }
26827 arg2 = reinterpret_cast< wxWindow * >(argp2);
26828 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26829 if (!SWIG_IsOK(res3)) {
26830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
26831 }
26832 if (!argp3) {
26833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
26834 }
26835 arg3 = reinterpret_cast< wxDC * >(argp3);
26836 {
26837 arg4 = &temp4;
26838 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26839 }
26840 if (obj4) {
26841 ecode5 = SWIG_AsVal_int(obj4, &val5);
26842 if (!SWIG_IsOK(ecode5)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "5"" of type '" "int""'");
26844 }
26845 arg5 = static_cast< int >(val5);
26846 }
26847 {
26848 PyThreadState* __tstate = wxPyBeginAllowThreads();
26849 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 resultobj = SWIG_Py_Void();
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 SWIGINTERN PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj = 0;
26862 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26863 wxWindow *arg2 = (wxWindow *) 0 ;
26864 wxDC *arg3 = 0 ;
26865 wxRect *arg4 = 0 ;
26866 int arg5 = (int) 0 ;
26867 void *argp1 = 0 ;
26868 int res1 = 0 ;
26869 void *argp2 = 0 ;
26870 int res2 = 0 ;
26871 void *argp3 = 0 ;
26872 int res3 = 0 ;
26873 wxRect temp4 ;
26874 int val5 ;
26875 int ecode5 = 0 ;
26876 PyObject * obj0 = 0 ;
26877 PyObject * obj1 = 0 ;
26878 PyObject * obj2 = 0 ;
26879 PyObject * obj3 = 0 ;
26880 PyObject * obj4 = 0 ;
26881 char * kwnames[] = {
26882 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26883 };
26884
26885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26887 if (!SWIG_IsOK(res1)) {
26888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26889 }
26890 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26892 if (!SWIG_IsOK(res2)) {
26893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "2"" of type '" "wxWindow *""'");
26894 }
26895 arg2 = reinterpret_cast< wxWindow * >(argp2);
26896 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26897 if (!SWIG_IsOK(res3)) {
26898 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
26899 }
26900 if (!argp3) {
26901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
26902 }
26903 arg3 = reinterpret_cast< wxDC * >(argp3);
26904 {
26905 arg4 = &temp4;
26906 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26907 }
26908 if (obj4) {
26909 ecode5 = SWIG_AsVal_int(obj4, &val5);
26910 if (!SWIG_IsOK(ecode5)) {
26911 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "5"" of type '" "int""'");
26912 }
26913 arg5 = static_cast< int >(val5);
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26929 PyObject *resultobj = 0;
26930 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26931 wxWindow *arg2 = (wxWindow *) 0 ;
26932 wxDC *arg3 = 0 ;
26933 wxRect *arg4 = 0 ;
26934 int arg5 = (int) 0 ;
26935 void *argp1 = 0 ;
26936 int res1 = 0 ;
26937 void *argp2 = 0 ;
26938 int res2 = 0 ;
26939 void *argp3 = 0 ;
26940 int res3 = 0 ;
26941 wxRect temp4 ;
26942 int val5 ;
26943 int ecode5 = 0 ;
26944 PyObject * obj0 = 0 ;
26945 PyObject * obj1 = 0 ;
26946 PyObject * obj2 = 0 ;
26947 PyObject * obj3 = 0 ;
26948 PyObject * obj4 = 0 ;
26949 char * kwnames[] = {
26950 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26951 };
26952
26953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26955 if (!SWIG_IsOK(res1)) {
26956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26957 }
26958 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26960 if (!SWIG_IsOK(res2)) {
26961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "2"" of type '" "wxWindow *""'");
26962 }
26963 arg2 = reinterpret_cast< wxWindow * >(argp2);
26964 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26965 if (!SWIG_IsOK(res3)) {
26966 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
26967 }
26968 if (!argp3) {
26969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
26970 }
26971 arg3 = reinterpret_cast< wxDC * >(argp3);
26972 {
26973 arg4 = &temp4;
26974 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26975 }
26976 if (obj4) {
26977 ecode5 = SWIG_AsVal_int(obj4, &val5);
26978 if (!SWIG_IsOK(ecode5)) {
26979 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "5"" of type '" "int""'");
26980 }
26981 arg5 = static_cast< int >(val5);
26982 }
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
26986 wxPyEndAllowThreads(__tstate);
26987 if (PyErr_Occurred()) SWIG_fail;
26988 }
26989 resultobj = SWIG_Py_Void();
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj = 0;
26998 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26999 wxWindow *arg2 = (wxWindow *) 0 ;
27000 wxDC *arg3 = 0 ;
27001 wxSize *arg4 = 0 ;
27002 int arg5 ;
27003 wxOrientation arg6 ;
27004 int arg7 = (int) 0 ;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 void *argp2 = 0 ;
27008 int res2 = 0 ;
27009 void *argp3 = 0 ;
27010 int res3 = 0 ;
27011 wxSize temp4 ;
27012 int val5 ;
27013 int ecode5 = 0 ;
27014 int val6 ;
27015 int ecode6 = 0 ;
27016 int val7 ;
27017 int ecode7 = 0 ;
27018 PyObject * obj0 = 0 ;
27019 PyObject * obj1 = 0 ;
27020 PyObject * obj2 = 0 ;
27021 PyObject * obj3 = 0 ;
27022 PyObject * obj4 = 0 ;
27023 PyObject * obj5 = 0 ;
27024 PyObject * obj6 = 0 ;
27025 char * kwnames[] = {
27026 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
27027 };
27028
27029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27031 if (!SWIG_IsOK(res1)) {
27032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27033 }
27034 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27036 if (!SWIG_IsOK(res2)) {
27037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "2"" of type '" "wxWindow *""'");
27038 }
27039 arg2 = reinterpret_cast< wxWindow * >(argp2);
27040 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27041 if (!SWIG_IsOK(res3)) {
27042 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
27043 }
27044 if (!argp3) {
27045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
27046 }
27047 arg3 = reinterpret_cast< wxDC * >(argp3);
27048 {
27049 arg4 = &temp4;
27050 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27051 }
27052 ecode5 = SWIG_AsVal_int(obj4, &val5);
27053 if (!SWIG_IsOK(ecode5)) {
27054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "5"" of type '" "int""'");
27055 }
27056 arg5 = static_cast< int >(val5);
27057 ecode6 = SWIG_AsVal_int(obj5, &val6);
27058 if (!SWIG_IsOK(ecode6)) {
27059 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "6"" of type '" "wxOrientation""'");
27060 }
27061 arg6 = static_cast< wxOrientation >(val6);
27062 if (obj6) {
27063 ecode7 = SWIG_AsVal_int(obj6, &val7);
27064 if (!SWIG_IsOK(ecode7)) {
27065 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "7"" of type '" "int""'");
27066 }
27067 arg7 = static_cast< int >(val7);
27068 }
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,arg6,arg7);
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = SWIG_Py_Void();
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj = 0;
27084 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27085 wxWindow *arg2 = (wxWindow *) 0 ;
27086 wxDC *arg3 = 0 ;
27087 wxRect *arg4 = 0 ;
27088 int arg5 = (int) 0 ;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 void *argp2 = 0 ;
27092 int res2 = 0 ;
27093 void *argp3 = 0 ;
27094 int res3 = 0 ;
27095 wxRect temp4 ;
27096 int val5 ;
27097 int ecode5 = 0 ;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 PyObject * obj2 = 0 ;
27101 PyObject * obj3 = 0 ;
27102 PyObject * obj4 = 0 ;
27103 char * kwnames[] = {
27104 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27105 };
27106
27107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27109 if (!SWIG_IsOK(res1)) {
27110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27111 }
27112 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27114 if (!SWIG_IsOK(res2)) {
27115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27116 }
27117 arg2 = reinterpret_cast< wxWindow * >(argp2);
27118 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27119 if (!SWIG_IsOK(res3)) {
27120 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
27121 }
27122 if (!argp3) {
27123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
27124 }
27125 arg3 = reinterpret_cast< wxDC * >(argp3);
27126 {
27127 arg4 = &temp4;
27128 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27129 }
27130 if (obj4) {
27131 ecode5 = SWIG_AsVal_int(obj4, &val5);
27132 if (!SWIG_IsOK(ecode5)) {
27133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "5"" of type '" "int""'");
27134 }
27135 arg5 = static_cast< int >(val5);
27136 }
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 resultobj = SWIG_Py_Void();
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 SWIGINTERN PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj = 0;
27152 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27153 wxWindow *arg2 = (wxWindow *) 0 ;
27154 wxDC *arg3 = 0 ;
27155 wxRect *arg4 = 0 ;
27156 int arg5 = (int) 0 ;
27157 void *argp1 = 0 ;
27158 int res1 = 0 ;
27159 void *argp2 = 0 ;
27160 int res2 = 0 ;
27161 void *argp3 = 0 ;
27162 int res3 = 0 ;
27163 wxRect temp4 ;
27164 int val5 ;
27165 int ecode5 = 0 ;
27166 PyObject * obj0 = 0 ;
27167 PyObject * obj1 = 0 ;
27168 PyObject * obj2 = 0 ;
27169 PyObject * obj3 = 0 ;
27170 PyObject * obj4 = 0 ;
27171 char * kwnames[] = {
27172 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27173 };
27174
27175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27177 if (!SWIG_IsOK(res1)) {
27178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27179 }
27180 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27182 if (!SWIG_IsOK(res2)) {
27183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "2"" of type '" "wxWindow *""'");
27184 }
27185 arg2 = reinterpret_cast< wxWindow * >(argp2);
27186 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27187 if (!SWIG_IsOK(res3)) {
27188 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
27189 }
27190 if (!argp3) {
27191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
27192 }
27193 arg3 = reinterpret_cast< wxDC * >(argp3);
27194 {
27195 arg4 = &temp4;
27196 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27197 }
27198 if (obj4) {
27199 ecode5 = SWIG_AsVal_int(obj4, &val5);
27200 if (!SWIG_IsOK(ecode5)) {
27201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "5"" of type '" "int""'");
27202 }
27203 arg5 = static_cast< int >(val5);
27204 }
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 resultobj = SWIG_Py_Void();
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 SWIGINTERN PyObject *_wrap_RendererNative_DrawCheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27219 PyObject *resultobj = 0;
27220 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27221 wxWindow *arg2 = (wxWindow *) 0 ;
27222 wxDC *arg3 = 0 ;
27223 wxRect *arg4 = 0 ;
27224 int arg5 = (int) 0 ;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 void *argp2 = 0 ;
27228 int res2 = 0 ;
27229 void *argp3 = 0 ;
27230 int res3 = 0 ;
27231 wxRect temp4 ;
27232 int val5 ;
27233 int ecode5 = 0 ;
27234 PyObject * obj0 = 0 ;
27235 PyObject * obj1 = 0 ;
27236 PyObject * obj2 = 0 ;
27237 PyObject * obj3 = 0 ;
27238 PyObject * obj4 = 0 ;
27239 char * kwnames[] = {
27240 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27241 };
27242
27243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawCheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27247 }
27248 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27250 if (!SWIG_IsOK(res2)) {
27251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "2"" of type '" "wxWindow *""'");
27252 }
27253 arg2 = reinterpret_cast< wxWindow * >(argp2);
27254 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27255 if (!SWIG_IsOK(res3)) {
27256 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27257 }
27258 if (!argp3) {
27259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27260 }
27261 arg3 = reinterpret_cast< wxDC * >(argp3);
27262 {
27263 arg4 = &temp4;
27264 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27265 }
27266 if (obj4) {
27267 ecode5 = SWIG_AsVal_int(obj4, &val5);
27268 if (!SWIG_IsOK(ecode5)) {
27269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "5"" of type '" "int""'");
27270 }
27271 arg5 = static_cast< int >(val5);
27272 }
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->DrawCheckBox(arg2,*arg3,(wxRect const &)*arg4,arg5);
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_Py_Void();
27280 return resultobj;
27281 fail:
27282 return NULL;
27283 }
27284
27285
27286 SWIGINTERN PyObject *_wrap_RendererNative_DrawPushButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27287 PyObject *resultobj = 0;
27288 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27289 wxWindow *arg2 = (wxWindow *) 0 ;
27290 wxDC *arg3 = 0 ;
27291 wxRect *arg4 = 0 ;
27292 int arg5 = (int) 0 ;
27293 void *argp1 = 0 ;
27294 int res1 = 0 ;
27295 void *argp2 = 0 ;
27296 int res2 = 0 ;
27297 void *argp3 = 0 ;
27298 int res3 = 0 ;
27299 wxRect temp4 ;
27300 int val5 ;
27301 int ecode5 = 0 ;
27302 PyObject * obj0 = 0 ;
27303 PyObject * obj1 = 0 ;
27304 PyObject * obj2 = 0 ;
27305 PyObject * obj3 = 0 ;
27306 PyObject * obj4 = 0 ;
27307 char * kwnames[] = {
27308 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27309 };
27310
27311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawPushButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27313 if (!SWIG_IsOK(res1)) {
27314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawPushButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27315 }
27316 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27318 if (!SWIG_IsOK(res2)) {
27319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawPushButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27320 }
27321 arg2 = reinterpret_cast< wxWindow * >(argp2);
27322 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27323 if (!SWIG_IsOK(res3)) {
27324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
27325 }
27326 if (!argp3) {
27327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
27328 }
27329 arg3 = reinterpret_cast< wxDC * >(argp3);
27330 {
27331 arg4 = &temp4;
27332 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27333 }
27334 if (obj4) {
27335 ecode5 = SWIG_AsVal_int(obj4, &val5);
27336 if (!SWIG_IsOK(ecode5)) {
27337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawPushButton" "', expected argument " "5"" of type '" "int""'");
27338 }
27339 arg5 = static_cast< int >(val5);
27340 }
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 (arg1)->DrawPushButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 resultobj = SWIG_Py_Void();
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_RendererNative_DrawItemSelectionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27355 PyObject *resultobj = 0;
27356 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27357 wxWindow *arg2 = (wxWindow *) 0 ;
27358 wxDC *arg3 = 0 ;
27359 wxRect *arg4 = 0 ;
27360 int arg5 = (int) 0 ;
27361 void *argp1 = 0 ;
27362 int res1 = 0 ;
27363 void *argp2 = 0 ;
27364 int res2 = 0 ;
27365 void *argp3 = 0 ;
27366 int res3 = 0 ;
27367 wxRect temp4 ;
27368 int val5 ;
27369 int ecode5 = 0 ;
27370 PyObject * obj0 = 0 ;
27371 PyObject * obj1 = 0 ;
27372 PyObject * obj2 = 0 ;
27373 PyObject * obj3 = 0 ;
27374 PyObject * obj4 = 0 ;
27375 char * kwnames[] = {
27376 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27377 };
27378
27379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawItemSelectionRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27383 }
27384 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27386 if (!SWIG_IsOK(res2)) {
27387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "2"" of type '" "wxWindow *""'");
27388 }
27389 arg2 = reinterpret_cast< wxWindow * >(argp2);
27390 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27391 if (!SWIG_IsOK(res3)) {
27392 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
27393 }
27394 if (!argp3) {
27395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
27396 }
27397 arg3 = reinterpret_cast< wxDC * >(argp3);
27398 {
27399 arg4 = &temp4;
27400 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27401 }
27402 if (obj4) {
27403 ecode5 = SWIG_AsVal_int(obj4, &val5);
27404 if (!SWIG_IsOK(ecode5)) {
27405 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "5"" of type '" "int""'");
27406 }
27407 arg5 = static_cast< int >(val5);
27408 }
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 (arg1)->DrawItemSelectionRect(arg2,*arg3,(wxRect const &)*arg4,arg5);
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 resultobj = SWIG_Py_Void();
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 SWIGINTERN PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27423 PyObject *resultobj = 0;
27424 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27425 wxWindow *arg2 = (wxWindow *) 0 ;
27426 SwigValueWrapper<wxSplitterRenderParams > result;
27427 void *argp1 = 0 ;
27428 int res1 = 0 ;
27429 void *argp2 = 0 ;
27430 int res2 = 0 ;
27431 PyObject * obj0 = 0 ;
27432 PyObject * obj1 = 0 ;
27433 char * kwnames[] = {
27434 (char *) "self",(char *) "win", NULL
27435 };
27436
27437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) SWIG_fail;
27438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27439 if (!SWIG_IsOK(res1)) {
27440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27441 }
27442 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27444 if (!SWIG_IsOK(res2)) {
27445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "2"" of type '" "wxWindow const *""'");
27446 }
27447 arg2 = reinterpret_cast< wxWindow * >(argp2);
27448 {
27449 PyThreadState* __tstate = wxPyBeginAllowThreads();
27450 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
27451 wxPyEndAllowThreads(__tstate);
27452 if (PyErr_Occurred()) SWIG_fail;
27453 }
27454 resultobj = SWIG_NewPointerObj((new wxSplitterRenderParams(static_cast< const wxSplitterRenderParams& >(result))), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_OWN | 0 );
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 SWIGINTERN PyObject *_wrap_RendererNative_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27462 PyObject *resultobj = 0;
27463 wxRendererNative *result = 0 ;
27464
27465 if (!SWIG_Python_UnpackTuple(args,"RendererNative_Get",0,0,0)) SWIG_fail;
27466 {
27467 if (!wxPyCheckForApp()) SWIG_fail;
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 {
27470 wxRendererNative &_result_ref = wxRendererNative::Get();
27471 result = (wxRendererNative *) &_result_ref;
27472 }
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 SWIGINTERN PyObject *_wrap_RendererNative_GetGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27484 PyObject *resultobj = 0;
27485 wxRendererNative *result = 0 ;
27486
27487 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetGeneric",0,0,0)) SWIG_fail;
27488 {
27489 if (!wxPyCheckForApp()) SWIG_fail;
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 {
27492 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
27493 result = (wxRendererNative *) &_result_ref;
27494 }
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_RendererNative_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506 PyObject *resultobj = 0;
27507 wxRendererNative *result = 0 ;
27508
27509 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetDefault",0,0,0)) SWIG_fail;
27510 {
27511 if (!wxPyCheckForApp()) SWIG_fail;
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 {
27514 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
27515 result = (wxRendererNative *) &_result_ref;
27516 }
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_RendererNative_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27530 wxRendererNative *result = 0 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 PyObject * obj0 = 0 ;
27534 char * kwnames[] = {
27535 (char *) "renderer", NULL
27536 };
27537
27538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) SWIG_fail;
27539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27540 if (!SWIG_IsOK(res1)) {
27541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_Set" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27542 }
27543 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27544 {
27545 if (!wxPyCheckForApp()) SWIG_fail;
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 result = (wxRendererNative *)wxRendererNative::Set(arg1);
27548 wxPyEndAllowThreads(__tstate);
27549 if (PyErr_Occurred()) SWIG_fail;
27550 }
27551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 SWIGINTERN PyObject *_wrap_RendererNative_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27559 PyObject *resultobj = 0;
27560 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27561 SwigValueWrapper<wxRendererVersion > result;
27562 void *argp1 = 0 ;
27563 int res1 = 0 ;
27564 PyObject *swig_obj[1] ;
27565
27566 if (!args) SWIG_fail;
27567 swig_obj[0] = args;
27568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27569 if (!SWIG_IsOK(res1)) {
27570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetVersion" "', expected argument " "1"" of type '" "wxRendererNative const *""'");
27571 }
27572 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27573 {
27574 PyThreadState* __tstate = wxPyBeginAllowThreads();
27575 result = ((wxRendererNative const *)arg1)->GetVersion();
27576 wxPyEndAllowThreads(__tstate);
27577 if (PyErr_Occurred()) SWIG_fail;
27578 }
27579 resultobj = SWIG_NewPointerObj((new wxRendererVersion(static_cast< const wxRendererVersion& >(result))), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_OWN | 0 );
27580 return resultobj;
27581 fail:
27582 return NULL;
27583 }
27584
27585
27586 SWIGINTERN PyObject *RendererNative_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27587 PyObject *obj;
27588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27589 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererNative, SWIG_NewClientData(obj));
27590 return SWIG_Py_Void();
27591 }
27592
27593 SWIGINTERN PyObject *_wrap_new_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27594 PyObject *resultobj = 0;
27595 wxPseudoDC *result = 0 ;
27596
27597 if (!SWIG_Python_UnpackTuple(args,"new_PseudoDC",0,0,0)) SWIG_fail;
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (wxPseudoDC *)new wxPseudoDC();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_NEW | 0 );
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_PseudoDC_BeginDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxPseudoDC *arg1 = (wxPseudoDC *) 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_wxPseudoDC, 0 | 0 );
27621 if (!SWIG_IsOK(res1)) {
27622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_BeginDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27623 }
27624 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 (arg1)->BeginDrawing();
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = SWIG_Py_Void();
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 SWIGINTERN PyObject *_wrap_PseudoDC_EndDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *resultobj = 0;
27640 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27641 void *argp1 = 0 ;
27642 int res1 = 0 ;
27643 PyObject *swig_obj[1] ;
27644
27645 if (!args) SWIG_fail;
27646 swig_obj[0] = args;
27647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27648 if (!SWIG_IsOK(res1)) {
27649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_EndDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27650 }
27651 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27652 {
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 (arg1)->EndDrawing();
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 resultobj = SWIG_Py_Void();
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *_wrap_delete_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27666 PyObject *resultobj = 0;
27667 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27668 void *argp1 = 0 ;
27669 int res1 = 0 ;
27670 PyObject *swig_obj[1] ;
27671
27672 if (!args) SWIG_fail;
27673 swig_obj[0] = args;
27674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_DISOWN | 0 );
27675 if (!SWIG_IsOK(res1)) {
27676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PseudoDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27677 }
27678 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27679 {
27680 PyThreadState* __tstate = wxPyBeginAllowThreads();
27681 delete arg1;
27682
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 resultobj = SWIG_Py_Void();
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27694 PyObject *resultobj = 0;
27695 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 PyObject *swig_obj[1] ;
27699
27700 if (!args) SWIG_fail;
27701 swig_obj[0] = args;
27702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27703 if (!SWIG_IsOK(res1)) {
27704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveAll" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27705 }
27706 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 (arg1)->RemoveAll();
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 resultobj = SWIG_Py_Void();
27714 return resultobj;
27715 fail:
27716 return NULL;
27717 }
27718
27719
27720 SWIGINTERN PyObject *_wrap_PseudoDC_GetLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27721 PyObject *resultobj = 0;
27722 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27723 int result;
27724 void *argp1 = 0 ;
27725 int res1 = 0 ;
27726 PyObject *swig_obj[1] ;
27727
27728 if (!args) SWIG_fail;
27729 swig_obj[0] = args;
27730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27731 if (!SWIG_IsOK(res1)) {
27732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetLen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27733 }
27734 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 result = (int)(arg1)->GetLen();
27738 wxPyEndAllowThreads(__tstate);
27739 if (PyErr_Occurred()) SWIG_fail;
27740 }
27741 resultobj = SWIG_From_int(static_cast< int >(result));
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_PseudoDC_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27749 PyObject *resultobj = 0;
27750 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27751 int arg2 ;
27752 void *argp1 = 0 ;
27753 int res1 = 0 ;
27754 int val2 ;
27755 int ecode2 = 0 ;
27756 PyObject * obj0 = 0 ;
27757 PyObject * obj1 = 0 ;
27758 char * kwnames[] = {
27759 (char *) "self",(char *) "id", NULL
27760 };
27761
27762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
27763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27764 if (!SWIG_IsOK(res1)) {
27765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27766 }
27767 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27768 ecode2 = SWIG_AsVal_int(obj1, &val2);
27769 if (!SWIG_IsOK(ecode2)) {
27770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetId" "', expected argument " "2"" of type '" "int""'");
27771 }
27772 arg2 = static_cast< int >(val2);
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 (arg1)->SetId(arg2);
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_Py_Void();
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_PseudoDC_ClearId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj = 0;
27788 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27789 int arg2 ;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 int val2 ;
27793 int ecode2 = 0 ;
27794 PyObject * obj0 = 0 ;
27795 PyObject * obj1 = 0 ;
27796 char * kwnames[] = {
27797 (char *) "self",(char *) "id", NULL
27798 };
27799
27800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_ClearId",kwnames,&obj0,&obj1)) SWIG_fail;
27801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_ClearId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27804 }
27805 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27806 ecode2 = SWIG_AsVal_int(obj1, &val2);
27807 if (!SWIG_IsOK(ecode2)) {
27808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_ClearId" "', expected argument " "2"" of type '" "int""'");
27809 }
27810 arg2 = static_cast< int >(val2);
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 (arg1)->ClearId(arg2);
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 resultobj = SWIG_Py_Void();
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj = 0;
27826 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27827 int arg2 ;
27828 void *argp1 = 0 ;
27829 int res1 = 0 ;
27830 int val2 ;
27831 int ecode2 = 0 ;
27832 PyObject * obj0 = 0 ;
27833 PyObject * obj1 = 0 ;
27834 char * kwnames[] = {
27835 (char *) "self",(char *) "id", NULL
27836 };
27837
27838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_RemoveId",kwnames,&obj0,&obj1)) SWIG_fail;
27839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27840 if (!SWIG_IsOK(res1)) {
27841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27842 }
27843 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27844 ecode2 = SWIG_AsVal_int(obj1, &val2);
27845 if (!SWIG_IsOK(ecode2)) {
27846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_RemoveId" "', expected argument " "2"" of type '" "int""'");
27847 }
27848 arg2 = static_cast< int >(val2);
27849 {
27850 PyThreadState* __tstate = wxPyBeginAllowThreads();
27851 (arg1)->RemoveId(arg2);
27852 wxPyEndAllowThreads(__tstate);
27853 if (PyErr_Occurred()) SWIG_fail;
27854 }
27855 resultobj = SWIG_Py_Void();
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_PseudoDC_TranslateId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj = 0;
27864 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27865 int arg2 ;
27866 int arg3 ;
27867 int arg4 ;
27868 void *argp1 = 0 ;
27869 int res1 = 0 ;
27870 int val2 ;
27871 int ecode2 = 0 ;
27872 int val3 ;
27873 int ecode3 = 0 ;
27874 int val4 ;
27875 int ecode4 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 PyObject * obj2 = 0 ;
27879 PyObject * obj3 = 0 ;
27880 char * kwnames[] = {
27881 (char *) "self",(char *) "id",(char *) "dx",(char *) "dy", NULL
27882 };
27883
27884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_TranslateId",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27886 if (!SWIG_IsOK(res1)) {
27887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_TranslateId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27888 }
27889 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27890 ecode2 = SWIG_AsVal_int(obj1, &val2);
27891 if (!SWIG_IsOK(ecode2)) {
27892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_TranslateId" "', expected argument " "2"" of type '" "int""'");
27893 }
27894 arg2 = static_cast< int >(val2);
27895 ecode3 = SWIG_AsVal_int(obj2, &val3);
27896 if (!SWIG_IsOK(ecode3)) {
27897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_TranslateId" "', expected argument " "3"" of type '" "int""'");
27898 }
27899 arg3 = static_cast< int >(val3);
27900 ecode4 = SWIG_AsVal_int(obj3, &val4);
27901 if (!SWIG_IsOK(ecode4)) {
27902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_TranslateId" "', expected argument " "4"" of type '" "int""'");
27903 }
27904 arg4 = static_cast< int >(val4);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 (arg1)->TranslateId(arg2,arg3,arg4);
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 resultobj = SWIG_Py_Void();
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIdToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27919 PyObject *resultobj = 0;
27920 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27921 int arg2 ;
27922 wxDC *arg3 = (wxDC *) 0 ;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 int val2 ;
27926 int ecode2 = 0 ;
27927 void *argp3 = 0 ;
27928 int res3 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 PyObject * obj2 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "id",(char *) "dc", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIdToDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27940 }
27941 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27942 ecode2 = SWIG_AsVal_int(obj1, &val2);
27943 if (!SWIG_IsOK(ecode2)) {
27944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "2"" of type '" "int""'");
27945 }
27946 arg2 = static_cast< int >(val2);
27947 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxDC, 0 | 0 );
27948 if (!SWIG_IsOK(res3)) {
27949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "3"" of type '" "wxDC *""'");
27950 }
27951 arg3 = reinterpret_cast< wxDC * >(argp3);
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 (arg1)->DrawIdToDC(arg2,arg3);
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 resultobj = SWIG_Py_Void();
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 SWIGINTERN PyObject *_wrap_PseudoDC_SetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj = 0;
27967 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27968 int arg2 ;
27969 wxRect *arg3 = 0 ;
27970 void *argp1 = 0 ;
27971 int res1 = 0 ;
27972 int val2 ;
27973 int ecode2 = 0 ;
27974 wxRect temp3 ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 PyObject * obj2 = 0 ;
27978 char * kwnames[] = {
27979 (char *) "self",(char *) "id",(char *) "rect", NULL
27980 };
27981
27982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_SetIdBounds",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27984 if (!SWIG_IsOK(res1)) {
27985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27986 }
27987 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27988 ecode2 = SWIG_AsVal_int(obj1, &val2);
27989 if (!SWIG_IsOK(ecode2)) {
27990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "2"" of type '" "int""'");
27991 }
27992 arg2 = static_cast< int >(val2);
27993 {
27994 arg3 = &temp3;
27995 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
27996 }
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 (arg1)->SetIdBounds(arg2,*arg3);
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 resultobj = SWIG_Py_Void();
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 SWIGINTERN PyObject *_wrap_PseudoDC_GetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj = 0;
28012 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28013 int arg2 ;
28014 wxRect result;
28015 void *argp1 = 0 ;
28016 int res1 = 0 ;
28017 int val2 ;
28018 int ecode2 = 0 ;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char * kwnames[] = {
28022 (char *) "self",(char *) "id", NULL
28023 };
28024
28025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_GetIdBounds",kwnames,&obj0,&obj1)) SWIG_fail;
28026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28027 if (!SWIG_IsOK(res1)) {
28028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28029 }
28030 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28031 ecode2 = SWIG_AsVal_int(obj1, &val2);
28032 if (!SWIG_IsOK(ecode2)) {
28033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "2"" of type '" "int""'");
28034 }
28035 arg2 = static_cast< int >(val2);
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = wxPseudoDC_GetIdBounds(arg1,arg2);
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj = 0;
28051 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28052 wxDC *arg2 = (wxDC *) 0 ;
28053 wxRect *arg3 = 0 ;
28054 void *argp1 = 0 ;
28055 int res1 = 0 ;
28056 void *argp2 = 0 ;
28057 int res2 = 0 ;
28058 wxRect temp3 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 PyObject * obj2 = 0 ;
28062 char * kwnames[] = {
28063 (char *) "self",(char *) "dc",(char *) "rect", NULL
28064 };
28065
28066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClipped",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28068 if (!SWIG_IsOK(res1)) {
28069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28070 }
28071 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28073 if (!SWIG_IsOK(res2)) {
28074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "2"" of type '" "wxDC *""'");
28075 }
28076 arg2 = reinterpret_cast< wxDC * >(argp2);
28077 {
28078 arg3 = &temp3;
28079 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
28080 }
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 (arg1)->DrawToDCClipped(arg2,(wxRect const &)*arg3);
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClippedRgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj = 0;
28096 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28097 wxDC *arg2 = (wxDC *) 0 ;
28098 wxRegion *arg3 = 0 ;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 void *argp2 = 0 ;
28102 int res2 = 0 ;
28103 void *argp3 = 0 ;
28104 int res3 = 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 PyObject * obj2 = 0 ;
28108 char * kwnames[] = {
28109 (char *) "self",(char *) "dc",(char *) "region", NULL
28110 };
28111
28112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClippedRgn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28114 if (!SWIG_IsOK(res1)) {
28115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28116 }
28117 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28119 if (!SWIG_IsOK(res2)) {
28120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "2"" of type '" "wxDC *""'");
28121 }
28122 arg2 = reinterpret_cast< wxDC * >(argp2);
28123 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRegion, 0 | 0);
28124 if (!SWIG_IsOK(res3)) {
28125 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
28126 }
28127 if (!argp3) {
28128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
28129 }
28130 arg3 = reinterpret_cast< wxRegion * >(argp3);
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 (arg1)->DrawToDCClippedRgn(arg2,(wxRegion const &)*arg3);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_Py_Void();
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj = 0;
28146 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28147 wxDC *arg2 = (wxDC *) 0 ;
28148 void *argp1 = 0 ;
28149 int res1 = 0 ;
28150 void *argp2 = 0 ;
28151 int res2 = 0 ;
28152 PyObject * obj0 = 0 ;
28153 PyObject * obj1 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "self",(char *) "dc", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawToDC",kwnames,&obj0,&obj1)) SWIG_fail;
28159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28160 if (!SWIG_IsOK(res1)) {
28161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28162 }
28163 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28165 if (!SWIG_IsOK(res2)) {
28166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDC" "', expected argument " "2"" of type '" "wxDC *""'");
28167 }
28168 arg2 = reinterpret_cast< wxDC * >(argp2);
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 (arg1)->DrawToDC(arg2);
28172 wxPyEndAllowThreads(__tstate);
28173 if (PyErr_Occurred()) SWIG_fail;
28174 }
28175 resultobj = SWIG_Py_Void();
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj = 0;
28184 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28185 int arg2 ;
28186 int arg3 ;
28187 wxColour *arg4 = 0 ;
28188 int arg5 = (int) wxFLOOD_SURFACE ;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 int val2 ;
28192 int ecode2 = 0 ;
28193 int val3 ;
28194 int ecode3 = 0 ;
28195 wxColour temp4 ;
28196 int val5 ;
28197 int ecode5 = 0 ;
28198 PyObject * obj0 = 0 ;
28199 PyObject * obj1 = 0 ;
28200 PyObject * obj2 = 0 ;
28201 PyObject * obj3 = 0 ;
28202 PyObject * obj4 = 0 ;
28203 char * kwnames[] = {
28204 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
28205 };
28206
28207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28209 if (!SWIG_IsOK(res1)) {
28210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFill" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28211 }
28212 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28213 ecode2 = SWIG_AsVal_int(obj1, &val2);
28214 if (!SWIG_IsOK(ecode2)) {
28215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_FloodFill" "', expected argument " "2"" of type '" "int""'");
28216 }
28217 arg2 = static_cast< int >(val2);
28218 ecode3 = SWIG_AsVal_int(obj2, &val3);
28219 if (!SWIG_IsOK(ecode3)) {
28220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_FloodFill" "', expected argument " "3"" of type '" "int""'");
28221 }
28222 arg3 = static_cast< int >(val3);
28223 {
28224 arg4 = &temp4;
28225 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
28226 }
28227 if (obj4) {
28228 ecode5 = SWIG_AsVal_int(obj4, &val5);
28229 if (!SWIG_IsOK(ecode5)) {
28230 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_FloodFill" "', expected argument " "5"" of type '" "int""'");
28231 }
28232 arg5 = static_cast< int >(val5);
28233 }
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 (arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_Py_Void();
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28248 PyObject *resultobj = 0;
28249 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28250 wxPoint *arg2 = 0 ;
28251 wxColour *arg3 = 0 ;
28252 int arg4 = (int) wxFLOOD_SURFACE ;
28253 void *argp1 = 0 ;
28254 int res1 = 0 ;
28255 wxPoint temp2 ;
28256 wxColour temp3 ;
28257 int val4 ;
28258 int ecode4 = 0 ;
28259 PyObject * obj0 = 0 ;
28260 PyObject * obj1 = 0 ;
28261 PyObject * obj2 = 0 ;
28262 PyObject * obj3 = 0 ;
28263 char * kwnames[] = {
28264 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
28265 };
28266
28267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28269 if (!SWIG_IsOK(res1)) {
28270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28271 }
28272 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28273 {
28274 arg2 = &temp2;
28275 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28276 }
28277 {
28278 arg3 = &temp3;
28279 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
28280 }
28281 if (obj3) {
28282 ecode4 = SWIG_AsVal_int(obj3, &val4);
28283 if (!SWIG_IsOK(ecode4)) {
28284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
28285 }
28286 arg4 = static_cast< int >(val4);
28287 }
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 (arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 resultobj = SWIG_Py_Void();
28295 return resultobj;
28296 fail:
28297 return NULL;
28298 }
28299
28300
28301 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28302 PyObject *resultobj = 0;
28303 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28304 int arg2 ;
28305 int arg3 ;
28306 int arg4 ;
28307 int arg5 ;
28308 void *argp1 = 0 ;
28309 int res1 = 0 ;
28310 int val2 ;
28311 int ecode2 = 0 ;
28312 int val3 ;
28313 int ecode3 = 0 ;
28314 int val4 ;
28315 int ecode4 = 0 ;
28316 int val5 ;
28317 int ecode5 = 0 ;
28318 PyObject * obj0 = 0 ;
28319 PyObject * obj1 = 0 ;
28320 PyObject * obj2 = 0 ;
28321 PyObject * obj3 = 0 ;
28322 PyObject * obj4 = 0 ;
28323 char * kwnames[] = {
28324 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
28325 };
28326
28327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28329 if (!SWIG_IsOK(res1)) {
28330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLine" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28331 }
28332 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28333 ecode2 = SWIG_AsVal_int(obj1, &val2);
28334 if (!SWIG_IsOK(ecode2)) {
28335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawLine" "', expected argument " "2"" of type '" "int""'");
28336 }
28337 arg2 = static_cast< int >(val2);
28338 ecode3 = SWIG_AsVal_int(obj2, &val3);
28339 if (!SWIG_IsOK(ecode3)) {
28340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawLine" "', expected argument " "3"" of type '" "int""'");
28341 }
28342 arg3 = static_cast< int >(val3);
28343 ecode4 = SWIG_AsVal_int(obj3, &val4);
28344 if (!SWIG_IsOK(ecode4)) {
28345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLine" "', expected argument " "4"" of type '" "int""'");
28346 }
28347 arg4 = static_cast< int >(val4);
28348 ecode5 = SWIG_AsVal_int(obj4, &val5);
28349 if (!SWIG_IsOK(ecode5)) {
28350 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLine" "', expected argument " "5"" of type '" "int""'");
28351 }
28352 arg5 = static_cast< int >(val5);
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 resultobj = SWIG_Py_Void();
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28367 PyObject *resultobj = 0;
28368 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28369 wxPoint *arg2 = 0 ;
28370 wxPoint *arg3 = 0 ;
28371 void *argp1 = 0 ;
28372 int res1 = 0 ;
28373 wxPoint temp2 ;
28374 wxPoint temp3 ;
28375 PyObject * obj0 = 0 ;
28376 PyObject * obj1 = 0 ;
28377 PyObject * obj2 = 0 ;
28378 char * kwnames[] = {
28379 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
28380 };
28381
28382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28384 if (!SWIG_IsOK(res1)) {
28385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLinePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28386 }
28387 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28388 {
28389 arg2 = &temp2;
28390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28391 }
28392 {
28393 arg3 = &temp3;
28394 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28395 }
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_Py_Void();
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28410 PyObject *resultobj = 0;
28411 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28412 int arg2 ;
28413 int arg3 ;
28414 void *argp1 = 0 ;
28415 int res1 = 0 ;
28416 int val2 ;
28417 int ecode2 = 0 ;
28418 int val3 ;
28419 int ecode3 = 0 ;
28420 PyObject * obj0 = 0 ;
28421 PyObject * obj1 = 0 ;
28422 PyObject * obj2 = 0 ;
28423 char * kwnames[] = {
28424 (char *) "self",(char *) "x",(char *) "y", NULL
28425 };
28426
28427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28429 if (!SWIG_IsOK(res1)) {
28430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHair" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28431 }
28432 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28433 ecode2 = SWIG_AsVal_int(obj1, &val2);
28434 if (!SWIG_IsOK(ecode2)) {
28435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_CrossHair" "', expected argument " "2"" of type '" "int""'");
28436 }
28437 arg2 = static_cast< int >(val2);
28438 ecode3 = SWIG_AsVal_int(obj2, &val3);
28439 if (!SWIG_IsOK(ecode3)) {
28440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_CrossHair" "', expected argument " "3"" of type '" "int""'");
28441 }
28442 arg3 = static_cast< int >(val3);
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 (arg1)->CrossHair(arg2,arg3);
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 resultobj = SWIG_Py_Void();
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj = 0;
28458 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28459 wxPoint *arg2 = 0 ;
28460 void *argp1 = 0 ;
28461 int res1 = 0 ;
28462 wxPoint temp2 ;
28463 PyObject * obj0 = 0 ;
28464 PyObject * obj1 = 0 ;
28465 char * kwnames[] = {
28466 (char *) "self",(char *) "pt", NULL
28467 };
28468
28469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
28470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28471 if (!SWIG_IsOK(res1)) {
28472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHairPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28473 }
28474 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28475 {
28476 arg2 = &temp2;
28477 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28478 }
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 (arg1)->CrossHair((wxPoint const &)*arg2);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj = 0;
28494 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28495 int arg2 ;
28496 int arg3 ;
28497 int arg4 ;
28498 int arg5 ;
28499 int arg6 ;
28500 int arg7 ;
28501 void *argp1 = 0 ;
28502 int res1 = 0 ;
28503 int val2 ;
28504 int ecode2 = 0 ;
28505 int val3 ;
28506 int ecode3 = 0 ;
28507 int val4 ;
28508 int ecode4 = 0 ;
28509 int val5 ;
28510 int ecode5 = 0 ;
28511 int val6 ;
28512 int ecode6 = 0 ;
28513 int val7 ;
28514 int ecode7 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 PyObject * obj2 = 0 ;
28518 PyObject * obj3 = 0 ;
28519 PyObject * obj4 = 0 ;
28520 PyObject * obj5 = 0 ;
28521 PyObject * obj6 = 0 ;
28522 char * kwnames[] = {
28523 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
28524 };
28525
28526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28528 if (!SWIG_IsOK(res1)) {
28529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28530 }
28531 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28532 ecode2 = SWIG_AsVal_int(obj1, &val2);
28533 if (!SWIG_IsOK(ecode2)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawArc" "', expected argument " "2"" of type '" "int""'");
28535 }
28536 arg2 = static_cast< int >(val2);
28537 ecode3 = SWIG_AsVal_int(obj2, &val3);
28538 if (!SWIG_IsOK(ecode3)) {
28539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawArc" "', expected argument " "3"" of type '" "int""'");
28540 }
28541 arg3 = static_cast< int >(val3);
28542 ecode4 = SWIG_AsVal_int(obj3, &val4);
28543 if (!SWIG_IsOK(ecode4)) {
28544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawArc" "', expected argument " "4"" of type '" "int""'");
28545 }
28546 arg4 = static_cast< int >(val4);
28547 ecode5 = SWIG_AsVal_int(obj4, &val5);
28548 if (!SWIG_IsOK(ecode5)) {
28549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawArc" "', expected argument " "5"" of type '" "int""'");
28550 }
28551 arg5 = static_cast< int >(val5);
28552 ecode6 = SWIG_AsVal_int(obj5, &val6);
28553 if (!SWIG_IsOK(ecode6)) {
28554 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawArc" "', expected argument " "6"" of type '" "int""'");
28555 }
28556 arg6 = static_cast< int >(val6);
28557 ecode7 = SWIG_AsVal_int(obj6, &val7);
28558 if (!SWIG_IsOK(ecode7)) {
28559 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawArc" "', expected argument " "7"" of type '" "int""'");
28560 }
28561 arg7 = static_cast< int >(val7);
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_Py_Void();
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj = 0;
28577 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28578 wxPoint *arg2 = 0 ;
28579 wxPoint *arg3 = 0 ;
28580 wxPoint *arg4 = 0 ;
28581 void *argp1 = 0 ;
28582 int res1 = 0 ;
28583 wxPoint temp2 ;
28584 wxPoint temp3 ;
28585 wxPoint temp4 ;
28586 PyObject * obj0 = 0 ;
28587 PyObject * obj1 = 0 ;
28588 PyObject * obj2 = 0 ;
28589 PyObject * obj3 = 0 ;
28590 char * kwnames[] = {
28591 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
28592 };
28593
28594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArcPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28598 }
28599 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28600 {
28601 arg2 = &temp2;
28602 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28603 }
28604 {
28605 arg3 = &temp3;
28606 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28607 }
28608 {
28609 arg4 = &temp4;
28610 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
28611 }
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 resultobj = SWIG_Py_Void();
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28626 PyObject *resultobj = 0;
28627 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28628 int arg2 ;
28629 int arg3 ;
28630 int arg4 ;
28631 int arg5 ;
28632 void *argp1 = 0 ;
28633 int res1 = 0 ;
28634 int val2 ;
28635 int ecode2 = 0 ;
28636 int val3 ;
28637 int ecode3 = 0 ;
28638 int val4 ;
28639 int ecode4 = 0 ;
28640 int val5 ;
28641 int ecode5 = 0 ;
28642 PyObject * obj0 = 0 ;
28643 PyObject * obj1 = 0 ;
28644 PyObject * obj2 = 0 ;
28645 PyObject * obj3 = 0 ;
28646 PyObject * obj4 = 0 ;
28647 char * kwnames[] = {
28648 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
28649 };
28650
28651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28653 if (!SWIG_IsOK(res1)) {
28654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28655 }
28656 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28657 ecode2 = SWIG_AsVal_int(obj1, &val2);
28658 if (!SWIG_IsOK(ecode2)) {
28659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
28660 }
28661 arg2 = static_cast< int >(val2);
28662 ecode3 = SWIG_AsVal_int(obj2, &val3);
28663 if (!SWIG_IsOK(ecode3)) {
28664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
28665 }
28666 arg3 = static_cast< int >(val3);
28667 ecode4 = SWIG_AsVal_int(obj3, &val4);
28668 if (!SWIG_IsOK(ecode4)) {
28669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
28670 }
28671 arg4 = static_cast< int >(val4);
28672 ecode5 = SWIG_AsVal_int(obj4, &val5);
28673 if (!SWIG_IsOK(ecode5)) {
28674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
28675 }
28676 arg5 = static_cast< int >(val5);
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
28680 wxPyEndAllowThreads(__tstate);
28681 if (PyErr_Occurred()) SWIG_fail;
28682 }
28683 resultobj = SWIG_Py_Void();
28684 return resultobj;
28685 fail:
28686 return NULL;
28687 }
28688
28689
28690 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28693 wxRect *arg2 = 0 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 wxRect temp2 ;
28697 PyObject * obj0 = 0 ;
28698 PyObject * obj1 = 0 ;
28699 char * kwnames[] = {
28700 (char *) "self",(char *) "rect", NULL
28701 };
28702
28703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
28704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28705 if (!SWIG_IsOK(res1)) {
28706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28707 }
28708 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28709 {
28710 arg2 = &temp2;
28711 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28712 }
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 (arg1)->DrawCheckMark((wxRect const &)*arg2);
28716 wxPyEndAllowThreads(__tstate);
28717 if (PyErr_Occurred()) SWIG_fail;
28718 }
28719 resultobj = SWIG_Py_Void();
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj = 0;
28728 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28729 int arg2 ;
28730 int arg3 ;
28731 int arg4 ;
28732 int arg5 ;
28733 double arg6 ;
28734 double arg7 ;
28735 void *argp1 = 0 ;
28736 int res1 = 0 ;
28737 int val2 ;
28738 int ecode2 = 0 ;
28739 int val3 ;
28740 int ecode3 = 0 ;
28741 int val4 ;
28742 int ecode4 = 0 ;
28743 int val5 ;
28744 int ecode5 = 0 ;
28745 double val6 ;
28746 int ecode6 = 0 ;
28747 double val7 ;
28748 int ecode7 = 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 PyObject * obj2 = 0 ;
28752 PyObject * obj3 = 0 ;
28753 PyObject * obj4 = 0 ;
28754 PyObject * obj5 = 0 ;
28755 PyObject * obj6 = 0 ;
28756 char * kwnames[] = {
28757 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
28758 };
28759
28760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28762 if (!SWIG_IsOK(res1)) {
28763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28764 }
28765 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28766 ecode2 = SWIG_AsVal_int(obj1, &val2);
28767 if (!SWIG_IsOK(ecode2)) {
28768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
28769 }
28770 arg2 = static_cast< int >(val2);
28771 ecode3 = SWIG_AsVal_int(obj2, &val3);
28772 if (!SWIG_IsOK(ecode3)) {
28773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
28774 }
28775 arg3 = static_cast< int >(val3);
28776 ecode4 = SWIG_AsVal_int(obj3, &val4);
28777 if (!SWIG_IsOK(ecode4)) {
28778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
28779 }
28780 arg4 = static_cast< int >(val4);
28781 ecode5 = SWIG_AsVal_int(obj4, &val5);
28782 if (!SWIG_IsOK(ecode5)) {
28783 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
28784 }
28785 arg5 = static_cast< int >(val5);
28786 ecode6 = SWIG_AsVal_double(obj5, &val6);
28787 if (!SWIG_IsOK(ecode6)) {
28788 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
28789 }
28790 arg6 = static_cast< double >(val6);
28791 ecode7 = SWIG_AsVal_double(obj6, &val7);
28792 if (!SWIG_IsOK(ecode7)) {
28793 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
28794 }
28795 arg7 = static_cast< double >(val7);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_Py_Void();
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj = 0;
28811 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28812 wxPoint *arg2 = 0 ;
28813 wxSize *arg3 = 0 ;
28814 double arg4 ;
28815 double arg5 ;
28816 void *argp1 = 0 ;
28817 int res1 = 0 ;
28818 wxPoint temp2 ;
28819 wxSize temp3 ;
28820 double val4 ;
28821 int ecode4 = 0 ;
28822 double val5 ;
28823 int ecode5 = 0 ;
28824 PyObject * obj0 = 0 ;
28825 PyObject * obj1 = 0 ;
28826 PyObject * obj2 = 0 ;
28827 PyObject * obj3 = 0 ;
28828 PyObject * obj4 = 0 ;
28829 char * kwnames[] = {
28830 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
28831 };
28832
28833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28835 if (!SWIG_IsOK(res1)) {
28836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28837 }
28838 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28839 {
28840 arg2 = &temp2;
28841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28842 }
28843 {
28844 arg3 = &temp3;
28845 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
28846 }
28847 ecode4 = SWIG_AsVal_double(obj3, &val4);
28848 if (!SWIG_IsOK(ecode4)) {
28849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
28850 }
28851 arg4 = static_cast< double >(val4);
28852 ecode5 = SWIG_AsVal_double(obj4, &val5);
28853 if (!SWIG_IsOK(ecode5)) {
28854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
28855 }
28856 arg5 = static_cast< double >(val5);
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_Py_Void();
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj = 0;
28872 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28873 int arg2 ;
28874 int arg3 ;
28875 void *argp1 = 0 ;
28876 int res1 = 0 ;
28877 int val2 ;
28878 int ecode2 = 0 ;
28879 int val3 ;
28880 int ecode3 = 0 ;
28881 PyObject * obj0 = 0 ;
28882 PyObject * obj1 = 0 ;
28883 PyObject * obj2 = 0 ;
28884 char * kwnames[] = {
28885 (char *) "self",(char *) "x",(char *) "y", NULL
28886 };
28887
28888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28892 }
28893 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28894 ecode2 = SWIG_AsVal_int(obj1, &val2);
28895 if (!SWIG_IsOK(ecode2)) {
28896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
28897 }
28898 arg2 = static_cast< int >(val2);
28899 ecode3 = SWIG_AsVal_int(obj2, &val3);
28900 if (!SWIG_IsOK(ecode3)) {
28901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
28902 }
28903 arg3 = static_cast< int >(val3);
28904 {
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 (arg1)->DrawPoint(arg2,arg3);
28907 wxPyEndAllowThreads(__tstate);
28908 if (PyErr_Occurred()) SWIG_fail;
28909 }
28910 resultobj = SWIG_Py_Void();
28911 return resultobj;
28912 fail:
28913 return NULL;
28914 }
28915
28916
28917 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28918 PyObject *resultobj = 0;
28919 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28920 wxPoint *arg2 = 0 ;
28921 void *argp1 = 0 ;
28922 int res1 = 0 ;
28923 wxPoint temp2 ;
28924 PyObject * obj0 = 0 ;
28925 PyObject * obj1 = 0 ;
28926 char * kwnames[] = {
28927 (char *) "self",(char *) "pt", NULL
28928 };
28929
28930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
28931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28932 if (!SWIG_IsOK(res1)) {
28933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPointPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28934 }
28935 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28936 {
28937 arg2 = &temp2;
28938 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28939 }
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 (arg1)->DrawPoint((wxPoint const &)*arg2);
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 resultobj = SWIG_Py_Void();
28947 return resultobj;
28948 fail:
28949 return NULL;
28950 }
28951
28952
28953 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28954 PyObject *resultobj = 0;
28955 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28956 int arg2 ;
28957 int arg3 ;
28958 int arg4 ;
28959 int arg5 ;
28960 void *argp1 = 0 ;
28961 int res1 = 0 ;
28962 int val2 ;
28963 int ecode2 = 0 ;
28964 int val3 ;
28965 int ecode3 = 0 ;
28966 int val4 ;
28967 int ecode4 = 0 ;
28968 int val5 ;
28969 int ecode5 = 0 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 PyObject * obj2 = 0 ;
28973 PyObject * obj3 = 0 ;
28974 PyObject * obj4 = 0 ;
28975 char * kwnames[] = {
28976 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
28977 };
28978
28979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28981 if (!SWIG_IsOK(res1)) {
28982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28983 }
28984 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28985 ecode2 = SWIG_AsVal_int(obj1, &val2);
28986 if (!SWIG_IsOK(ecode2)) {
28987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
28988 }
28989 arg2 = static_cast< int >(val2);
28990 ecode3 = SWIG_AsVal_int(obj2, &val3);
28991 if (!SWIG_IsOK(ecode3)) {
28992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
28993 }
28994 arg3 = static_cast< int >(val3);
28995 ecode4 = SWIG_AsVal_int(obj3, &val4);
28996 if (!SWIG_IsOK(ecode4)) {
28997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
28998 }
28999 arg4 = static_cast< int >(val4);
29000 ecode5 = SWIG_AsVal_int(obj4, &val5);
29001 if (!SWIG_IsOK(ecode5)) {
29002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
29003 }
29004 arg5 = static_cast< int >(val5);
29005 {
29006 PyThreadState* __tstate = wxPyBeginAllowThreads();
29007 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 resultobj = SWIG_Py_Void();
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj = 0;
29020 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29021 wxRect *arg2 = 0 ;
29022 void *argp1 = 0 ;
29023 int res1 = 0 ;
29024 wxRect temp2 ;
29025 PyObject * obj0 = 0 ;
29026 PyObject * obj1 = 0 ;
29027 char * kwnames[] = {
29028 (char *) "self",(char *) "rect", NULL
29029 };
29030
29031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
29032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29033 if (!SWIG_IsOK(res1)) {
29034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29035 }
29036 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29037 {
29038 arg2 = &temp2;
29039 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29040 }
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 (arg1)->DrawRectangle((wxRect const &)*arg2);
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 resultobj = SWIG_Py_Void();
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29055 PyObject *resultobj = 0;
29056 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29057 wxPoint *arg2 = 0 ;
29058 wxSize *arg3 = 0 ;
29059 void *argp1 = 0 ;
29060 int res1 = 0 ;
29061 wxPoint temp2 ;
29062 wxSize temp3 ;
29063 PyObject * obj0 = 0 ;
29064 PyObject * obj1 = 0 ;
29065 PyObject * obj2 = 0 ;
29066 char * kwnames[] = {
29067 (char *) "self",(char *) "pt",(char *) "sz", NULL
29068 };
29069
29070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29072 if (!SWIG_IsOK(res1)) {
29073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29074 }
29075 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29076 {
29077 arg2 = &temp2;
29078 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29079 }
29080 {
29081 arg3 = &temp3;
29082 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29083 }
29084 {
29085 PyThreadState* __tstate = wxPyBeginAllowThreads();
29086 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
29087 wxPyEndAllowThreads(__tstate);
29088 if (PyErr_Occurred()) SWIG_fail;
29089 }
29090 resultobj = SWIG_Py_Void();
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj = 0;
29099 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29100 int arg2 ;
29101 int arg3 ;
29102 int arg4 ;
29103 int arg5 ;
29104 double arg6 ;
29105 void *argp1 = 0 ;
29106 int res1 = 0 ;
29107 int val2 ;
29108 int ecode2 = 0 ;
29109 int val3 ;
29110 int ecode3 = 0 ;
29111 int val4 ;
29112 int ecode4 = 0 ;
29113 int val5 ;
29114 int ecode5 = 0 ;
29115 double val6 ;
29116 int ecode6 = 0 ;
29117 PyObject * obj0 = 0 ;
29118 PyObject * obj1 = 0 ;
29119 PyObject * obj2 = 0 ;
29120 PyObject * obj3 = 0 ;
29121 PyObject * obj4 = 0 ;
29122 PyObject * obj5 = 0 ;
29123 char * kwnames[] = {
29124 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
29125 };
29126
29127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:PseudoDC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29129 if (!SWIG_IsOK(res1)) {
29130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29131 }
29132 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29133 ecode2 = SWIG_AsVal_int(obj1, &val2);
29134 if (!SWIG_IsOK(ecode2)) {
29135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
29136 }
29137 arg2 = static_cast< int >(val2);
29138 ecode3 = SWIG_AsVal_int(obj2, &val3);
29139 if (!SWIG_IsOK(ecode3)) {
29140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
29141 }
29142 arg3 = static_cast< int >(val3);
29143 ecode4 = SWIG_AsVal_int(obj3, &val4);
29144 if (!SWIG_IsOK(ecode4)) {
29145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
29146 }
29147 arg4 = static_cast< int >(val4);
29148 ecode5 = SWIG_AsVal_int(obj4, &val5);
29149 if (!SWIG_IsOK(ecode5)) {
29150 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
29151 }
29152 arg5 = static_cast< int >(val5);
29153 ecode6 = SWIG_AsVal_double(obj5, &val6);
29154 if (!SWIG_IsOK(ecode6)) {
29155 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
29156 }
29157 arg6 = static_cast< double >(val6);
29158 {
29159 PyThreadState* __tstate = wxPyBeginAllowThreads();
29160 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 resultobj = SWIG_Py_Void();
29165 return resultobj;
29166 fail:
29167 return NULL;
29168 }
29169
29170
29171 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj = 0;
29173 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29174 wxRect *arg2 = 0 ;
29175 double arg3 ;
29176 void *argp1 = 0 ;
29177 int res1 = 0 ;
29178 wxRect temp2 ;
29179 double val3 ;
29180 int ecode3 = 0 ;
29181 PyObject * obj0 = 0 ;
29182 PyObject * obj1 = 0 ;
29183 PyObject * obj2 = 0 ;
29184 char * kwnames[] = {
29185 (char *) "self",(char *) "r",(char *) "radius", NULL
29186 };
29187
29188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29190 if (!SWIG_IsOK(res1)) {
29191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29192 }
29193 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29194 {
29195 arg2 = &temp2;
29196 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29197 }
29198 ecode3 = SWIG_AsVal_double(obj2, &val3);
29199 if (!SWIG_IsOK(ecode3)) {
29200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
29201 }
29202 arg3 = static_cast< double >(val3);
29203 {
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 resultobj = SWIG_Py_Void();
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj = 0;
29218 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29219 wxPoint *arg2 = 0 ;
29220 wxSize *arg3 = 0 ;
29221 double arg4 ;
29222 void *argp1 = 0 ;
29223 int res1 = 0 ;
29224 wxPoint temp2 ;
29225 wxSize temp3 ;
29226 double val4 ;
29227 int ecode4 = 0 ;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 PyObject * obj2 = 0 ;
29231 PyObject * obj3 = 0 ;
29232 char * kwnames[] = {
29233 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
29234 };
29235
29236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29238 if (!SWIG_IsOK(res1)) {
29239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29240 }
29241 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29242 {
29243 arg2 = &temp2;
29244 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29245 }
29246 {
29247 arg3 = &temp3;
29248 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29249 }
29250 ecode4 = SWIG_AsVal_double(obj3, &val4);
29251 if (!SWIG_IsOK(ecode4)) {
29252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
29253 }
29254 arg4 = static_cast< double >(val4);
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 resultobj = SWIG_Py_Void();
29262 return resultobj;
29263 fail:
29264 return NULL;
29265 }
29266
29267
29268 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29269 PyObject *resultobj = 0;
29270 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29271 int arg2 ;
29272 int arg3 ;
29273 int arg4 ;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 int val2 ;
29277 int ecode2 = 0 ;
29278 int val3 ;
29279 int ecode3 = 0 ;
29280 int val4 ;
29281 int ecode4 = 0 ;
29282 PyObject * obj0 = 0 ;
29283 PyObject * obj1 = 0 ;
29284 PyObject * obj2 = 0 ;
29285 PyObject * obj3 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCircle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29294 }
29295 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29296 ecode2 = SWIG_AsVal_int(obj1, &val2);
29297 if (!SWIG_IsOK(ecode2)) {
29298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
29299 }
29300 arg2 = static_cast< int >(val2);
29301 ecode3 = SWIG_AsVal_int(obj2, &val3);
29302 if (!SWIG_IsOK(ecode3)) {
29303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
29304 }
29305 arg3 = static_cast< int >(val3);
29306 ecode4 = SWIG_AsVal_int(obj3, &val4);
29307 if (!SWIG_IsOK(ecode4)) {
29308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
29309 }
29310 arg4 = static_cast< int >(val4);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 (arg1)->DrawCircle(arg2,arg3,arg4);
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 resultobj = SWIG_Py_Void();
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj = 0;
29326 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29327 wxPoint *arg2 = 0 ;
29328 int arg3 ;
29329 void *argp1 = 0 ;
29330 int res1 = 0 ;
29331 wxPoint temp2 ;
29332 int val3 ;
29333 int ecode3 = 0 ;
29334 PyObject * obj0 = 0 ;
29335 PyObject * obj1 = 0 ;
29336 PyObject * obj2 = 0 ;
29337 char * kwnames[] = {
29338 (char *) "self",(char *) "pt",(char *) "radius", NULL
29339 };
29340
29341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29343 if (!SWIG_IsOK(res1)) {
29344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29345 }
29346 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29347 {
29348 arg2 = &temp2;
29349 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29350 }
29351 ecode3 = SWIG_AsVal_int(obj2, &val3);
29352 if (!SWIG_IsOK(ecode3)) {
29353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
29354 }
29355 arg3 = static_cast< int >(val3);
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 resultobj = SWIG_Py_Void();
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj = 0;
29371 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29372 int arg2 ;
29373 int arg3 ;
29374 int arg4 ;
29375 int arg5 ;
29376 void *argp1 = 0 ;
29377 int res1 = 0 ;
29378 int val2 ;
29379 int ecode2 = 0 ;
29380 int val3 ;
29381 int ecode3 = 0 ;
29382 int val4 ;
29383 int ecode4 = 0 ;
29384 int val5 ;
29385 int ecode5 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 PyObject * obj2 = 0 ;
29389 PyObject * obj3 = 0 ;
29390 PyObject * obj4 = 0 ;
29391 char * kwnames[] = {
29392 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
29393 };
29394
29395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29397 if (!SWIG_IsOK(res1)) {
29398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29399 }
29400 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29401 ecode2 = SWIG_AsVal_int(obj1, &val2);
29402 if (!SWIG_IsOK(ecode2)) {
29403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
29404 }
29405 arg2 = static_cast< int >(val2);
29406 ecode3 = SWIG_AsVal_int(obj2, &val3);
29407 if (!SWIG_IsOK(ecode3)) {
29408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
29409 }
29410 arg3 = static_cast< int >(val3);
29411 ecode4 = SWIG_AsVal_int(obj3, &val4);
29412 if (!SWIG_IsOK(ecode4)) {
29413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
29414 }
29415 arg4 = static_cast< int >(val4);
29416 ecode5 = SWIG_AsVal_int(obj4, &val5);
29417 if (!SWIG_IsOK(ecode5)) {
29418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
29419 }
29420 arg5 = static_cast< int >(val5);
29421 {
29422 PyThreadState* __tstate = wxPyBeginAllowThreads();
29423 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
29424 wxPyEndAllowThreads(__tstate);
29425 if (PyErr_Occurred()) SWIG_fail;
29426 }
29427 resultobj = SWIG_Py_Void();
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj = 0;
29436 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29437 wxRect *arg2 = 0 ;
29438 void *argp1 = 0 ;
29439 int res1 = 0 ;
29440 wxRect temp2 ;
29441 PyObject * obj0 = 0 ;
29442 PyObject * obj1 = 0 ;
29443 char * kwnames[] = {
29444 (char *) "self",(char *) "rect", NULL
29445 };
29446
29447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
29448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29449 if (!SWIG_IsOK(res1)) {
29450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29451 }
29452 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29453 {
29454 arg2 = &temp2;
29455 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29456 }
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 (arg1)->DrawEllipse((wxRect const &)*arg2);
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 resultobj = SWIG_Py_Void();
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj = 0;
29472 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29473 wxPoint *arg2 = 0 ;
29474 wxSize *arg3 = 0 ;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 wxPoint temp2 ;
29478 wxSize temp3 ;
29479 PyObject * obj0 = 0 ;
29480 PyObject * obj1 = 0 ;
29481 PyObject * obj2 = 0 ;
29482 char * kwnames[] = {
29483 (char *) "self",(char *) "pt",(char *) "sz", NULL
29484 };
29485
29486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29488 if (!SWIG_IsOK(res1)) {
29489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29490 }
29491 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29492 {
29493 arg2 = &temp2;
29494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29495 }
29496 {
29497 arg3 = &temp3;
29498 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29499 }
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 resultobj = SWIG_Py_Void();
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj = 0;
29515 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29516 wxIcon *arg2 = 0 ;
29517 int arg3 ;
29518 int arg4 ;
29519 void *argp1 = 0 ;
29520 int res1 = 0 ;
29521 void *argp2 = 0 ;
29522 int res2 = 0 ;
29523 int val3 ;
29524 int ecode3 = 0 ;
29525 int val4 ;
29526 int ecode4 = 0 ;
29527 PyObject * obj0 = 0 ;
29528 PyObject * obj1 = 0 ;
29529 PyObject * obj2 = 0 ;
29530 PyObject * obj3 = 0 ;
29531 char * kwnames[] = {
29532 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
29533 };
29534
29535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29537 if (!SWIG_IsOK(res1)) {
29538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIcon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29539 }
29540 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29541 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
29542 if (!SWIG_IsOK(res2)) {
29543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
29544 }
29545 if (!argp2) {
29546 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
29547 }
29548 arg2 = reinterpret_cast< wxIcon * >(argp2);
29549 ecode3 = SWIG_AsVal_int(obj2, &val3);
29550 if (!SWIG_IsOK(ecode3)) {
29551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
29552 }
29553 arg3 = static_cast< int >(val3);
29554 ecode4 = SWIG_AsVal_int(obj3, &val4);
29555 if (!SWIG_IsOK(ecode4)) {
29556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
29557 }
29558 arg4 = static_cast< int >(val4);
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 resultobj = SWIG_Py_Void();
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29573 PyObject *resultobj = 0;
29574 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29575 wxIcon *arg2 = 0 ;
29576 wxPoint *arg3 = 0 ;
29577 void *argp1 = 0 ;
29578 int res1 = 0 ;
29579 void *argp2 = 0 ;
29580 int res2 = 0 ;
29581 wxPoint temp3 ;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 PyObject * obj2 = 0 ;
29585 char * kwnames[] = {
29586 (char *) "self",(char *) "icon",(char *) "pt", NULL
29587 };
29588
29589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29593 }
29594 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
29596 if (!SWIG_IsOK(res2)) {
29597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
29598 }
29599 if (!argp2) {
29600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
29601 }
29602 arg2 = reinterpret_cast< wxIcon * >(argp2);
29603 {
29604 arg3 = &temp3;
29605 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29606 }
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 resultobj = SWIG_Py_Void();
29614 return resultobj;
29615 fail:
29616 return NULL;
29617 }
29618
29619
29620 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29621 PyObject *resultobj = 0;
29622 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29623 wxBitmap *arg2 = 0 ;
29624 int arg3 ;
29625 int arg4 ;
29626 bool arg5 = (bool) false ;
29627 void *argp1 = 0 ;
29628 int res1 = 0 ;
29629 void *argp2 = 0 ;
29630 int res2 = 0 ;
29631 int val3 ;
29632 int ecode3 = 0 ;
29633 int val4 ;
29634 int ecode4 = 0 ;
29635 bool val5 ;
29636 int ecode5 = 0 ;
29637 PyObject * obj0 = 0 ;
29638 PyObject * obj1 = 0 ;
29639 PyObject * obj2 = 0 ;
29640 PyObject * obj3 = 0 ;
29641 PyObject * obj4 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29648 if (!SWIG_IsOK(res1)) {
29649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29650 }
29651 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
29653 if (!SWIG_IsOK(res2)) {
29654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29655 }
29656 if (!argp2) {
29657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29658 }
29659 arg2 = reinterpret_cast< wxBitmap * >(argp2);
29660 ecode3 = SWIG_AsVal_int(obj2, &val3);
29661 if (!SWIG_IsOK(ecode3)) {
29662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
29663 }
29664 arg3 = static_cast< int >(val3);
29665 ecode4 = SWIG_AsVal_int(obj3, &val4);
29666 if (!SWIG_IsOK(ecode4)) {
29667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
29668 }
29669 arg4 = static_cast< int >(val4);
29670 if (obj4) {
29671 ecode5 = SWIG_AsVal_bool(obj4, &val5);
29672 if (!SWIG_IsOK(ecode5)) {
29673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
29674 }
29675 arg5 = static_cast< bool >(val5);
29676 }
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
29680 wxPyEndAllowThreads(__tstate);
29681 if (PyErr_Occurred()) SWIG_fail;
29682 }
29683 resultobj = SWIG_Py_Void();
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj = 0;
29692 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29693 wxBitmap *arg2 = 0 ;
29694 wxPoint *arg3 = 0 ;
29695 bool arg4 = (bool) false ;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 void *argp2 = 0 ;
29699 int res2 = 0 ;
29700 wxPoint temp3 ;
29701 bool val4 ;
29702 int ecode4 = 0 ;
29703 PyObject * obj0 = 0 ;
29704 PyObject * obj1 = 0 ;
29705 PyObject * obj2 = 0 ;
29706 PyObject * obj3 = 0 ;
29707 char * kwnames[] = {
29708 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
29709 };
29710
29711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29713 if (!SWIG_IsOK(res1)) {
29714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29715 }
29716 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
29718 if (!SWIG_IsOK(res2)) {
29719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29720 }
29721 if (!argp2) {
29722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29723 }
29724 arg2 = reinterpret_cast< wxBitmap * >(argp2);
29725 {
29726 arg3 = &temp3;
29727 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29728 }
29729 if (obj3) {
29730 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29731 if (!SWIG_IsOK(ecode4)) {
29732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
29733 }
29734 arg4 = static_cast< bool >(val4);
29735 }
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 resultobj = SWIG_Py_Void();
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 SWIGINTERN PyObject *_wrap_PseudoDC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj = 0;
29751 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29752 wxString *arg2 = 0 ;
29753 int arg3 ;
29754 int arg4 ;
29755 void *argp1 = 0 ;
29756 int res1 = 0 ;
29757 bool temp2 = false ;
29758 int val3 ;
29759 int ecode3 = 0 ;
29760 int val4 ;
29761 int ecode4 = 0 ;
29762 PyObject * obj0 = 0 ;
29763 PyObject * obj1 = 0 ;
29764 PyObject * obj2 = 0 ;
29765 PyObject * obj3 = 0 ;
29766 char * kwnames[] = {
29767 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
29768 };
29769
29770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29772 if (!SWIG_IsOK(res1)) {
29773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29774 }
29775 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29776 {
29777 arg2 = wxString_in_helper(obj1);
29778 if (arg2 == NULL) SWIG_fail;
29779 temp2 = true;
29780 }
29781 ecode3 = SWIG_AsVal_int(obj2, &val3);
29782 if (!SWIG_IsOK(ecode3)) {
29783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawText" "', expected argument " "3"" of type '" "int""'");
29784 }
29785 arg3 = static_cast< int >(val3);
29786 ecode4 = SWIG_AsVal_int(obj3, &val4);
29787 if (!SWIG_IsOK(ecode4)) {
29788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawText" "', expected argument " "4"" of type '" "int""'");
29789 }
29790 arg4 = static_cast< int >(val4);
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_Py_Void();
29798 {
29799 if (temp2)
29800 delete arg2;
29801 }
29802 return resultobj;
29803 fail:
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *_wrap_PseudoDC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj = 0;
29814 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29815 wxString *arg2 = 0 ;
29816 wxPoint *arg3 = 0 ;
29817 void *argp1 = 0 ;
29818 int res1 = 0 ;
29819 bool temp2 = false ;
29820 wxPoint temp3 ;
29821 PyObject * obj0 = 0 ;
29822 PyObject * obj1 = 0 ;
29823 PyObject * obj2 = 0 ;
29824 char * kwnames[] = {
29825 (char *) "self",(char *) "text",(char *) "pt", NULL
29826 };
29827
29828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29832 }
29833 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29834 {
29835 arg2 = wxString_in_helper(obj1);
29836 if (arg2 == NULL) SWIG_fail;
29837 temp2 = true;
29838 }
29839 {
29840 arg3 = &temp3;
29841 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29842 }
29843 {
29844 PyThreadState* __tstate = wxPyBeginAllowThreads();
29845 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_Py_Void();
29850 {
29851 if (temp2)
29852 delete arg2;
29853 }
29854 return resultobj;
29855 fail:
29856 {
29857 if (temp2)
29858 delete arg2;
29859 }
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29865 PyObject *resultobj = 0;
29866 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29867 wxString *arg2 = 0 ;
29868 int arg3 ;
29869 int arg4 ;
29870 double arg5 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 bool temp2 = false ;
29874 int val3 ;
29875 int ecode3 = 0 ;
29876 int val4 ;
29877 int ecode4 = 0 ;
29878 double val5 ;
29879 int ecode5 = 0 ;
29880 PyObject * obj0 = 0 ;
29881 PyObject * obj1 = 0 ;
29882 PyObject * obj2 = 0 ;
29883 PyObject * obj3 = 0 ;
29884 PyObject * obj4 = 0 ;
29885 char * kwnames[] = {
29886 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
29887 };
29888
29889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29891 if (!SWIG_IsOK(res1)) {
29892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29893 }
29894 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29895 {
29896 arg2 = wxString_in_helper(obj1);
29897 if (arg2 == NULL) SWIG_fail;
29898 temp2 = true;
29899 }
29900 ecode3 = SWIG_AsVal_int(obj2, &val3);
29901 if (!SWIG_IsOK(ecode3)) {
29902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
29903 }
29904 arg3 = static_cast< int >(val3);
29905 ecode4 = SWIG_AsVal_int(obj3, &val4);
29906 if (!SWIG_IsOK(ecode4)) {
29907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
29908 }
29909 arg4 = static_cast< int >(val4);
29910 ecode5 = SWIG_AsVal_double(obj4, &val5);
29911 if (!SWIG_IsOK(ecode5)) {
29912 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
29913 }
29914 arg5 = static_cast< double >(val5);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 resultobj = SWIG_Py_Void();
29922 {
29923 if (temp2)
29924 delete arg2;
29925 }
29926 return resultobj;
29927 fail:
29928 {
29929 if (temp2)
29930 delete arg2;
29931 }
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj = 0;
29938 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29939 wxString *arg2 = 0 ;
29940 wxPoint *arg3 = 0 ;
29941 double arg4 ;
29942 void *argp1 = 0 ;
29943 int res1 = 0 ;
29944 bool temp2 = false ;
29945 wxPoint temp3 ;
29946 double val4 ;
29947 int ecode4 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 PyObject * obj2 = 0 ;
29951 PyObject * obj3 = 0 ;
29952 char * kwnames[] = {
29953 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
29954 };
29955
29956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29960 }
29961 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29962 {
29963 arg2 = wxString_in_helper(obj1);
29964 if (arg2 == NULL) SWIG_fail;
29965 temp2 = true;
29966 }
29967 {
29968 arg3 = &temp3;
29969 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29970 }
29971 ecode4 = SWIG_AsVal_double(obj3, &val4);
29972 if (!SWIG_IsOK(ecode4)) {
29973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
29974 }
29975 arg4 = static_cast< double >(val4);
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_Py_Void();
29983 {
29984 if (temp2)
29985 delete arg2;
29986 }
29987 return resultobj;
29988 fail:
29989 {
29990 if (temp2)
29991 delete arg2;
29992 }
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj = 0;
29999 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30000 int arg2 ;
30001 wxPoint *arg3 = (wxPoint *) 0 ;
30002 int arg4 = (int) 0 ;
30003 int arg5 = (int) 0 ;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 int val4 ;
30007 int ecode4 = 0 ;
30008 int val5 ;
30009 int ecode5 = 0 ;
30010 PyObject * obj0 = 0 ;
30011 PyObject * obj1 = 0 ;
30012 PyObject * obj2 = 0 ;
30013 PyObject * obj3 = 0 ;
30014 char * kwnames[] = {
30015 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
30016 };
30017
30018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:PseudoDC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLines" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30022 }
30023 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30024 {
30025 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30026 if (arg3 == NULL) SWIG_fail;
30027 }
30028 if (obj2) {
30029 ecode4 = SWIG_AsVal_int(obj2, &val4);
30030 if (!SWIG_IsOK(ecode4)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLines" "', expected argument " "4"" of type '" "int""'");
30032 }
30033 arg4 = static_cast< int >(val4);
30034 }
30035 if (obj3) {
30036 ecode5 = SWIG_AsVal_int(obj3, &val5);
30037 if (!SWIG_IsOK(ecode5)) {
30038 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLines" "', expected argument " "5"" of type '" "int""'");
30039 }
30040 arg5 = static_cast< int >(val5);
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 resultobj = SWIG_Py_Void();
30049 {
30050 if (arg3) delete [] arg3;
30051 }
30052 return resultobj;
30053 fail:
30054 {
30055 if (arg3) delete [] arg3;
30056 }
30057 return NULL;
30058 }
30059
30060
30061 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30062 PyObject *resultobj = 0;
30063 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30064 int arg2 ;
30065 wxPoint *arg3 = (wxPoint *) 0 ;
30066 int arg4 = (int) 0 ;
30067 int arg5 = (int) 0 ;
30068 int arg6 = (int) wxODDEVEN_RULE ;
30069 void *argp1 = 0 ;
30070 int res1 = 0 ;
30071 int val4 ;
30072 int ecode4 = 0 ;
30073 int val5 ;
30074 int ecode5 = 0 ;
30075 int val6 ;
30076 int ecode6 = 0 ;
30077 PyObject * obj0 = 0 ;
30078 PyObject * obj1 = 0 ;
30079 PyObject * obj2 = 0 ;
30080 PyObject * obj3 = 0 ;
30081 PyObject * obj4 = 0 ;
30082 char * kwnames[] = {
30083 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
30084 };
30085
30086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:PseudoDC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30088 if (!SWIG_IsOK(res1)) {
30089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30090 }
30091 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30092 {
30093 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30094 if (arg3 == NULL) SWIG_fail;
30095 }
30096 if (obj2) {
30097 ecode4 = SWIG_AsVal_int(obj2, &val4);
30098 if (!SWIG_IsOK(ecode4)) {
30099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
30100 }
30101 arg4 = static_cast< int >(val4);
30102 }
30103 if (obj3) {
30104 ecode5 = SWIG_AsVal_int(obj3, &val5);
30105 if (!SWIG_IsOK(ecode5)) {
30106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
30107 }
30108 arg5 = static_cast< int >(val5);
30109 }
30110 if (obj4) {
30111 ecode6 = SWIG_AsVal_int(obj4, &val6);
30112 if (!SWIG_IsOK(ecode6)) {
30113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
30114 }
30115 arg6 = static_cast< int >(val6);
30116 }
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 resultobj = SWIG_Py_Void();
30124 {
30125 if (arg3) delete [] arg3;
30126 }
30127 return resultobj;
30128 fail:
30129 {
30130 if (arg3) delete [] arg3;
30131 }
30132 return NULL;
30133 }
30134
30135
30136 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj = 0;
30138 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30139 wxString *arg2 = 0 ;
30140 wxRect *arg3 = 0 ;
30141 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
30142 int arg5 = (int) -1 ;
30143 void *argp1 = 0 ;
30144 int res1 = 0 ;
30145 bool temp2 = false ;
30146 wxRect temp3 ;
30147 int val4 ;
30148 int ecode4 = 0 ;
30149 int val5 ;
30150 int ecode5 = 0 ;
30151 PyObject * obj0 = 0 ;
30152 PyObject * obj1 = 0 ;
30153 PyObject * obj2 = 0 ;
30154 PyObject * obj3 = 0 ;
30155 PyObject * obj4 = 0 ;
30156 char * kwnames[] = {
30157 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
30158 };
30159
30160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:PseudoDC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30162 if (!SWIG_IsOK(res1)) {
30163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30164 }
30165 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30166 {
30167 arg2 = wxString_in_helper(obj1);
30168 if (arg2 == NULL) SWIG_fail;
30169 temp2 = true;
30170 }
30171 {
30172 arg3 = &temp3;
30173 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
30174 }
30175 if (obj3) {
30176 ecode4 = SWIG_AsVal_int(obj3, &val4);
30177 if (!SWIG_IsOK(ecode4)) {
30178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
30179 }
30180 arg4 = static_cast< int >(val4);
30181 }
30182 if (obj4) {
30183 ecode5 = SWIG_AsVal_int(obj4, &val5);
30184 if (!SWIG_IsOK(ecode5)) {
30185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
30186 }
30187 arg5 = static_cast< int >(val5);
30188 }
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
30192 wxPyEndAllowThreads(__tstate);
30193 if (PyErr_Occurred()) SWIG_fail;
30194 }
30195 resultobj = SWIG_Py_Void();
30196 {
30197 if (temp2)
30198 delete arg2;
30199 }
30200 return resultobj;
30201 fail:
30202 {
30203 if (temp2)
30204 delete arg2;
30205 }
30206 return NULL;
30207 }
30208
30209
30210 SWIGINTERN PyObject *_wrap_PseudoDC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30211 PyObject *resultobj = 0;
30212 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30213 wxString *arg2 = 0 ;
30214 wxBitmap *arg3 = 0 ;
30215 wxRect *arg4 = 0 ;
30216 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
30217 int arg6 = (int) -1 ;
30218 void *argp1 = 0 ;
30219 int res1 = 0 ;
30220 bool temp2 = false ;
30221 void *argp3 = 0 ;
30222 int res3 = 0 ;
30223 wxRect temp4 ;
30224 int val5 ;
30225 int ecode5 = 0 ;
30226 int val6 ;
30227 int ecode6 = 0 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 PyObject * obj2 = 0 ;
30231 PyObject * obj3 = 0 ;
30232 PyObject * obj4 = 0 ;
30233 PyObject * obj5 = 0 ;
30234 char * kwnames[] = {
30235 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
30236 };
30237
30238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:PseudoDC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30240 if (!SWIG_IsOK(res1)) {
30241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30242 }
30243 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30244 {
30245 arg2 = wxString_in_helper(obj1);
30246 if (arg2 == NULL) SWIG_fail;
30247 temp2 = true;
30248 }
30249 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
30250 if (!SWIG_IsOK(res3)) {
30251 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30252 }
30253 if (!argp3) {
30254 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30255 }
30256 arg3 = reinterpret_cast< wxBitmap * >(argp3);
30257 {
30258 arg4 = &temp4;
30259 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
30260 }
30261 if (obj4) {
30262 ecode5 = SWIG_AsVal_int(obj4, &val5);
30263 if (!SWIG_IsOK(ecode5)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
30265 }
30266 arg5 = static_cast< int >(val5);
30267 }
30268 if (obj5) {
30269 ecode6 = SWIG_AsVal_int(obj5, &val6);
30270 if (!SWIG_IsOK(ecode6)) {
30271 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
30272 }
30273 arg6 = static_cast< int >(val6);
30274 }
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 (arg1)->DrawLabel((wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 resultobj = SWIG_Py_Void();
30282 {
30283 if (temp2)
30284 delete arg2;
30285 }
30286 return resultobj;
30287 fail:
30288 {
30289 if (temp2)
30290 delete arg2;
30291 }
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_PseudoDC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30297 PyObject *resultobj = 0;
30298 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30299 int arg2 ;
30300 wxPoint *arg3 = (wxPoint *) 0 ;
30301 void *argp1 = 0 ;
30302 int res1 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 PyObject * obj1 = 0 ;
30305 char * kwnames[] = {
30306 (char *) "self",(char *) "points", NULL
30307 };
30308
30309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
30310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30311 if (!SWIG_IsOK(res1)) {
30312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawSpline" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30313 }
30314 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30315 {
30316 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30317 if (arg3 == NULL) SWIG_fail;
30318 }
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 (arg1)->DrawSpline(arg2,arg3);
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 resultobj = SWIG_Py_Void();
30326 {
30327 if (arg3) delete [] arg3;
30328 }
30329 return resultobj;
30330 fail:
30331 {
30332 if (arg3) delete [] arg3;
30333 }
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PseudoDC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_Clear" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30350 }
30351 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->Clear();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_PseudoDC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj = 0;
30367 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30368 wxFont *arg2 = 0 ;
30369 void *argp1 = 0 ;
30370 int res1 = 0 ;
30371 void *argp2 = 0 ;
30372 int res2 = 0 ;
30373 PyObject * obj0 = 0 ;
30374 PyObject * obj1 = 0 ;
30375 char * kwnames[] = {
30376 (char *) "self",(char *) "font", NULL
30377 };
30378
30379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
30380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30381 if (!SWIG_IsOK(res1)) {
30382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetFont" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30383 }
30384 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30385 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
30386 if (!SWIG_IsOK(res2)) {
30387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
30388 }
30389 if (!argp2) {
30390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
30391 }
30392 arg2 = reinterpret_cast< wxFont * >(argp2);
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 (arg1)->SetFont((wxFont const &)*arg2);
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 resultobj = SWIG_Py_Void();
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_PseudoDC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30407 PyObject *resultobj = 0;
30408 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30409 wxPen *arg2 = 0 ;
30410 void *argp1 = 0 ;
30411 int res1 = 0 ;
30412 void *argp2 = 0 ;
30413 int res2 = 0 ;
30414 PyObject * obj0 = 0 ;
30415 PyObject * obj1 = 0 ;
30416 char * kwnames[] = {
30417 (char *) "self",(char *) "pen", NULL
30418 };
30419
30420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
30421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30424 }
30425 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30426 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
30427 if (!SWIG_IsOK(res2)) {
30428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
30429 }
30430 if (!argp2) {
30431 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
30432 }
30433 arg2 = reinterpret_cast< wxPen * >(argp2);
30434 {
30435 PyThreadState* __tstate = wxPyBeginAllowThreads();
30436 (arg1)->SetPen((wxPen const &)*arg2);
30437 wxPyEndAllowThreads(__tstate);
30438 if (PyErr_Occurred()) SWIG_fail;
30439 }
30440 resultobj = SWIG_Py_Void();
30441 return resultobj;
30442 fail:
30443 return NULL;
30444 }
30445
30446
30447 SWIGINTERN PyObject *_wrap_PseudoDC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30448 PyObject *resultobj = 0;
30449 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30450 wxBrush *arg2 = 0 ;
30451 void *argp1 = 0 ;
30452 int res1 = 0 ;
30453 void *argp2 = 0 ;
30454 int res2 = 0 ;
30455 PyObject * obj0 = 0 ;
30456 PyObject * obj1 = 0 ;
30457 char * kwnames[] = {
30458 (char *) "self",(char *) "brush", NULL
30459 };
30460
30461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
30462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30463 if (!SWIG_IsOK(res1)) {
30464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBrush" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30465 }
30466 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
30468 if (!SWIG_IsOK(res2)) {
30469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
30470 }
30471 if (!argp2) {
30472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
30473 }
30474 arg2 = reinterpret_cast< wxBrush * >(argp2);
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 (arg1)->SetBrush((wxBrush const &)*arg2);
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 resultobj = SWIG_Py_Void();
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj = 0;
30490 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30491 wxBrush *arg2 = 0 ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 void *argp2 = 0 ;
30495 int res2 = 0 ;
30496 PyObject * obj0 = 0 ;
30497 PyObject * obj1 = 0 ;
30498 char * kwnames[] = {
30499 (char *) "self",(char *) "brush", NULL
30500 };
30501
30502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
30503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30506 }
30507 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
30509 if (!SWIG_IsOK(res2)) {
30510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
30511 }
30512 if (!argp2) {
30513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
30514 }
30515 arg2 = reinterpret_cast< wxBrush * >(argp2);
30516 {
30517 PyThreadState* __tstate = wxPyBeginAllowThreads();
30518 (arg1)->SetBackground((wxBrush const &)*arg2);
30519 wxPyEndAllowThreads(__tstate);
30520 if (PyErr_Occurred()) SWIG_fail;
30521 }
30522 resultobj = SWIG_Py_Void();
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30530 PyObject *resultobj = 0;
30531 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30532 int arg2 ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 int val2 ;
30536 int ecode2 = 0 ;
30537 PyObject * obj0 = 0 ;
30538 PyObject * obj1 = 0 ;
30539 char * kwnames[] = {
30540 (char *) "self",(char *) "mode", NULL
30541 };
30542
30543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
30544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30547 }
30548 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30549 ecode2 = SWIG_AsVal_int(obj1, &val2);
30550 if (!SWIG_IsOK(ecode2)) {
30551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
30552 }
30553 arg2 = static_cast< int >(val2);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 (arg1)->SetBackgroundMode(arg2);
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 resultobj = SWIG_Py_Void();
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_PseudoDC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj = 0;
30569 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30570 wxPalette *arg2 = 0 ;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 void *argp2 = 0 ;
30574 int res2 = 0 ;
30575 PyObject * obj0 = 0 ;
30576 PyObject * obj1 = 0 ;
30577 char * kwnames[] = {
30578 (char *) "self",(char *) "palette", NULL
30579 };
30580
30581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
30582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30583 if (!SWIG_IsOK(res1)) {
30584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPalette" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30585 }
30586 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
30588 if (!SWIG_IsOK(res2)) {
30589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
30590 }
30591 if (!argp2) {
30592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
30593 }
30594 arg2 = reinterpret_cast< wxPalette * >(argp2);
30595 {
30596 PyThreadState* __tstate = wxPyBeginAllowThreads();
30597 (arg1)->SetPalette((wxPalette const &)*arg2);
30598 wxPyEndAllowThreads(__tstate);
30599 if (PyErr_Occurred()) SWIG_fail;
30600 }
30601 resultobj = SWIG_Py_Void();
30602 return resultobj;
30603 fail:
30604 return NULL;
30605 }
30606
30607
30608 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30609 PyObject *resultobj = 0;
30610 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30611 wxColour *arg2 = 0 ;
30612 void *argp1 = 0 ;
30613 int res1 = 0 ;
30614 wxColour temp2 ;
30615 PyObject * obj0 = 0 ;
30616 PyObject * obj1 = 0 ;
30617 char * kwnames[] = {
30618 (char *) "self",(char *) "colour", NULL
30619 };
30620
30621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
30622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextForeground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30625 }
30626 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30627 {
30628 arg2 = &temp2;
30629 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30630 }
30631 {
30632 PyThreadState* __tstate = wxPyBeginAllowThreads();
30633 (arg1)->SetTextForeground((wxColour const &)*arg2);
30634 wxPyEndAllowThreads(__tstate);
30635 if (PyErr_Occurred()) SWIG_fail;
30636 }
30637 resultobj = SWIG_Py_Void();
30638 return resultobj;
30639 fail:
30640 return NULL;
30641 }
30642
30643
30644 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30645 PyObject *resultobj = 0;
30646 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30647 wxColour *arg2 = 0 ;
30648 void *argp1 = 0 ;
30649 int res1 = 0 ;
30650 wxColour temp2 ;
30651 PyObject * obj0 = 0 ;
30652 PyObject * obj1 = 0 ;
30653 char * kwnames[] = {
30654 (char *) "self",(char *) "colour", NULL
30655 };
30656
30657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
30658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30659 if (!SWIG_IsOK(res1)) {
30660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30661 }
30662 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30663 {
30664 arg2 = &temp2;
30665 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30666 }
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 (arg1)->SetTextBackground((wxColour const &)*arg2);
30670 wxPyEndAllowThreads(__tstate);
30671 if (PyErr_Occurred()) SWIG_fail;
30672 }
30673 resultobj = SWIG_Py_Void();
30674 return resultobj;
30675 fail:
30676 return NULL;
30677 }
30678
30679
30680 SWIGINTERN PyObject *_wrap_PseudoDC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30681 PyObject *resultobj = 0;
30682 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30683 int arg2 ;
30684 void *argp1 = 0 ;
30685 int res1 = 0 ;
30686 int val2 ;
30687 int ecode2 = 0 ;
30688 PyObject * obj0 = 0 ;
30689 PyObject * obj1 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "function", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30698 }
30699 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30700 ecode2 = SWIG_AsVal_int(obj1, &val2);
30701 if (!SWIG_IsOK(ecode2)) {
30702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
30703 }
30704 arg2 = static_cast< int >(val2);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 (arg1)->SetLogicalFunction(arg2);
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 resultobj = SWIG_Py_Void();
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 SWIGINTERN PyObject *PseudoDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30719 PyObject *obj;
30720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30721 SWIG_TypeNewClientData(SWIGTYPE_p_wxPseudoDC, SWIG_NewClientData(obj));
30722 return SWIG_Py_Void();
30723 }
30724
30725 SWIGINTERN PyObject *PseudoDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30726 return SWIG_Python_InitShadowInstance(args);
30727 }
30728
30729 static PyMethodDef SwigMethods[] = {
30730 { (char *)"new_GDIObject", (PyCFunction)_wrap_new_GDIObject, METH_NOARGS, NULL},
30731 { (char *)"delete_GDIObject", (PyCFunction)_wrap_delete_GDIObject, METH_O, NULL},
30732 { (char *)"GDIObject_IsNull", (PyCFunction)_wrap_GDIObject_IsNull, METH_O, NULL},
30733 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
30734 { (char *)"GDIObject_swiginit", GDIObject_swiginit, METH_VARARGS, NULL},
30735 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
30736 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
30737 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30738 { (char *)"delete_Colour", (PyCFunction)_wrap_delete_Colour, METH_O, NULL},
30739 { (char *)"Colour_Red", (PyCFunction)_wrap_Colour_Red, METH_O, NULL},
30740 { (char *)"Colour_Green", (PyCFunction)_wrap_Colour_Green, METH_O, NULL},
30741 { (char *)"Colour_Blue", (PyCFunction)_wrap_Colour_Blue, METH_O, NULL},
30742 { (char *)"Colour_Alpha", (PyCFunction)_wrap_Colour_Alpha, METH_O, NULL},
30743 { (char *)"Colour_Ok", (PyCFunction)_wrap_Colour_Ok, METH_O, NULL},
30744 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30745 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30746 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
30747 { (char *)"Colour_GetAsString", (PyCFunction) _wrap_Colour_GetAsString, METH_VARARGS | METH_KEYWORDS, NULL},
30748 { (char *)"Colour_GetPixel", (PyCFunction)_wrap_Colour_GetPixel, METH_O, NULL},
30749 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30750 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30751 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
30752 { (char *)"Colour_GetRGB", (PyCFunction)_wrap_Colour_GetRGB, METH_O, NULL},
30753 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
30754 { (char *)"Colour_swiginit", Colour_swiginit, METH_VARARGS, NULL},
30755 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
30756 { (char *)"delete_Palette", (PyCFunction)_wrap_delete_Palette, METH_O, NULL},
30757 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
30758 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30759 { (char *)"Palette_GetColoursCount", (PyCFunction)_wrap_Palette_GetColoursCount, METH_O, NULL},
30760 { (char *)"Palette_Ok", (PyCFunction)_wrap_Palette_Ok, METH_O, NULL},
30761 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
30762 { (char *)"Palette_swiginit", Palette_swiginit, METH_VARARGS, NULL},
30763 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
30764 { (char *)"delete_Pen", (PyCFunction)_wrap_delete_Pen, METH_O, NULL},
30765 { (char *)"Pen_GetCap", (PyCFunction)_wrap_Pen_GetCap, METH_O, NULL},
30766 { (char *)"Pen_GetColour", (PyCFunction)_wrap_Pen_GetColour, METH_O, NULL},
30767 { (char *)"Pen_GetJoin", (PyCFunction)_wrap_Pen_GetJoin, METH_O, NULL},
30768 { (char *)"Pen_GetStyle", (PyCFunction)_wrap_Pen_GetStyle, METH_O, NULL},
30769 { (char *)"Pen_GetWidth", (PyCFunction)_wrap_Pen_GetWidth, METH_O, NULL},
30770 { (char *)"Pen_Ok", (PyCFunction)_wrap_Pen_Ok, METH_O, NULL},
30771 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
30772 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30773 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
30774 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30775 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30776 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
30777 { (char *)"Pen_GetDashes", (PyCFunction)_wrap_Pen_GetDashes, METH_O, NULL},
30778 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
30779 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30780 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30781 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
30782 { (char *)"Pen_swiginit", Pen_swiginit, METH_VARARGS, NULL},
30783 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
30784 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30785 { (char *)"delete_Brush", (PyCFunction)_wrap_delete_Brush, METH_O, NULL},
30786 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30787 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30788 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
30789 { (char *)"Brush_GetColour", (PyCFunction)_wrap_Brush_GetColour, METH_O, NULL},
30790 { (char *)"Brush_GetStyle", (PyCFunction)_wrap_Brush_GetStyle, METH_O, NULL},
30791 { (char *)"Brush_GetStipple", (PyCFunction)_wrap_Brush_GetStipple, METH_O, NULL},
30792 { (char *)"Brush_IsHatch", (PyCFunction)_wrap_Brush_IsHatch, METH_O, NULL},
30793 { (char *)"Brush_Ok", (PyCFunction)_wrap_Brush_Ok, METH_O, NULL},
30794 { (char *)"Brush_MacGetTheme", (PyCFunction)_wrap_Brush_MacGetTheme, METH_O, NULL},
30795 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
30796 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
30797 { (char *)"Brush_swiginit", Brush_swiginit, METH_VARARGS, NULL},
30798 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30799 { (char *)"delete_Bitmap", (PyCFunction)_wrap_delete_Bitmap, METH_O, NULL},
30800 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30801 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30802 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
30803 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
30804 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
30805 { (char *)"Bitmap_Ok", (PyCFunction)_wrap_Bitmap_Ok, METH_O, NULL},
30806 { (char *)"Bitmap_GetWidth", (PyCFunction)_wrap_Bitmap_GetWidth, METH_O, NULL},
30807 { (char *)"Bitmap_GetHeight", (PyCFunction)_wrap_Bitmap_GetHeight, METH_O, NULL},
30808 { (char *)"Bitmap_GetDepth", (PyCFunction)_wrap_Bitmap_GetDepth, METH_O, NULL},
30809 { (char *)"Bitmap_GetSize", (PyCFunction)_wrap_Bitmap_GetSize, METH_O, NULL},
30810 { (char *)"Bitmap_ConvertToImage", (PyCFunction)_wrap_Bitmap_ConvertToImage, METH_O, NULL},
30811 { (char *)"Bitmap_GetMask", (PyCFunction)_wrap_Bitmap_GetMask, METH_O, NULL},
30812 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
30813 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
30814 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30815 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
30816 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
30817 { (char *)"Bitmap_GetPalette", (PyCFunction)_wrap_Bitmap_GetPalette, METH_O, NULL},
30818 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30819 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
30820 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30821 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30822 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
30823 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30824 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30825 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
30826 { (char *)"Bitmap_swiginit", Bitmap_swiginit, METH_VARARGS, NULL},
30827 { (char *)"_BitmapFromBufferAlpha", (PyCFunction) _wrap__BitmapFromBufferAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
30828 { (char *)"_BitmapFromBuffer", (PyCFunction) _wrap__BitmapFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
30829 { (char *)"_BitmapFromBufferRGBA", (PyCFunction) _wrap__BitmapFromBufferRGBA, METH_VARARGS | METH_KEYWORDS, NULL},
30830 { (char *)"PixelDataBase_GetOrigin", (PyCFunction)_wrap_PixelDataBase_GetOrigin, METH_O, NULL},
30831 { (char *)"PixelDataBase_GetWidth", (PyCFunction)_wrap_PixelDataBase_GetWidth, METH_O, NULL},
30832 { (char *)"PixelDataBase_GetHeight", (PyCFunction)_wrap_PixelDataBase_GetHeight, METH_O, NULL},
30833 { (char *)"PixelDataBase_GetSize", (PyCFunction)_wrap_PixelDataBase_GetSize, METH_O, NULL},
30834 { (char *)"PixelDataBase_GetRowStride", (PyCFunction)_wrap_PixelDataBase_GetRowStride, METH_O, NULL},
30835 { (char *)"PixelDataBase_swigregister", PixelDataBase_swigregister, METH_VARARGS, NULL},
30836 { (char *)"new_NativePixelData", _wrap_new_NativePixelData, METH_VARARGS, NULL},
30837 { (char *)"delete_NativePixelData", (PyCFunction)_wrap_delete_NativePixelData, METH_O, NULL},
30838 { (char *)"NativePixelData_GetPixels", (PyCFunction)_wrap_NativePixelData_GetPixels, METH_O, NULL},
30839 { (char *)"NativePixelData_UseAlpha", (PyCFunction)_wrap_NativePixelData_UseAlpha, METH_O, NULL},
30840 { (char *)"NativePixelData___nonzero__", (PyCFunction)_wrap_NativePixelData___nonzero__, METH_O, NULL},
30841 { (char *)"NativePixelData_swigregister", NativePixelData_swigregister, METH_VARARGS, NULL},
30842 { (char *)"NativePixelData_swiginit", NativePixelData_swiginit, METH_VARARGS, NULL},
30843 { (char *)"new_NativePixelData_Accessor", _wrap_new_NativePixelData_Accessor, METH_VARARGS, NULL},
30844 { (char *)"delete_NativePixelData_Accessor", (PyCFunction)_wrap_delete_NativePixelData_Accessor, METH_O, NULL},
30845 { (char *)"NativePixelData_Accessor_Reset", (PyCFunction) _wrap_NativePixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
30846 { (char *)"NativePixelData_Accessor_IsOk", (PyCFunction)_wrap_NativePixelData_Accessor_IsOk, METH_O, NULL},
30847 { (char *)"NativePixelData_Accessor_nextPixel", (PyCFunction)_wrap_NativePixelData_Accessor_nextPixel, METH_O, NULL},
30848 { (char *)"NativePixelData_Accessor_Offset", (PyCFunction) _wrap_NativePixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30849 { (char *)"NativePixelData_Accessor_OffsetX", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
30850 { (char *)"NativePixelData_Accessor_OffsetY", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
30851 { (char *)"NativePixelData_Accessor_MoveTo", (PyCFunction) _wrap_NativePixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
30852 { (char *)"NativePixelData_Accessor_Set", (PyCFunction) _wrap_NativePixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30853 { (char *)"NativePixelData_Accessor_Get", (PyCFunction)_wrap_NativePixelData_Accessor_Get, METH_O, NULL},
30854 { (char *)"NativePixelData_Accessor_swigregister", NativePixelData_Accessor_swigregister, METH_VARARGS, NULL},
30855 { (char *)"NativePixelData_Accessor_swiginit", NativePixelData_Accessor_swiginit, METH_VARARGS, NULL},
30856 { (char *)"new_AlphaPixelData", _wrap_new_AlphaPixelData, METH_VARARGS, NULL},
30857 { (char *)"delete_AlphaPixelData", (PyCFunction)_wrap_delete_AlphaPixelData, METH_O, NULL},
30858 { (char *)"AlphaPixelData_GetPixels", (PyCFunction)_wrap_AlphaPixelData_GetPixels, METH_O, NULL},
30859 { (char *)"AlphaPixelData_UseAlpha", (PyCFunction)_wrap_AlphaPixelData_UseAlpha, METH_O, NULL},
30860 { (char *)"AlphaPixelData___nonzero__", (PyCFunction)_wrap_AlphaPixelData___nonzero__, METH_O, NULL},
30861 { (char *)"AlphaPixelData_swigregister", AlphaPixelData_swigregister, METH_VARARGS, NULL},
30862 { (char *)"AlphaPixelData_swiginit", AlphaPixelData_swiginit, METH_VARARGS, NULL},
30863 { (char *)"new_AlphaPixelData_Accessor", _wrap_new_AlphaPixelData_Accessor, METH_VARARGS, NULL},
30864 { (char *)"delete_AlphaPixelData_Accessor", (PyCFunction)_wrap_delete_AlphaPixelData_Accessor, METH_O, NULL},
30865 { (char *)"AlphaPixelData_Accessor_Reset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
30866 { (char *)"AlphaPixelData_Accessor_IsOk", (PyCFunction)_wrap_AlphaPixelData_Accessor_IsOk, METH_O, NULL},
30867 { (char *)"AlphaPixelData_Accessor_nextPixel", (PyCFunction)_wrap_AlphaPixelData_Accessor_nextPixel, METH_O, NULL},
30868 { (char *)"AlphaPixelData_Accessor_Offset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30869 { (char *)"AlphaPixelData_Accessor_OffsetX", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
30870 { (char *)"AlphaPixelData_Accessor_OffsetY", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
30871 { (char *)"AlphaPixelData_Accessor_MoveTo", (PyCFunction) _wrap_AlphaPixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
30872 { (char *)"AlphaPixelData_Accessor_Set", (PyCFunction) _wrap_AlphaPixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30873 { (char *)"AlphaPixelData_Accessor_Get", (PyCFunction)_wrap_AlphaPixelData_Accessor_Get, METH_O, NULL},
30874 { (char *)"AlphaPixelData_Accessor_swigregister", AlphaPixelData_Accessor_swigregister, METH_VARARGS, NULL},
30875 { (char *)"AlphaPixelData_Accessor_swiginit", AlphaPixelData_Accessor_swiginit, METH_VARARGS, NULL},
30876 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
30877 { (char *)"delete_Mask", (PyCFunction)_wrap_delete_Mask, METH_O, NULL},
30878 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
30879 { (char *)"Mask_swiginit", Mask_swiginit, METH_VARARGS, NULL},
30880 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
30881 { (char *)"delete_Icon", (PyCFunction)_wrap_delete_Icon, METH_O, NULL},
30882 { (char *)"new_EmptyIcon", (PyCFunction)_wrap_new_EmptyIcon, METH_NOARGS, NULL},
30883 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
30884 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30885 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
30886 { (char *)"Icon_Ok", (PyCFunction)_wrap_Icon_Ok, METH_O, NULL},
30887 { (char *)"Icon_GetWidth", (PyCFunction)_wrap_Icon_GetWidth, METH_O, NULL},
30888 { (char *)"Icon_GetHeight", (PyCFunction)_wrap_Icon_GetHeight, METH_O, NULL},
30889 { (char *)"Icon_GetDepth", (PyCFunction)_wrap_Icon_GetDepth, METH_O, NULL},
30890 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30891 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
30892 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30893 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30894 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
30895 { (char *)"Icon_swiginit", Icon_swiginit, METH_VARARGS, NULL},
30896 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
30897 { (char *)"delete_IconLocation", (PyCFunction)_wrap_delete_IconLocation, METH_O, NULL},
30898 { (char *)"IconLocation_IsOk", (PyCFunction)_wrap_IconLocation_IsOk, METH_O, NULL},
30899 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
30900 { (char *)"IconLocation_GetFileName", (PyCFunction)_wrap_IconLocation_GetFileName, METH_O, NULL},
30901 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
30902 { (char *)"IconLocation_GetIndex", (PyCFunction)_wrap_IconLocation_GetIndex, METH_O, NULL},
30903 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
30904 { (char *)"IconLocation_swiginit", IconLocation_swiginit, METH_VARARGS, NULL},
30905 { (char *)"new_IconBundle", (PyCFunction)_wrap_new_IconBundle, METH_NOARGS, NULL},
30906 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
30907 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30908 { (char *)"delete_IconBundle", (PyCFunction)_wrap_delete_IconBundle, METH_O, NULL},
30909 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30910 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
30911 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30912 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
30913 { (char *)"IconBundle_swiginit", IconBundle_swiginit, METH_VARARGS, NULL},
30914 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
30915 { (char *)"delete_Cursor", (PyCFunction)_wrap_delete_Cursor, METH_O, NULL},
30916 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30917 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
30918 { (char *)"Cursor_Ok", (PyCFunction)_wrap_Cursor_Ok, METH_O, NULL},
30919 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
30920 { (char *)"Cursor_swiginit", Cursor_swiginit, METH_VARARGS, NULL},
30921 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
30922 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30923 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
30924 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
30925 { (char *)"delete_Region", (PyCFunction)_wrap_delete_Region, METH_O, NULL},
30926 { (char *)"Region_Clear", (PyCFunction)_wrap_Region_Clear, METH_O, NULL},
30927 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30928 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
30929 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30930 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
30931 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
30932 { (char *)"Region_GetBox", (PyCFunction)_wrap_Region_GetBox, METH_O, NULL},
30933 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
30934 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
30935 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30936 { (char *)"Region_IsEmpty", (PyCFunction)_wrap_Region_IsEmpty, METH_O, NULL},
30937 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
30938 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
30939 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30940 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
30941 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
30942 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30943 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
30944 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
30945 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30946 { (char *)"Region_ConvertToBitmap", (PyCFunction)_wrap_Region_ConvertToBitmap, METH_O, NULL},
30947 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30948 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
30949 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
30950 { (char *)"Region_swiginit", Region_swiginit, METH_VARARGS, NULL},
30951 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
30952 { (char *)"delete_RegionIterator", (PyCFunction)_wrap_delete_RegionIterator, METH_O, NULL},
30953 { (char *)"RegionIterator_GetX", (PyCFunction)_wrap_RegionIterator_GetX, METH_O, NULL},
30954 { (char *)"RegionIterator_GetY", (PyCFunction)_wrap_RegionIterator_GetY, METH_O, NULL},
30955 { (char *)"RegionIterator_GetW", (PyCFunction)_wrap_RegionIterator_GetW, METH_O, NULL},
30956 { (char *)"RegionIterator_GetWidth", (PyCFunction)_wrap_RegionIterator_GetWidth, METH_O, NULL},
30957 { (char *)"RegionIterator_GetH", (PyCFunction)_wrap_RegionIterator_GetH, METH_O, NULL},
30958 { (char *)"RegionIterator_GetHeight", (PyCFunction)_wrap_RegionIterator_GetHeight, METH_O, NULL},
30959 { (char *)"RegionIterator_GetRect", (PyCFunction)_wrap_RegionIterator_GetRect, METH_O, NULL},
30960 { (char *)"RegionIterator_HaveRects", (PyCFunction)_wrap_RegionIterator_HaveRects, METH_O, NULL},
30961 { (char *)"RegionIterator_Reset", (PyCFunction)_wrap_RegionIterator_Reset, METH_O, NULL},
30962 { (char *)"RegionIterator_Next", (PyCFunction)_wrap_RegionIterator_Next, METH_O, NULL},
30963 { (char *)"RegionIterator___nonzero__", (PyCFunction)_wrap_RegionIterator___nonzero__, METH_O, NULL},
30964 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
30965 { (char *)"RegionIterator_swiginit", RegionIterator_swiginit, METH_VARARGS, NULL},
30966 { (char *)"new_NativeFontInfo", (PyCFunction)_wrap_new_NativeFontInfo, METH_NOARGS, NULL},
30967 { (char *)"delete_NativeFontInfo", (PyCFunction)_wrap_delete_NativeFontInfo, METH_O, NULL},
30968 { (char *)"NativeFontInfo_Init", (PyCFunction)_wrap_NativeFontInfo_Init, METH_O, NULL},
30969 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
30970 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction)_wrap_NativeFontInfo_GetPointSize, METH_O, NULL},
30971 { (char *)"NativeFontInfo_GetStyle", (PyCFunction)_wrap_NativeFontInfo_GetStyle, METH_O, NULL},
30972 { (char *)"NativeFontInfo_GetWeight", (PyCFunction)_wrap_NativeFontInfo_GetWeight, METH_O, NULL},
30973 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction)_wrap_NativeFontInfo_GetUnderlined, METH_O, NULL},
30974 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction)_wrap_NativeFontInfo_GetFaceName, METH_O, NULL},
30975 { (char *)"NativeFontInfo_GetFamily", (PyCFunction)_wrap_NativeFontInfo_GetFamily, METH_O, NULL},
30976 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction)_wrap_NativeFontInfo_GetEncoding, METH_O, NULL},
30977 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30978 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30979 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
30980 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
30981 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
30982 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
30983 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30984 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
30985 { (char *)"NativeFontInfo_ToString", (PyCFunction)_wrap_NativeFontInfo_ToString, METH_O, NULL},
30986 { (char *)"NativeFontInfo___str__", (PyCFunction)_wrap_NativeFontInfo___str__, METH_O, NULL},
30987 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"NativeFontInfo_ToUserString", (PyCFunction)_wrap_NativeFontInfo_ToUserString, METH_O, NULL},
30989 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
30990 { (char *)"NativeFontInfo_swiginit", NativeFontInfo_swiginit, METH_VARARGS, NULL},
30991 { (char *)"NativeEncodingInfo_facename_set", _wrap_NativeEncodingInfo_facename_set, METH_VARARGS, NULL},
30992 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction)_wrap_NativeEncodingInfo_facename_get, METH_O, NULL},
30993 { (char *)"NativeEncodingInfo_encoding_set", _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS, NULL},
30994 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction)_wrap_NativeEncodingInfo_encoding_get, METH_O, NULL},
30995 { (char *)"new_NativeEncodingInfo", (PyCFunction)_wrap_new_NativeEncodingInfo, METH_NOARGS, NULL},
30996 { (char *)"delete_NativeEncodingInfo", (PyCFunction)_wrap_delete_NativeEncodingInfo, METH_O, NULL},
30997 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"NativeEncodingInfo_ToString", (PyCFunction)_wrap_NativeEncodingInfo_ToString, METH_O, NULL},
30999 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
31000 { (char *)"NativeEncodingInfo_swiginit", NativeEncodingInfo_swiginit, METH_VARARGS, NULL},
31001 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"new_FontMapper", (PyCFunction)_wrap_new_FontMapper, METH_NOARGS, NULL},
31004 { (char *)"delete_FontMapper", (PyCFunction)_wrap_delete_FontMapper, METH_O, NULL},
31005 { (char *)"FontMapper_Get", (PyCFunction)_wrap_FontMapper_Get, METH_NOARGS, NULL},
31006 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction)_wrap_FontMapper_GetSupportedEncodingsCount, METH_NOARGS, NULL},
31009 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction)_wrap_FontMapper_GetDefaultConfigPath, METH_NOARGS, NULL},
31015 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
31020 { (char *)"FontMapper_swiginit", FontMapper_swiginit, METH_VARARGS, NULL},
31021 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"delete_Font", (PyCFunction)_wrap_delete_Font, METH_O, NULL},
31023 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"Font_Ok", (PyCFunction)_wrap_Font_Ok, METH_O, NULL},
31029 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"Font_GetPointSize", (PyCFunction)_wrap_Font_GetPointSize, METH_O, NULL},
31032 { (char *)"Font_GetPixelSize", (PyCFunction)_wrap_Font_GetPixelSize, METH_O, NULL},
31033 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction)_wrap_Font_IsUsingSizeInPixels, METH_O, NULL},
31034 { (char *)"Font_GetFamily", (PyCFunction)_wrap_Font_GetFamily, METH_O, NULL},
31035 { (char *)"Font_GetStyle", (PyCFunction)_wrap_Font_GetStyle, METH_O, NULL},
31036 { (char *)"Font_GetWeight", (PyCFunction)_wrap_Font_GetWeight, METH_O, NULL},
31037 { (char *)"Font_GetUnderlined", (PyCFunction)_wrap_Font_GetUnderlined, METH_O, NULL},
31038 { (char *)"Font_GetFaceName", (PyCFunction)_wrap_Font_GetFaceName, METH_O, NULL},
31039 { (char *)"Font_GetEncoding", (PyCFunction)_wrap_Font_GetEncoding, METH_O, NULL},
31040 { (char *)"Font_GetNativeFontInfo", (PyCFunction)_wrap_Font_GetNativeFontInfo, METH_O, NULL},
31041 { (char *)"Font_IsFixedWidth", (PyCFunction)_wrap_Font_IsFixedWidth, METH_O, NULL},
31042 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoDesc, METH_O, NULL},
31043 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoUserDesc, METH_O, NULL},
31044 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"Font_GetFamilyString", (PyCFunction)_wrap_Font_GetFamilyString, METH_O, NULL},
31056 { (char *)"Font_GetStyleString", (PyCFunction)_wrap_Font_GetStyleString, METH_O, NULL},
31057 { (char *)"Font_GetWeightString", (PyCFunction)_wrap_Font_GetWeightString, METH_O, NULL},
31058 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"Font_GetNoAntiAliasing", (PyCFunction)_wrap_Font_GetNoAntiAliasing, METH_O, NULL},
31060 { (char *)"Font_GetDefaultEncoding", (PyCFunction)_wrap_Font_GetDefaultEncoding, METH_NOARGS, NULL},
31061 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
31063 { (char *)"Font_swiginit", Font_swiginit, METH_VARARGS, NULL},
31064 { (char *)"new_FontEnumerator", (PyCFunction)_wrap_new_FontEnumerator, METH_NOARGS, NULL},
31065 { (char *)"delete_FontEnumerator", (PyCFunction)_wrap_delete_FontEnumerator, METH_O, NULL},
31066 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"FontEnumerator_GetEncodings", (PyCFunction)_wrap_FontEnumerator_GetEncodings, METH_NOARGS, NULL},
31070 { (char *)"FontEnumerator_GetFacenames", (PyCFunction)_wrap_FontEnumerator_GetFacenames, METH_NOARGS, NULL},
31071 { (char *)"FontEnumerator_IsValidFacename", (PyCFunction) _wrap_FontEnumerator_IsValidFacename, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
31073 { (char *)"FontEnumerator_swiginit", FontEnumerator_swiginit, METH_VARARGS, NULL},
31074 { (char *)"LanguageInfo_Language_set", _wrap_LanguageInfo_Language_set, METH_VARARGS, NULL},
31075 { (char *)"LanguageInfo_Language_get", (PyCFunction)_wrap_LanguageInfo_Language_get, METH_O, NULL},
31076 { (char *)"LanguageInfo_CanonicalName_set", _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS, NULL},
31077 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction)_wrap_LanguageInfo_CanonicalName_get, METH_O, NULL},
31078 { (char *)"LanguageInfo_Description_set", _wrap_LanguageInfo_Description_set, METH_VARARGS, NULL},
31079 { (char *)"LanguageInfo_Description_get", (PyCFunction)_wrap_LanguageInfo_Description_get, METH_O, NULL},
31080 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
31081 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"delete_Locale", (PyCFunction)_wrap_delete_Locale, METH_O, NULL},
31083 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Locale_GetSystemLanguage", (PyCFunction)_wrap_Locale_GetSystemLanguage, METH_NOARGS, NULL},
31086 { (char *)"Locale_GetSystemEncoding", (PyCFunction)_wrap_Locale_GetSystemEncoding, METH_NOARGS, NULL},
31087 { (char *)"Locale_GetSystemEncodingName", (PyCFunction)_wrap_Locale_GetSystemEncodingName, METH_NOARGS, NULL},
31088 { (char *)"Locale_IsOk", (PyCFunction)_wrap_Locale_IsOk, METH_O, NULL},
31089 { (char *)"Locale_GetLocale", (PyCFunction)_wrap_Locale_GetLocale, METH_O, NULL},
31090 { (char *)"Locale_GetLanguage", (PyCFunction)_wrap_Locale_GetLanguage, METH_O, NULL},
31091 { (char *)"Locale_GetSysName", (PyCFunction)_wrap_Locale_GetSysName, METH_O, NULL},
31092 { (char *)"Locale_GetCanonicalName", (PyCFunction)_wrap_Locale_GetCanonicalName, METH_O, NULL},
31093 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"Locale_GetName", (PyCFunction)_wrap_Locale_GetName, METH_O, NULL},
31102 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
31103 { (char *)"Locale_swiginit", Locale_swiginit, METH_VARARGS, NULL},
31104 { (char *)"new_PyLocale", (PyCFunction) _wrap_new_PyLocale, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"delete_PyLocale", (PyCFunction)_wrap_delete_PyLocale, METH_O, NULL},
31106 { (char *)"PyLocale__setCallbackInfo", (PyCFunction) _wrap_PyLocale__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"PyLocale_GetSingularString", (PyCFunction) _wrap_PyLocale_GetSingularString, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"PyLocale_GetPluralString", (PyCFunction) _wrap_PyLocale_GetPluralString, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"PyLocale_swigregister", PyLocale_swigregister, METH_VARARGS, NULL},
31110 { (char *)"PyLocale_swiginit", PyLocale_swiginit, METH_VARARGS, NULL},
31111 { (char *)"GetLocale", (PyCFunction)_wrap_GetLocale, METH_NOARGS, NULL},
31112 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
31113 { (char *)"new_EncodingConverter", (PyCFunction)_wrap_new_EncodingConverter, METH_NOARGS, NULL},
31114 { (char *)"delete_EncodingConverter", (PyCFunction)_wrap_delete_EncodingConverter, METH_O, NULL},
31115 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
31121 { (char *)"EncodingConverter_swiginit", EncodingConverter_swiginit, METH_VARARGS, NULL},
31122 { (char *)"delete_DC", (PyCFunction)_wrap_delete_DC, METH_O, NULL},
31123 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"DC_GradientFillConcentric", (PyCFunction) _wrap_DC_GradientFillConcentric, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"DC_GradientFillLinear", (PyCFunction) _wrap_DC_GradientFillLinear, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"DC_Clear", (PyCFunction)_wrap_DC_Clear, METH_O, NULL},
31172 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"DC_EndDoc", (PyCFunction)_wrap_DC_EndDoc, METH_O, NULL},
31174 { (char *)"DC_StartPage", (PyCFunction)_wrap_DC_StartPage, METH_O, NULL},
31175 { (char *)"DC_EndPage", (PyCFunction)_wrap_DC_EndPage, METH_O, NULL},
31176 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"DC_DestroyClippingRegion", (PyCFunction)_wrap_DC_DestroyClippingRegion, METH_O, NULL},
31183 { (char *)"DC_GetClippingBox", (PyCFunction)_wrap_DC_GetClippingBox, METH_O, NULL},
31184 { (char *)"DC_GetClippingRect", (PyCFunction)_wrap_DC_GetClippingRect, METH_O, NULL},
31185 { (char *)"DC_GetCharHeight", (PyCFunction)_wrap_DC_GetCharHeight, METH_O, NULL},
31186 { (char *)"DC_GetCharWidth", (PyCFunction)_wrap_DC_GetCharWidth, METH_O, NULL},
31187 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"DC_GetSize", (PyCFunction)_wrap_DC_GetSize, METH_O, NULL},
31192 { (char *)"DC_GetSizeTuple", (PyCFunction)_wrap_DC_GetSizeTuple, METH_O, NULL},
31193 { (char *)"DC_GetSizeMM", (PyCFunction)_wrap_DC_GetSizeMM, METH_O, NULL},
31194 { (char *)"DC_GetSizeMMTuple", (PyCFunction)_wrap_DC_GetSizeMMTuple, METH_O, NULL},
31195 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"DC_CanDrawBitmap", (PyCFunction)_wrap_DC_CanDrawBitmap, METH_O, NULL},
31204 { (char *)"DC_CanGetTextExtent", (PyCFunction)_wrap_DC_CanGetTextExtent, METH_O, NULL},
31205 { (char *)"DC_GetDepth", (PyCFunction)_wrap_DC_GetDepth, METH_O, NULL},
31206 { (char *)"DC_GetPPI", (PyCFunction)_wrap_DC_GetPPI, METH_O, NULL},
31207 { (char *)"DC_Ok", (PyCFunction)_wrap_DC_Ok, METH_O, NULL},
31208 { (char *)"DC_GetBackgroundMode", (PyCFunction)_wrap_DC_GetBackgroundMode, METH_O, NULL},
31209 { (char *)"DC_GetBackground", (PyCFunction)_wrap_DC_GetBackground, METH_O, NULL},
31210 { (char *)"DC_GetBrush", (PyCFunction)_wrap_DC_GetBrush, METH_O, NULL},
31211 { (char *)"DC_GetFont", (PyCFunction)_wrap_DC_GetFont, METH_O, NULL},
31212 { (char *)"DC_GetPen", (PyCFunction)_wrap_DC_GetPen, METH_O, NULL},
31213 { (char *)"DC_GetTextBackground", (PyCFunction)_wrap_DC_GetTextBackground, METH_O, NULL},
31214 { (char *)"DC_GetTextForeground", (PyCFunction)_wrap_DC_GetTextForeground, METH_O, NULL},
31215 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"DC_GetMapMode", (PyCFunction)_wrap_DC_GetMapMode, METH_O, NULL},
31218 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"DC_GetUserScale", (PyCFunction)_wrap_DC_GetUserScale, METH_O, NULL},
31220 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"DC_GetLogicalScale", (PyCFunction)_wrap_DC_GetLogicalScale, METH_O, NULL},
31222 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"DC_GetLogicalOrigin", (PyCFunction)_wrap_DC_GetLogicalOrigin, METH_O, NULL},
31224 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction)_wrap_DC_GetLogicalOriginTuple, METH_O, NULL},
31225 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"DC_GetDeviceOrigin", (PyCFunction)_wrap_DC_GetDeviceOrigin, METH_O, NULL},
31228 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction)_wrap_DC_GetDeviceOriginTuple, METH_O, NULL},
31229 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"DC_GetLogicalFunction", (PyCFunction)_wrap_DC_GetLogicalFunction, METH_O, NULL},
31233 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction)_wrap_DC_ComputeScaleAndOrigin, METH_O, NULL},
31235 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"DC_ResetBoundingBox", (PyCFunction)_wrap_DC_ResetBoundingBox, METH_O, NULL},
31238 { (char *)"DC_MinX", (PyCFunction)_wrap_DC_MinX, METH_O, NULL},
31239 { (char *)"DC_MaxX", (PyCFunction)_wrap_DC_MaxX, METH_O, NULL},
31240 { (char *)"DC_MinY", (PyCFunction)_wrap_DC_MinY, METH_O, NULL},
31241 { (char *)"DC_MaxY", (PyCFunction)_wrap_DC_MaxY, METH_O, NULL},
31242 { (char *)"DC_GetBoundingBox", (PyCFunction)_wrap_DC_GetBoundingBox, METH_O, NULL},
31243 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
31250 { (char *)"new_MemoryDC", (PyCFunction)_wrap_new_MemoryDC, METH_NOARGS, NULL},
31251 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
31254 { (char *)"MemoryDC_swiginit", MemoryDC_swiginit, METH_VARARGS, NULL},
31255 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
31256 { (char *)"delete_BufferedDC", (PyCFunction)_wrap_delete_BufferedDC, METH_O, NULL},
31257 { (char *)"BufferedDC_UnMask", (PyCFunction)_wrap_BufferedDC_UnMask, METH_O, NULL},
31258 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
31259 { (char *)"BufferedDC_swiginit", BufferedDC_swiginit, METH_VARARGS, NULL},
31260 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
31262 { (char *)"BufferedPaintDC_swiginit", BufferedPaintDC_swiginit, METH_VARARGS, NULL},
31263 { (char *)"new_ScreenDC", (PyCFunction)_wrap_new_ScreenDC, METH_NOARGS, NULL},
31264 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction)_wrap_ScreenDC_EndDrawingOnTop, METH_O, NULL},
31267 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
31268 { (char *)"ScreenDC_swiginit", ScreenDC_swiginit, METH_VARARGS, NULL},
31269 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
31271 { (char *)"ClientDC_swiginit", ClientDC_swiginit, METH_VARARGS, NULL},
31272 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
31274 { (char *)"PaintDC_swiginit", PaintDC_swiginit, METH_VARARGS, NULL},
31275 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
31277 { (char *)"WindowDC_swiginit", WindowDC_swiginit, METH_VARARGS, NULL},
31278 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
31280 { (char *)"MirrorDC_swiginit", MirrorDC_swiginit, METH_VARARGS, NULL},
31281 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"PostScriptDC_GetPrintData", (PyCFunction)_wrap_PostScriptDC_GetPrintData, METH_O, NULL},
31283 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"PostScriptDC_GetResolution", (PyCFunction)_wrap_PostScriptDC_GetResolution, METH_NOARGS, NULL},
31286 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
31287 { (char *)"PostScriptDC_swiginit", PostScriptDC_swiginit, METH_VARARGS, NULL},
31288 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"delete_MetaFile", (PyCFunction)_wrap_delete_MetaFile, METH_O, NULL},
31290 { (char *)"MetaFile_Ok", (PyCFunction)_wrap_MetaFile_Ok, METH_O, NULL},
31291 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"MetaFile_GetSize", (PyCFunction)_wrap_MetaFile_GetSize, METH_O, NULL},
31293 { (char *)"MetaFile_GetWidth", (PyCFunction)_wrap_MetaFile_GetWidth, METH_O, NULL},
31294 { (char *)"MetaFile_GetHeight", (PyCFunction)_wrap_MetaFile_GetHeight, METH_O, NULL},
31295 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
31296 { (char *)"MetaFile_swiginit", MetaFile_swiginit, METH_VARARGS, NULL},
31297 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"MetaFileDC_Close", (PyCFunction)_wrap_MetaFileDC_Close, METH_O, NULL},
31299 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
31300 { (char *)"MetaFileDC_swiginit", MetaFileDC_swiginit, METH_VARARGS, NULL},
31301 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
31303 { (char *)"PrinterDC_swiginit", PrinterDC_swiginit, METH_VARARGS, NULL},
31304 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"delete_ImageList", (PyCFunction)_wrap_delete_ImageList, METH_O, NULL},
31306 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"ImageList_GetImageCount", (PyCFunction)_wrap_ImageList_GetImageCount, METH_O, NULL},
31314 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"ImageList_RemoveAll", (PyCFunction)_wrap_ImageList_RemoveAll, METH_O, NULL},
31316 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
31318 { (char *)"ImageList_swiginit", ImageList_swiginit, METH_VARARGS, NULL},
31319 { (char *)"new_StockGDI", (PyCFunction)_wrap_new_StockGDI, METH_NOARGS, NULL},
31320 { (char *)"delete_StockGDI", (PyCFunction)_wrap_delete_StockGDI, METH_O, NULL},
31321 { (char *)"StockGDI_DeleteAll", (PyCFunction)_wrap_StockGDI_DeleteAll, METH_NOARGS, NULL},
31322 { (char *)"StockGDI_instance", (PyCFunction)_wrap_StockGDI_instance, METH_NOARGS, NULL},
31323 { (char *)"StockGDI_GetBrush", (PyCFunction) _wrap_StockGDI_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"StockGDI_GetColour", (PyCFunction) _wrap_StockGDI_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"StockGDI_GetCursor", (PyCFunction) _wrap_StockGDI_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"StockGDI_GetPen", (PyCFunction) _wrap_StockGDI_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"StockGDI_GetFont", (PyCFunction) _wrap_StockGDI_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"StockGDI_swigregister", StockGDI_swigregister, METH_VARARGS, NULL},
31329 { (char *)"StockGDI_swiginit", StockGDI_swiginit, METH_VARARGS, NULL},
31330 { (char *)"new_GDIObjListBase", (PyCFunction)_wrap_new_GDIObjListBase, METH_NOARGS, NULL},
31331 { (char *)"delete_GDIObjListBase", (PyCFunction)_wrap_delete_GDIObjListBase, METH_O, NULL},
31332 { (char *)"GDIObjListBase_swigregister", GDIObjListBase_swigregister, METH_VARARGS, NULL},
31333 { (char *)"GDIObjListBase_swiginit", GDIObjListBase_swiginit, METH_VARARGS, NULL},
31334 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
31338 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
31342 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
31346 { (char *)"new_ColourDatabase", (PyCFunction)_wrap_new_ColourDatabase, METH_NOARGS, NULL},
31347 { (char *)"delete_ColourDatabase", (PyCFunction)_wrap_delete_ColourDatabase, METH_O, NULL},
31348 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
31353 { (char *)"ColourDatabase_swiginit", ColourDatabase_swiginit, METH_VARARGS, NULL},
31354 { (char *)"_wxPyInitTheFontList", (PyCFunction)_wrap__wxPyInitTheFontList, METH_NOARGS, NULL},
31355 { (char *)"_wxPyInitThePenList", (PyCFunction)_wrap__wxPyInitThePenList, METH_NOARGS, NULL},
31356 { (char *)"_wxPyInitTheBrushList", (PyCFunction)_wrap__wxPyInitTheBrushList, METH_NOARGS, NULL},
31357 { (char *)"_wxPyInitTheColourDatabase", (PyCFunction)_wrap__wxPyInitTheColourDatabase, METH_NOARGS, NULL},
31358 { (char *)"new_Effects", (PyCFunction)_wrap_new_Effects, METH_NOARGS, NULL},
31359 { (char *)"Effects_GetHighlightColour", (PyCFunction)_wrap_Effects_GetHighlightColour, METH_O, NULL},
31360 { (char *)"Effects_GetLightShadow", (PyCFunction)_wrap_Effects_GetLightShadow, METH_O, NULL},
31361 { (char *)"Effects_GetFaceColour", (PyCFunction)_wrap_Effects_GetFaceColour, METH_O, NULL},
31362 { (char *)"Effects_GetMediumShadow", (PyCFunction)_wrap_Effects_GetMediumShadow, METH_O, NULL},
31363 { (char *)"Effects_GetDarkShadow", (PyCFunction)_wrap_Effects_GetDarkShadow, METH_O, NULL},
31364 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
31373 { (char *)"Effects_swiginit", Effects_swiginit, METH_VARARGS, NULL},
31374 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"delete_SplitterRenderParams", (PyCFunction)_wrap_delete_SplitterRenderParams, METH_O, NULL},
31376 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction)_wrap_SplitterRenderParams_widthSash_get, METH_O, NULL},
31377 { (char *)"SplitterRenderParams_border_get", (PyCFunction)_wrap_SplitterRenderParams_border_get, METH_O, NULL},
31378 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction)_wrap_SplitterRenderParams_isHotSensitive_get, METH_O, NULL},
31379 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
31380 { (char *)"SplitterRenderParams_swiginit", SplitterRenderParams_swiginit, METH_VARARGS, NULL},
31381 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"delete_RendererVersion", (PyCFunction)_wrap_delete_RendererVersion, METH_O, NULL},
31383 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"RendererVersion_version_get", (PyCFunction)_wrap_RendererVersion_version_get, METH_O, NULL},
31385 { (char *)"RendererVersion_age_get", (PyCFunction)_wrap_RendererVersion_age_get, METH_O, NULL},
31386 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
31387 { (char *)"RendererVersion_swiginit", RendererVersion_swiginit, METH_VARARGS, NULL},
31388 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"RendererNative_DrawCheckBox", (PyCFunction) _wrap_RendererNative_DrawCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"RendererNative_DrawPushButton", (PyCFunction) _wrap_RendererNative_DrawPushButton, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"RendererNative_DrawItemSelectionRect", (PyCFunction) _wrap_RendererNative_DrawItemSelectionRect, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"RendererNative_Get", (PyCFunction)_wrap_RendererNative_Get, METH_NOARGS, NULL},
31399 { (char *)"RendererNative_GetGeneric", (PyCFunction)_wrap_RendererNative_GetGeneric, METH_NOARGS, NULL},
31400 { (char *)"RendererNative_GetDefault", (PyCFunction)_wrap_RendererNative_GetDefault, METH_NOARGS, NULL},
31401 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"RendererNative_GetVersion", (PyCFunction)_wrap_RendererNative_GetVersion, METH_O, NULL},
31403 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
31404 { (char *)"new_PseudoDC", (PyCFunction)_wrap_new_PseudoDC, METH_NOARGS, NULL},
31405 { (char *)"PseudoDC_BeginDrawing", (PyCFunction)_wrap_PseudoDC_BeginDrawing, METH_O, NULL},
31406 { (char *)"PseudoDC_EndDrawing", (PyCFunction)_wrap_PseudoDC_EndDrawing, METH_O, NULL},
31407 { (char *)"delete_PseudoDC", (PyCFunction)_wrap_delete_PseudoDC, METH_O, NULL},
31408 { (char *)"PseudoDC_RemoveAll", (PyCFunction)_wrap_PseudoDC_RemoveAll, METH_O, NULL},
31409 { (char *)"PseudoDC_GetLen", (PyCFunction)_wrap_PseudoDC_GetLen, METH_O, NULL},
31410 { (char *)"PseudoDC_SetId", (PyCFunction) _wrap_PseudoDC_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"PseudoDC_ClearId", (PyCFunction) _wrap_PseudoDC_ClearId, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"PseudoDC_RemoveId", (PyCFunction) _wrap_PseudoDC_RemoveId, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"PseudoDC_TranslateId", (PyCFunction) _wrap_PseudoDC_TranslateId, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"PseudoDC_DrawIdToDC", (PyCFunction) _wrap_PseudoDC_DrawIdToDC, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"PseudoDC_SetIdBounds", (PyCFunction) _wrap_PseudoDC_SetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"PseudoDC_GetIdBounds", (PyCFunction) _wrap_PseudoDC_GetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"PseudoDC_DrawToDCClipped", (PyCFunction) _wrap_PseudoDC_DrawToDCClipped, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"PseudoDC_DrawToDCClippedRgn", (PyCFunction) _wrap_PseudoDC_DrawToDCClippedRgn, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"PseudoDC_DrawToDC", (PyCFunction) _wrap_PseudoDC_DrawToDC, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"PseudoDC_FloodFill", (PyCFunction) _wrap_PseudoDC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"PseudoDC_FloodFillPoint", (PyCFunction) _wrap_PseudoDC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"PseudoDC_DrawLine", (PyCFunction) _wrap_PseudoDC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"PseudoDC_DrawLinePoint", (PyCFunction) _wrap_PseudoDC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"PseudoDC_CrossHair", (PyCFunction) _wrap_PseudoDC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"PseudoDC_CrossHairPoint", (PyCFunction) _wrap_PseudoDC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"PseudoDC_DrawArc", (PyCFunction) _wrap_PseudoDC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"PseudoDC_DrawArcPoint", (PyCFunction) _wrap_PseudoDC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"PseudoDC_DrawCheckMark", (PyCFunction) _wrap_PseudoDC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"PseudoDC_DrawCheckMarkRect", (PyCFunction) _wrap_PseudoDC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"PseudoDC_DrawEllipticArc", (PyCFunction) _wrap_PseudoDC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"PseudoDC_DrawEllipticArcPointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"PseudoDC_DrawPoint", (PyCFunction) _wrap_PseudoDC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"PseudoDC_DrawPointPoint", (PyCFunction) _wrap_PseudoDC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"PseudoDC_DrawRectangle", (PyCFunction) _wrap_PseudoDC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"PseudoDC_DrawRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"PseudoDC_DrawRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"PseudoDC_DrawRoundedRectangle", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"PseudoDC_DrawRoundedRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"PseudoDC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"PseudoDC_DrawCircle", (PyCFunction) _wrap_PseudoDC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"PseudoDC_DrawCirclePoint", (PyCFunction) _wrap_PseudoDC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"PseudoDC_DrawEllipse", (PyCFunction) _wrap_PseudoDC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"PseudoDC_DrawEllipseRect", (PyCFunction) _wrap_PseudoDC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"PseudoDC_DrawEllipsePointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"PseudoDC_DrawIcon", (PyCFunction) _wrap_PseudoDC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"PseudoDC_DrawIconPoint", (PyCFunction) _wrap_PseudoDC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"PseudoDC_DrawBitmap", (PyCFunction) _wrap_PseudoDC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"PseudoDC_DrawBitmapPoint", (PyCFunction) _wrap_PseudoDC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"PseudoDC_DrawText", (PyCFunction) _wrap_PseudoDC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"PseudoDC_DrawTextPoint", (PyCFunction) _wrap_PseudoDC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"PseudoDC_DrawRotatedText", (PyCFunction) _wrap_PseudoDC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"PseudoDC_DrawRotatedTextPoint", (PyCFunction) _wrap_PseudoDC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"PseudoDC_DrawLines", (PyCFunction) _wrap_PseudoDC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"PseudoDC_DrawPolygon", (PyCFunction) _wrap_PseudoDC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"PseudoDC_DrawLabel", (PyCFunction) _wrap_PseudoDC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"PseudoDC_DrawImageLabel", (PyCFunction) _wrap_PseudoDC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"PseudoDC_DrawSpline", (PyCFunction) _wrap_PseudoDC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"PseudoDC_Clear", (PyCFunction)_wrap_PseudoDC_Clear, METH_O, NULL},
31459 { (char *)"PseudoDC_SetFont", (PyCFunction) _wrap_PseudoDC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"PseudoDC_SetPen", (PyCFunction) _wrap_PseudoDC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"PseudoDC_SetBrush", (PyCFunction) _wrap_PseudoDC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"PseudoDC_SetBackground", (PyCFunction) _wrap_PseudoDC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"PseudoDC_SetBackgroundMode", (PyCFunction) _wrap_PseudoDC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"PseudoDC_SetPalette", (PyCFunction) _wrap_PseudoDC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"PseudoDC_SetTextForeground", (PyCFunction) _wrap_PseudoDC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"PseudoDC_SetTextBackground", (PyCFunction) _wrap_PseudoDC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"PseudoDC_SetLogicalFunction", (PyCFunction) _wrap_PseudoDC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"PseudoDC_swigregister", PseudoDC_swigregister, METH_VARARGS, NULL},
31469 { (char *)"PseudoDC_swiginit", PseudoDC_swiginit, METH_VARARGS, NULL},
31470 { NULL, NULL, 0, NULL }
31471 };
31472
31473
31474 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31475
31476 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
31477 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
31478 }
31479 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
31480 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
31481 }
31482 static void *_p_wxPyLocaleTo_p_wxLocale(void *x) {
31483 return (void *)((wxLocale *) ((wxPyLocale *) x));
31484 }
31485 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
31486 return (void *)((wxGDIObject *) ((wxIcon *) x));
31487 }
31488 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
31489 return (void *)((wxGDIObject *) ((wxPalette *) x));
31490 }
31491 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
31492 return (void *)((wxGDIObject *) ((wxPen *) x));
31493 }
31494 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
31495 return (void *)((wxGDIObject *) ((wxFont *) x));
31496 }
31497 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
31498 return (void *)((wxGDIObject *) ((wxCursor *) x));
31499 }
31500 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
31501 return (void *)((wxGDIObject *) ((wxBitmap *) x));
31502 }
31503 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
31504 return (void *)((wxGDIObject *) ((wxRegion *) x));
31505 }
31506 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
31507 return (void *)((wxGDIObject *) ((wxBrush *) x));
31508 }
31509 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
31510 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
31511 }
31512 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
31513 return (void *)((wxDC *) ((wxScreenDC *) x));
31514 }
31515 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
31516 return (void *)((wxDC *) ((wxMirrorDC *) x));
31517 }
31518 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
31519 return (void *)((wxDC *) ((wxMemoryDC *) x));
31520 }
31521 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
31522 return (void *)((wxDC *) ((wxWindowDC *) x));
31523 }
31524 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
31525 return (void *)((wxDC *) ((wxMetaFileDC *) x));
31526 }
31527 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
31528 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
31529 }
31530 static void *_p_wxClientDCTo_p_wxDC(void *x) {
31531 return (void *)((wxDC *) ((wxClientDC *) x));
31532 }
31533 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
31534 return (void *)((wxDC *) ((wxPaintDC *) x));
31535 }
31536 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
31537 return (void *)((wxDC *) ((wxPostScriptDC *) x));
31538 }
31539 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
31540 return (void *)((wxDC *) ((wxPrinterDC *) x));
31541 }
31542 static void *_p_wxBrushListTo_p_wxGDIObjListBase(void *x) {
31543 return (void *)((wxGDIObjListBase *) ((wxBrushList *) x));
31544 }
31545 static void *_p_wxFontListTo_p_wxGDIObjListBase(void *x) {
31546 return (void *)((wxGDIObjListBase *) ((wxFontList *) x));
31547 }
31548 static void *_p_wxPenListTo_p_wxGDIObjListBase(void *x) {
31549 return (void *)((wxGDIObjListBase *) ((wxPenList *) x));
31550 }
31551 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
31552 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
31553 }
31554 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
31555 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
31556 }
31557 static void *_p_wxPenTo_p_wxObject(void *x) {
31558 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
31559 }
31560 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
31561 return (void *)((wxObject *) ((wxRegionIterator *) x));
31562 }
31563 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
31564 return (void *)((wxObject *) ((wxSizerItem *) x));
31565 }
31566 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
31567 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
31568 }
31569 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
31570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
31571 }
31572 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
31573 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
31574 }
31575 static void *_p_wxIconTo_p_wxObject(void *x) {
31576 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
31577 }
31578 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
31579 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
31580 }
31581 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
31582 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
31583 }
31584 static void *_p_wxSizerTo_p_wxObject(void *x) {
31585 return (void *)((wxObject *) ((wxSizer *) x));
31586 }
31587 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
31588 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
31589 }
31590 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
31591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
31592 }
31593 static void *_p_wxEventTo_p_wxObject(void *x) {
31594 return (void *)((wxObject *) ((wxEvent *) x));
31595 }
31596 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
31597 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
31598 }
31599 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
31600 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
31601 }
31602 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
31603 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
31604 }
31605 static void *_p_wxPseudoDCTo_p_wxObject(void *x) {
31606 return (void *)((wxObject *) ((wxPseudoDC *) x));
31607 }
31608 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
31609 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
31610 }
31611 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
31612 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
31613 }
31614 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
31615 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
31616 }
31617 static void *_p_wxDCTo_p_wxObject(void *x) {
31618 return (void *)((wxObject *) ((wxDC *) x));
31619 }
31620 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
31621 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
31622 }
31623 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
31624 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
31625 }
31626 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
31627 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31628 }
31629 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
31630 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
31631 }
31632 static void *_p_wxControlTo_p_wxObject(void *x) {
31633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
31634 }
31635 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
31636 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
31637 }
31638 static void *_p_wxClientDCTo_p_wxObject(void *x) {
31639 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
31640 }
31641 static void *_p_wxFSFileTo_p_wxObject(void *x) {
31642 return (void *)((wxObject *) ((wxFSFile *) x));
31643 }
31644 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
31645 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
31646 }
31647 static void *_p_wxRegionTo_p_wxObject(void *x) {
31648 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
31649 }
31650 static void *_p_wxPySizerTo_p_wxObject(void *x) {
31651 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
31652 }
31653 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
31654 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
31655 }
31656 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
31657 return (void *)((wxObject *) ((wxGDIObject *) x));
31658 }
31659 static void *_p_wxEffectsTo_p_wxObject(void *x) {
31660 return (void *)((wxObject *) ((wxEffects *) x));
31661 }
31662 static void *_p_wxPyEventTo_p_wxObject(void *x) {
31663 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
31664 }
31665 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
31666 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
31667 }
31668 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
31669 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
31670 }
31671 static void *_p_wxShowEventTo_p_wxObject(void *x) {
31672 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
31673 }
31674 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
31675 return (void *)((wxObject *) ((wxMenuItem *) x));
31676 }
31677 static void *_p_wxDateEventTo_p_wxObject(void *x) {
31678 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
31679 }
31680 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
31681 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
31682 }
31683 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
31684 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
31685 }
31686 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
31687 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
31688 }
31689 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
31690 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
31691 }
31692 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
31693 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
31694 }
31695 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
31696 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
31697 }
31698 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
31699 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
31700 }
31701 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
31702 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
31703 }
31704 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
31705 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
31706 }
31707 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
31708 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
31709 }
31710 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
31711 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
31712 }
31713 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
31714 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
31715 }
31716 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
31717 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
31718 }
31719 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
31720 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
31721 }
31722 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
31723 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
31724 }
31725 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
31726 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
31727 }
31728 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
31729 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
31730 }
31731 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
31732 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
31733 }
31734 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
31735 return (void *)((wxObject *) ((wxImageHandler *) x));
31736 }
31737 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
31738 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
31739 }
31740 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
31741 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
31742 }
31743 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
31744 return (void *)((wxObject *) ((wxEvtHandler *) x));
31745 }
31746 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
31747 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
31748 }
31749 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
31750 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
31751 }
31752 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
31753 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
31754 }
31755 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
31756 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
31757 }
31758 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
31759 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
31760 }
31761 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
31762 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
31763 }
31764 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
31765 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
31766 }
31767 static void *_p_wxImageTo_p_wxObject(void *x) {
31768 return (void *)((wxObject *) ((wxImage *) x));
31769 }
31770 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
31771 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
31772 }
31773 static void *_p_wxPaletteTo_p_wxObject(void *x) {
31774 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
31775 }
31776 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
31777 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
31778 }
31779 static void *_p_wxImageListTo_p_wxObject(void *x) {
31780 return (void *)((wxObject *) ((wxImageList *) x));
31781 }
31782 static void *_p_wxCursorTo_p_wxObject(void *x) {
31783 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
31784 }
31785 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
31786 return (void *)((wxObject *) ((wxEncodingConverter *) x));
31787 }
31788 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
31789 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
31790 }
31791 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
31792 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31793 }
31794 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
31795 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
31796 }
31797 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
31798 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
31799 }
31800 static void *_p_wxWindowTo_p_wxObject(void *x) {
31801 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
31802 }
31803 static void *_p_wxMenuTo_p_wxObject(void *x) {
31804 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
31805 }
31806 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
31807 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
31808 }
31809 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
31810 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
31811 }
31812 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
31813 return (void *)((wxObject *) ((wxFileSystem *) x));
31814 }
31815 static void *_p_wxBitmapTo_p_wxObject(void *x) {
31816 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
31817 }
31818 static void *_p_wxMaskTo_p_wxObject(void *x) {
31819 return (void *)((wxObject *) ((wxMask *) x));
31820 }
31821 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
31822 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
31823 }
31824 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
31825 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
31826 }
31827 static void *_p_wxPyAppTo_p_wxObject(void *x) {
31828 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
31829 }
31830 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
31831 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
31832 }
31833 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
31834 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
31835 }
31836 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
31837 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
31838 }
31839 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
31840 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
31841 }
31842 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
31843 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
31844 }
31845 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
31846 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
31847 }
31848 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
31849 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
31850 }
31851 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
31852 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
31853 }
31854 static void *_p_wxFontTo_p_wxObject(void *x) {
31855 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
31856 }
31857 static void *_p_wxBrushTo_p_wxObject(void *x) {
31858 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
31859 }
31860 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
31861 return (void *)((wxObject *) ((wxMetaFile *) x));
31862 }
31863 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
31864 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31865 }
31866 static void *_p_wxColourTo_p_wxObject(void *x) {
31867 return (void *)((wxObject *) ((wxColour *) x));
31868 }
31869 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
31870 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
31871 }
31872 static void *_p_wxValidatorTo_p_wxObject(void *x) {
31873 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
31874 }
31875 static void *_p_wxControlTo_p_wxWindow(void *x) {
31876 return (void *)((wxWindow *) ((wxControl *) x));
31877 }
31878 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
31879 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
31880 }
31881 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
31882 return (void *)((wxWindow *) ((wxMenuBar *) x));
31883 }
31884 static void *_p_wxNativePixelDataTo_p_wxPixelDataBase(void *x) {
31885 return (void *)((wxPixelDataBase *) ((wxNativePixelData *) x));
31886 }
31887 static void *_p_wxAlphaPixelDataTo_p_wxPixelDataBase(void *x) {
31888 return (void *)((wxPixelDataBase *) ((wxAlphaPixelData *) x));
31889 }
31890 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
31891 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
31892 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
31893 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
31894 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
31895 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
31896 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
31897 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
31898 static swig_type_info _swigt__p_wxAlphaPixelData = {"_p_wxAlphaPixelData", "wxAlphaPixelData *", 0, 0, (void*)0, 0};
31899 static swig_type_info _swigt__p_wxAlphaPixelData_Accessor = {"_p_wxAlphaPixelData_Accessor", "wxAlphaPixelData_Accessor *", 0, 0, (void*)0, 0};
31900 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
31901 static swig_type_info _swigt__p_wxBrush = {"_p_wxBrush", "wxBrush *", 0, 0, (void*)0, 0};
31902 static swig_type_info _swigt__p_wxBrushList = {"_p_wxBrushList", "wxBrushList *", 0, 0, (void*)0, 0};
31903 static swig_type_info _swigt__p_wxBufferedDC = {"_p_wxBufferedDC", "wxBufferedDC *", 0, 0, (void*)0, 0};
31904 static swig_type_info _swigt__p_wxBufferedPaintDC = {"_p_wxBufferedPaintDC", "wxBufferedPaintDC *", 0, 0, (void*)0, 0};
31905 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
31906 static swig_type_info _swigt__p_wxClientDC = {"_p_wxClientDC", "wxClientDC *", 0, 0, (void*)0, 0};
31907 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
31908 static swig_type_info _swigt__p_wxColourDatabase = {"_p_wxColourDatabase", "wxColourDatabase *", 0, 0, (void*)0, 0};
31909 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
31910 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
31911 static swig_type_info _swigt__p_wxDash = {"_p_wxDash", "wxDash *", 0, 0, (void*)0, 0};
31912 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
31913 static swig_type_info _swigt__p_wxEffects = {"_p_wxEffects", "wxEffects *", 0, 0, (void*)0, 0};
31914 static swig_type_info _swigt__p_wxEncodingConverter = {"_p_wxEncodingConverter", "wxEncodingConverter *", 0, 0, (void*)0, 0};
31915 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
31916 static swig_type_info _swigt__p_wxFontList = {"_p_wxFontList", "wxFontList *", 0, 0, (void*)0, 0};
31917 static swig_type_info _swigt__p_wxFontMapper = {"_p_wxFontMapper", "wxFontMapper *", 0, 0, (void*)0, 0};
31918 static swig_type_info _swigt__p_wxGDIObjListBase = {"_p_wxGDIObjListBase", "wxGDIObjListBase *", 0, 0, (void*)0, 0};
31919 static swig_type_info _swigt__p_wxGDIObject = {"_p_wxGDIObject", "wxGDIObject *", 0, 0, (void*)0, 0};
31920 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
31921 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
31922 static swig_type_info _swigt__p_wxIconLocation = {"_p_wxIconLocation", "wxIconLocation *", 0, 0, (void*)0, 0};
31923 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
31924 static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
31925 static swig_type_info _swigt__p_wxLanguageInfo = {"_p_wxLanguageInfo", "wxLanguageInfo *", 0, 0, (void*)0, 0};
31926 static swig_type_info _swigt__p_wxLocale = {"_p_wxLocale", "wxLocale *", 0, 0, (void*)0, 0};
31927 static swig_type_info _swigt__p_wxMask = {"_p_wxMask", "wxMask *", 0, 0, (void*)0, 0};
31928 static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
31929 static swig_type_info _swigt__p_wxMetaFile = {"_p_wxMetaFile", "wxMetaFile *", 0, 0, (void*)0, 0};
31930 static swig_type_info _swigt__p_wxMetaFileDC = {"_p_wxMetaFileDC", "wxMetaFileDC *", 0, 0, (void*)0, 0};
31931 static swig_type_info _swigt__p_wxMirrorDC = {"_p_wxMirrorDC", "wxMirrorDC *", 0, 0, (void*)0, 0};
31932 static swig_type_info _swigt__p_wxNativeEncodingInfo = {"_p_wxNativeEncodingInfo", "wxNativeEncodingInfo *", 0, 0, (void*)0, 0};
31933 static swig_type_info _swigt__p_wxNativeFontInfo = {"_p_wxNativeFontInfo", "wxNativeFontInfo *", 0, 0, (void*)0, 0};
31934 static swig_type_info _swigt__p_wxNativePixelData = {"_p_wxNativePixelData", "wxNativePixelData *", 0, 0, (void*)0, 0};
31935 static swig_type_info _swigt__p_wxNativePixelData_Accessor = {"_p_wxNativePixelData_Accessor", "wxNativePixelData_Accessor *", 0, 0, (void*)0, 0};
31936 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
31937 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
31938 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
31939 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
31940 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
31941 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
31942 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
31943 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
31944 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
31945 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
31946 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
31947 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
31948 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
31949 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
31950 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
31951 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
31952 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
31953 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
31954 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
31955 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
31956 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
31957 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
31958 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
31959 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
31960 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
31961 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
31962 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
31963 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
31964 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
31965 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
31966 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
31967 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
31968 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
31969 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
31970 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
31971 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
31972 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
31973 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
31974 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
31975 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
31976 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
31977 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
31978 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
31979 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
31980 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
31981 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
31982 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
31983 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
31984 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
31985 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
31986 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
31987 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
31988 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
31989 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
31990 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
31991 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
31992 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
31993 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
31994 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
31995 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
31996 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
31997 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
31998 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
31999 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
32000 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
32001 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
32002 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
32003 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
32004 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
32005 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
32006 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
32007 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
32008 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
32009 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
32010 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
32011 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
32012 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
32013 static swig_type_info _swigt__p_wxPaintDC = {"_p_wxPaintDC", "wxPaintDC *", 0, 0, (void*)0, 0};
32014 static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, (void*)0, 0};
32015 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
32016 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
32017 static swig_type_info _swigt__p_wxPenList = {"_p_wxPenList", "wxPenList *", 0, 0, (void*)0, 0};
32018 static swig_type_info _swigt__p_wxPixelDataBase = {"_p_wxPixelDataBase", "wxPixelDataBase *", 0, 0, (void*)0, 0};
32019 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
32020 static swig_type_info _swigt__p_wxPostScriptDC = {"_p_wxPostScriptDC", "wxPostScriptDC *", 0, 0, (void*)0, 0};
32021 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};
32022 static swig_type_info _swigt__p_wxPrinterDC = {"_p_wxPrinterDC", "wxPrinterDC *", 0, 0, (void*)0, 0};
32023 static swig_type_info _swigt__p_wxPseudoDC = {"_p_wxPseudoDC", "wxPseudoDC *", 0, 0, (void*)0, 0};
32024 static swig_type_info _swigt__p_wxPyFontEnumerator = {"_p_wxPyFontEnumerator", "wxPyFontEnumerator *", 0, 0, (void*)0, 0};
32025 static swig_type_info _swigt__p_wxPyLocale = {"_p_wxPyLocale", "wxPyLocale *", 0, 0, (void*)0, 0};
32026 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
32027 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
32028 static swig_type_info _swigt__p_wxRegionIterator = {"_p_wxRegionIterator", "wxRegionIterator *", 0, 0, (void*)0, 0};
32029 static swig_type_info _swigt__p_wxRendererNative = {"_p_wxRendererNative", "wxRendererNative *", 0, 0, (void*)0, 0};
32030 static swig_type_info _swigt__p_wxRendererVersion = {"_p_wxRendererVersion", "wxRendererVersion *", 0, 0, (void*)0, 0};
32031 static swig_type_info _swigt__p_wxScreenDC = {"_p_wxScreenDC", "wxScreenDC *", 0, 0, (void*)0, 0};
32032 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
32033 static swig_type_info _swigt__p_wxSplitterRenderParams = {"_p_wxSplitterRenderParams", "wxSplitterRenderParams *", 0, 0, (void*)0, 0};
32034 static swig_type_info _swigt__p_wxStockGDI = {"_p_wxStockGDI", "wxStockGDI *", 0, 0, (void*)0, 0};
32035 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
32036 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
32037 static swig_type_info _swigt__p_wxWindowDC = {"_p_wxWindowDC", "wxWindowDC *", 0, 0, (void*)0, 0};
32038
32039 static swig_type_info *swig_type_initial[] = {
32040 &_swigt__p_buffer,
32041 &_swigt__p_char,
32042 &_swigt__p_double,
32043 &_swigt__p_form_ops_t,
32044 &_swigt__p_int,
32045 &_swigt__p_unsigned_char,
32046 &_swigt__p_unsigned_int,
32047 &_swigt__p_unsigned_long,
32048 &_swigt__p_wxANIHandler,
32049 &_swigt__p_wxAcceleratorTable,
32050 &_swigt__p_wxActivateEvent,
32051 &_swigt__p_wxAlphaPixelData,
32052 &_swigt__p_wxAlphaPixelData_Accessor,
32053 &_swigt__p_wxBMPHandler,
32054 &_swigt__p_wxBitmap,
32055 &_swigt__p_wxBoxSizer,
32056 &_swigt__p_wxBrush,
32057 &_swigt__p_wxBrushList,
32058 &_swigt__p_wxBufferedDC,
32059 &_swigt__p_wxBufferedPaintDC,
32060 &_swigt__p_wxCURHandler,
32061 &_swigt__p_wxChar,
32062 &_swigt__p_wxChildFocusEvent,
32063 &_swigt__p_wxClientDC,
32064 &_swigt__p_wxClipboardTextEvent,
32065 &_swigt__p_wxCloseEvent,
32066 &_swigt__p_wxColour,
32067 &_swigt__p_wxColourDatabase,
32068 &_swigt__p_wxCommandEvent,
32069 &_swigt__p_wxContextMenuEvent,
32070 &_swigt__p_wxControl,
32071 &_swigt__p_wxControlWithItems,
32072 &_swigt__p_wxCursor,
32073 &_swigt__p_wxDC,
32074 &_swigt__p_wxDash,
32075 &_swigt__p_wxDateEvent,
32076 &_swigt__p_wxDisplayChangedEvent,
32077 &_swigt__p_wxDropFilesEvent,
32078 &_swigt__p_wxDuplexMode,
32079 &_swigt__p_wxEffects,
32080 &_swigt__p_wxEncodingConverter,
32081 &_swigt__p_wxEraseEvent,
32082 &_swigt__p_wxEvent,
32083 &_swigt__p_wxEvtHandler,
32084 &_swigt__p_wxFSFile,
32085 &_swigt__p_wxFileSystem,
32086 &_swigt__p_wxFlexGridSizer,
32087 &_swigt__p_wxFocusEvent,
32088 &_swigt__p_wxFont,
32089 &_swigt__p_wxFontList,
32090 &_swigt__p_wxFontMapper,
32091 &_swigt__p_wxGBSizerItem,
32092 &_swigt__p_wxGDIObjListBase,
32093 &_swigt__p_wxGDIObject,
32094 &_swigt__p_wxGIFHandler,
32095 &_swigt__p_wxGridBagSizer,
32096 &_swigt__p_wxGridSizer,
32097 &_swigt__p_wxICOHandler,
32098 &_swigt__p_wxIcon,
32099 &_swigt__p_wxIconBundle,
32100 &_swigt__p_wxIconLocation,
32101 &_swigt__p_wxIconizeEvent,
32102 &_swigt__p_wxIdleEvent,
32103 &_swigt__p_wxImage,
32104 &_swigt__p_wxImageHandler,
32105 &_swigt__p_wxImageList,
32106 &_swigt__p_wxIndividualLayoutConstraint,
32107 &_swigt__p_wxInitDialogEvent,
32108 &_swigt__p_wxJPEGHandler,
32109 &_swigt__p_wxKeyEvent,
32110 &_swigt__p_wxLanguageInfo,
32111 &_swigt__p_wxLayoutConstraints,
32112 &_swigt__p_wxLocale,
32113 &_swigt__p_wxMask,
32114 &_swigt__p_wxMaximizeEvent,
32115 &_swigt__p_wxMemoryDC,
32116 &_swigt__p_wxMenu,
32117 &_swigt__p_wxMenuBar,
32118 &_swigt__p_wxMenuEvent,
32119 &_swigt__p_wxMenuItem,
32120 &_swigt__p_wxMetaFile,
32121 &_swigt__p_wxMetaFileDC,
32122 &_swigt__p_wxMirrorDC,
32123 &_swigt__p_wxMouseCaptureChangedEvent,
32124 &_swigt__p_wxMouseCaptureLostEvent,
32125 &_swigt__p_wxMouseEvent,
32126 &_swigt__p_wxMoveEvent,
32127 &_swigt__p_wxNativeEncodingInfo,
32128 &_swigt__p_wxNativeFontInfo,
32129 &_swigt__p_wxNativePixelData,
32130 &_swigt__p_wxNativePixelData_Accessor,
32131 &_swigt__p_wxNavigationKeyEvent,
32132 &_swigt__p_wxNcPaintEvent,
32133 &_swigt__p_wxNotifyEvent,
32134 &_swigt__p_wxObject,
32135 &_swigt__p_wxPCXHandler,
32136 &_swigt__p_wxPNGHandler,
32137 &_swigt__p_wxPNMHandler,
32138 &_swigt__p_wxPaintDC,
32139 &_swigt__p_wxPaintEvent,
32140 &_swigt__p_wxPalette,
32141 &_swigt__p_wxPaletteChangedEvent,
32142 &_swigt__p_wxPaperSize,
32143 &_swigt__p_wxPen,
32144 &_swigt__p_wxPenList,
32145 &_swigt__p_wxPixelDataBase,
32146 &_swigt__p_wxPoint,
32147 &_swigt__p_wxPostScriptDC,
32148 &_swigt__p_wxPrintData,
32149 &_swigt__p_wxPrinterDC,
32150 &_swigt__p_wxPseudoDC,
32151 &_swigt__p_wxPyApp,
32152 &_swigt__p_wxPyCommandEvent,
32153 &_swigt__p_wxPyEvent,
32154 &_swigt__p_wxPyFontEnumerator,
32155 &_swigt__p_wxPyImageHandler,
32156 &_swigt__p_wxPyLocale,
32157 &_swigt__p_wxPySizer,
32158 &_swigt__p_wxPyValidator,
32159 &_swigt__p_wxQueryNewPaletteEvent,
32160 &_swigt__p_wxRect,
32161 &_swigt__p_wxRegion,
32162 &_swigt__p_wxRegionIterator,
32163 &_swigt__p_wxRendererNative,
32164 &_swigt__p_wxRendererVersion,
32165 &_swigt__p_wxScreenDC,
32166 &_swigt__p_wxScrollEvent,
32167 &_swigt__p_wxScrollWinEvent,
32168 &_swigt__p_wxSetCursorEvent,
32169 &_swigt__p_wxShowEvent,
32170 &_swigt__p_wxSize,
32171 &_swigt__p_wxSizeEvent,
32172 &_swigt__p_wxSizer,
32173 &_swigt__p_wxSizerItem,
32174 &_swigt__p_wxSplitterRenderParams,
32175 &_swigt__p_wxStaticBoxSizer,
32176 &_swigt__p_wxStdDialogButtonSizer,
32177 &_swigt__p_wxStockGDI,
32178 &_swigt__p_wxString,
32179 &_swigt__p_wxSysColourChangedEvent,
32180 &_swigt__p_wxTIFFHandler,
32181 &_swigt__p_wxUpdateUIEvent,
32182 &_swigt__p_wxValidator,
32183 &_swigt__p_wxWindow,
32184 &_swigt__p_wxWindowCreateEvent,
32185 &_swigt__p_wxWindowDC,
32186 &_swigt__p_wxWindowDestroyEvent,
32187 &_swigt__p_wxXPMHandler,
32188 };
32189
32190 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
32191 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
32192 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
32193 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
32194 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
32195 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
32196 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
32197 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
32198 static swig_cast_info _swigc__p_wxAlphaPixelData[] = { {&_swigt__p_wxAlphaPixelData, 0, 0, 0},{0, 0, 0, 0}};
32199 static swig_cast_info _swigc__p_wxAlphaPixelData_Accessor[] = { {&_swigt__p_wxAlphaPixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
32200 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
32201 static swig_cast_info _swigc__p_wxBrush[] = { {&_swigt__p_wxBrush, 0, 0, 0},{0, 0, 0, 0}};
32202 static swig_cast_info _swigc__p_wxBrushList[] = { {&_swigt__p_wxBrushList, 0, 0, 0},{0, 0, 0, 0}};
32203 static swig_cast_info _swigc__p_wxBufferedDC[] = { {&_swigt__p_wxBufferedDC, 0, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxBufferedDC, 0, 0},{0, 0, 0, 0}};
32204 static swig_cast_info _swigc__p_wxBufferedPaintDC[] = { {&_swigt__p_wxBufferedPaintDC, 0, 0, 0},{0, 0, 0, 0}};
32205 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
32206 static swig_cast_info _swigc__p_wxClientDC[] = { {&_swigt__p_wxClientDC, 0, 0, 0},{0, 0, 0, 0}};
32207 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
32208 static swig_cast_info _swigc__p_wxColourDatabase[] = { {&_swigt__p_wxColourDatabase, 0, 0, 0},{0, 0, 0, 0}};
32209 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
32210 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxBufferedDC, _p_wxBufferedDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxScreenDC, _p_wxScreenDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxMirrorDC, _p_wxMirrorDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxMemoryDC, _p_wxMemoryDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxWindowDC, _p_wxWindowDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxDC, 0, 0, 0}, {&_swigt__p_wxMetaFileDC, _p_wxMetaFileDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxClientDC, _p_wxClientDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxPaintDC, _p_wxPaintDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxPostScriptDC, _p_wxPostScriptDCTo_p_wxDC, 0, 0}, {&_swigt__p_wxPrinterDC, _p_wxPrinterDCTo_p_wxDC, 0, 0},{0, 0, 0, 0}};
32211 static swig_cast_info _swigc__p_wxDash[] = { {&_swigt__p_wxDash, 0, 0, 0},{0, 0, 0, 0}};
32212 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
32213 static swig_cast_info _swigc__p_wxEffects[] = { {&_swigt__p_wxEffects, 0, 0, 0},{0, 0, 0, 0}};
32214 static swig_cast_info _swigc__p_wxEncodingConverter[] = { {&_swigt__p_wxEncodingConverter, 0, 0, 0},{0, 0, 0, 0}};
32215 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
32216 static swig_cast_info _swigc__p_wxFontList[] = { {&_swigt__p_wxFontList, 0, 0, 0},{0, 0, 0, 0}};
32217 static swig_cast_info _swigc__p_wxFontMapper[] = { {&_swigt__p_wxFontMapper, 0, 0, 0},{0, 0, 0, 0}};
32218 static swig_cast_info _swigc__p_wxGDIObjListBase[] = { {&_swigt__p_wxGDIObjListBase, 0, 0, 0}, {&_swigt__p_wxBrushList, _p_wxBrushListTo_p_wxGDIObjListBase, 0, 0}, {&_swigt__p_wxFontList, _p_wxFontListTo_p_wxGDIObjListBase, 0, 0}, {&_swigt__p_wxPenList, _p_wxPenListTo_p_wxGDIObjListBase, 0, 0},{0, 0, 0, 0}};
32219 static swig_cast_info _swigc__p_wxGDIObject[] = { {&_swigt__p_wxIcon, _p_wxIconTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxPen, _p_wxPenTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxFont, _p_wxFontTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxPalette, _p_wxPaletteTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxGDIObject, 0, 0, 0}, {&_swigt__p_wxCursor, _p_wxCursorTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxBitmap, _p_wxBitmapTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxRegion, _p_wxRegionTo_p_wxGDIObject, 0, 0}, {&_swigt__p_wxBrush, _p_wxBrushTo_p_wxGDIObject, 0, 0},{0, 0, 0, 0}};
32220 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
32221 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
32222 static swig_cast_info _swigc__p_wxIconLocation[] = { {&_swigt__p_wxIconLocation, 0, 0, 0},{0, 0, 0, 0}};
32223 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
32224 static swig_cast_info _swigc__p_wxImageList[] = { {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
32225 static swig_cast_info _swigc__p_wxLanguageInfo[] = { {&_swigt__p_wxLanguageInfo, 0, 0, 0},{0, 0, 0, 0}};
32226 static swig_cast_info _swigc__p_wxLocale[] = { {&_swigt__p_wxPyLocale, _p_wxPyLocaleTo_p_wxLocale, 0, 0}, {&_swigt__p_wxLocale, 0, 0, 0},{0, 0, 0, 0}};
32227 static swig_cast_info _swigc__p_wxMask[] = { {&_swigt__p_wxMask, 0, 0, 0},{0, 0, 0, 0}};
32228 static swig_cast_info _swigc__p_wxMemoryDC[] = { {&_swigt__p_wxBufferedDC, _p_wxBufferedDCTo_p_wxMemoryDC, 0, 0}, {&_swigt__p_wxMemoryDC, 0, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxMemoryDC, 0, 0},{0, 0, 0, 0}};
32229 static swig_cast_info _swigc__p_wxMetaFile[] = { {&_swigt__p_wxMetaFile, 0, 0, 0},{0, 0, 0, 0}};
32230 static swig_cast_info _swigc__p_wxMetaFileDC[] = { {&_swigt__p_wxMetaFileDC, 0, 0, 0},{0, 0, 0, 0}};
32231 static swig_cast_info _swigc__p_wxMirrorDC[] = { {&_swigt__p_wxMirrorDC, 0, 0, 0},{0, 0, 0, 0}};
32232 static swig_cast_info _swigc__p_wxNativeEncodingInfo[] = { {&_swigt__p_wxNativeEncodingInfo, 0, 0, 0},{0, 0, 0, 0}};
32233 static swig_cast_info _swigc__p_wxNativeFontInfo[] = { {&_swigt__p_wxNativeFontInfo, 0, 0, 0},{0, 0, 0, 0}};
32234 static swig_cast_info _swigc__p_wxNativePixelData[] = { {&_swigt__p_wxNativePixelData, 0, 0, 0},{0, 0, 0, 0}};
32235 static swig_cast_info _swigc__p_wxNativePixelData_Accessor[] = { {&_swigt__p_wxNativePixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
32236 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
32237 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32238 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32239 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
32240 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
32241 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
32242 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
32243 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
32244 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
32245 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
32246 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
32247 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
32248 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
32249 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
32250 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
32251 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
32252 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
32253 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
32254 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32255 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32256 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32257 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32258 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
32259 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
32260 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
32261 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
32262 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
32263 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
32264 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
32265 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
32266 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
32267 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
32268 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
32269 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
32270 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32271 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32272 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32273 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
32274 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
32275 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
32276 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
32277 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
32278 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
32279 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
32280 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
32281 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
32282 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
32283 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
32284 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
32285 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
32286 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
32287 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
32288 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
32289 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
32290 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
32291 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
32292 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
32293 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
32294 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
32295 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
32296 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
32297 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
32298 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
32299 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
32300 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
32301 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
32302 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
32303 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
32304 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
32305 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
32306 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
32307 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
32308 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
32309 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
32310 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
32311 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
32312 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxRegionIterator, _p_wxRegionIteratorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPen, _p_wxPenTo_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_wxMask, _p_wxMaskTo_p_wxObject, 0, 0}, {&_swigt__p_wxPseudoDC, _p_wxPseudoDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxFont, _p_wxFontTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClientDC, _p_wxClientDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxMemoryDC, _p_wxMemoryDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxRegion, _p_wxRegionTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxDC, _p_wxDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxIcon, _p_wxIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDC, _p_wxWindowDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxGDIObject, _p_wxGDIObjectTo_p_wxObject, 0, 0}, {&_swigt__p_wxEffects, _p_wxEffectsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPostScriptDC, _p_wxPostScriptDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintDC, _p_wxPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinterDC, _p_wxPrinterDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxScreenDC, _p_wxScreenDCTo_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_wxBufferedDC, _p_wxBufferedDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPalette, _p_wxPaletteTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageList, _p_wxImageListTo_p_wxObject, 0, 0}, {&_swigt__p_wxCursor, _p_wxCursorTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxMirrorDC, _p_wxMirrorDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxEncodingConverter, _p_wxEncodingConverterTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFileDC, _p_wxMetaFileDCTo_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_wxBitmap, _p_wxBitmapTo_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_wxBrush, _p_wxBrushTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFile, _p_wxMetaFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxColour, _p_wxColourTo_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}};
32313 static swig_cast_info _swigc__p_wxPaintDC[] = { {&_swigt__p_wxPaintDC, 0, 0, 0},{0, 0, 0, 0}};
32314 static swig_cast_info _swigc__p_wxPalette[] = { {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
32315 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
32316 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
32317 static swig_cast_info _swigc__p_wxPenList[] = { {&_swigt__p_wxPenList, 0, 0, 0},{0, 0, 0, 0}};
32318 static swig_cast_info _swigc__p_wxPixelDataBase[] = { {&_swigt__p_wxPixelDataBase, 0, 0, 0}, {&_swigt__p_wxNativePixelData, _p_wxNativePixelDataTo_p_wxPixelDataBase, 0, 0}, {&_swigt__p_wxAlphaPixelData, _p_wxAlphaPixelDataTo_p_wxPixelDataBase, 0, 0},{0, 0, 0, 0}};
32319 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
32320 static swig_cast_info _swigc__p_wxPostScriptDC[] = { {&_swigt__p_wxPostScriptDC, 0, 0, 0},{0, 0, 0, 0}};
32321 static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
32322 static swig_cast_info _swigc__p_wxPrinterDC[] = { {&_swigt__p_wxPrinterDC, 0, 0, 0},{0, 0, 0, 0}};
32323 static swig_cast_info _swigc__p_wxPseudoDC[] = { {&_swigt__p_wxPseudoDC, 0, 0, 0},{0, 0, 0, 0}};
32324 static swig_cast_info _swigc__p_wxPyFontEnumerator[] = { {&_swigt__p_wxPyFontEnumerator, 0, 0, 0},{0, 0, 0, 0}};
32325 static swig_cast_info _swigc__p_wxPyLocale[] = { {&_swigt__p_wxPyLocale, 0, 0, 0},{0, 0, 0, 0}};
32326 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
32327 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
32328 static swig_cast_info _swigc__p_wxRegionIterator[] = { {&_swigt__p_wxRegionIterator, 0, 0, 0},{0, 0, 0, 0}};
32329 static swig_cast_info _swigc__p_wxRendererNative[] = { {&_swigt__p_wxRendererNative, 0, 0, 0},{0, 0, 0, 0}};
32330 static swig_cast_info _swigc__p_wxRendererVersion[] = { {&_swigt__p_wxRendererVersion, 0, 0, 0},{0, 0, 0, 0}};
32331 static swig_cast_info _swigc__p_wxScreenDC[] = { {&_swigt__p_wxScreenDC, 0, 0, 0},{0, 0, 0, 0}};
32332 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
32333 static swig_cast_info _swigc__p_wxSplitterRenderParams[] = { {&_swigt__p_wxSplitterRenderParams, 0, 0, 0},{0, 0, 0, 0}};
32334 static swig_cast_info _swigc__p_wxStockGDI[] = { {&_swigt__p_wxStockGDI, 0, 0, 0},{0, 0, 0, 0}};
32335 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
32336 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
32337 static swig_cast_info _swigc__p_wxWindowDC[] = { {&_swigt__p_wxWindowDC, 0, 0, 0},{0, 0, 0, 0}};
32338
32339 static swig_cast_info *swig_cast_initial[] = {
32340 _swigc__p_buffer,
32341 _swigc__p_char,
32342 _swigc__p_double,
32343 _swigc__p_form_ops_t,
32344 _swigc__p_int,
32345 _swigc__p_unsigned_char,
32346 _swigc__p_unsigned_int,
32347 _swigc__p_unsigned_long,
32348 _swigc__p_wxANIHandler,
32349 _swigc__p_wxAcceleratorTable,
32350 _swigc__p_wxActivateEvent,
32351 _swigc__p_wxAlphaPixelData,
32352 _swigc__p_wxAlphaPixelData_Accessor,
32353 _swigc__p_wxBMPHandler,
32354 _swigc__p_wxBitmap,
32355 _swigc__p_wxBoxSizer,
32356 _swigc__p_wxBrush,
32357 _swigc__p_wxBrushList,
32358 _swigc__p_wxBufferedDC,
32359 _swigc__p_wxBufferedPaintDC,
32360 _swigc__p_wxCURHandler,
32361 _swigc__p_wxChar,
32362 _swigc__p_wxChildFocusEvent,
32363 _swigc__p_wxClientDC,
32364 _swigc__p_wxClipboardTextEvent,
32365 _swigc__p_wxCloseEvent,
32366 _swigc__p_wxColour,
32367 _swigc__p_wxColourDatabase,
32368 _swigc__p_wxCommandEvent,
32369 _swigc__p_wxContextMenuEvent,
32370 _swigc__p_wxControl,
32371 _swigc__p_wxControlWithItems,
32372 _swigc__p_wxCursor,
32373 _swigc__p_wxDC,
32374 _swigc__p_wxDash,
32375 _swigc__p_wxDateEvent,
32376 _swigc__p_wxDisplayChangedEvent,
32377 _swigc__p_wxDropFilesEvent,
32378 _swigc__p_wxDuplexMode,
32379 _swigc__p_wxEffects,
32380 _swigc__p_wxEncodingConverter,
32381 _swigc__p_wxEraseEvent,
32382 _swigc__p_wxEvent,
32383 _swigc__p_wxEvtHandler,
32384 _swigc__p_wxFSFile,
32385 _swigc__p_wxFileSystem,
32386 _swigc__p_wxFlexGridSizer,
32387 _swigc__p_wxFocusEvent,
32388 _swigc__p_wxFont,
32389 _swigc__p_wxFontList,
32390 _swigc__p_wxFontMapper,
32391 _swigc__p_wxGBSizerItem,
32392 _swigc__p_wxGDIObjListBase,
32393 _swigc__p_wxGDIObject,
32394 _swigc__p_wxGIFHandler,
32395 _swigc__p_wxGridBagSizer,
32396 _swigc__p_wxGridSizer,
32397 _swigc__p_wxICOHandler,
32398 _swigc__p_wxIcon,
32399 _swigc__p_wxIconBundle,
32400 _swigc__p_wxIconLocation,
32401 _swigc__p_wxIconizeEvent,
32402 _swigc__p_wxIdleEvent,
32403 _swigc__p_wxImage,
32404 _swigc__p_wxImageHandler,
32405 _swigc__p_wxImageList,
32406 _swigc__p_wxIndividualLayoutConstraint,
32407 _swigc__p_wxInitDialogEvent,
32408 _swigc__p_wxJPEGHandler,
32409 _swigc__p_wxKeyEvent,
32410 _swigc__p_wxLanguageInfo,
32411 _swigc__p_wxLayoutConstraints,
32412 _swigc__p_wxLocale,
32413 _swigc__p_wxMask,
32414 _swigc__p_wxMaximizeEvent,
32415 _swigc__p_wxMemoryDC,
32416 _swigc__p_wxMenu,
32417 _swigc__p_wxMenuBar,
32418 _swigc__p_wxMenuEvent,
32419 _swigc__p_wxMenuItem,
32420 _swigc__p_wxMetaFile,
32421 _swigc__p_wxMetaFileDC,
32422 _swigc__p_wxMirrorDC,
32423 _swigc__p_wxMouseCaptureChangedEvent,
32424 _swigc__p_wxMouseCaptureLostEvent,
32425 _swigc__p_wxMouseEvent,
32426 _swigc__p_wxMoveEvent,
32427 _swigc__p_wxNativeEncodingInfo,
32428 _swigc__p_wxNativeFontInfo,
32429 _swigc__p_wxNativePixelData,
32430 _swigc__p_wxNativePixelData_Accessor,
32431 _swigc__p_wxNavigationKeyEvent,
32432 _swigc__p_wxNcPaintEvent,
32433 _swigc__p_wxNotifyEvent,
32434 _swigc__p_wxObject,
32435 _swigc__p_wxPCXHandler,
32436 _swigc__p_wxPNGHandler,
32437 _swigc__p_wxPNMHandler,
32438 _swigc__p_wxPaintDC,
32439 _swigc__p_wxPaintEvent,
32440 _swigc__p_wxPalette,
32441 _swigc__p_wxPaletteChangedEvent,
32442 _swigc__p_wxPaperSize,
32443 _swigc__p_wxPen,
32444 _swigc__p_wxPenList,
32445 _swigc__p_wxPixelDataBase,
32446 _swigc__p_wxPoint,
32447 _swigc__p_wxPostScriptDC,
32448 _swigc__p_wxPrintData,
32449 _swigc__p_wxPrinterDC,
32450 _swigc__p_wxPseudoDC,
32451 _swigc__p_wxPyApp,
32452 _swigc__p_wxPyCommandEvent,
32453 _swigc__p_wxPyEvent,
32454 _swigc__p_wxPyFontEnumerator,
32455 _swigc__p_wxPyImageHandler,
32456 _swigc__p_wxPyLocale,
32457 _swigc__p_wxPySizer,
32458 _swigc__p_wxPyValidator,
32459 _swigc__p_wxQueryNewPaletteEvent,
32460 _swigc__p_wxRect,
32461 _swigc__p_wxRegion,
32462 _swigc__p_wxRegionIterator,
32463 _swigc__p_wxRendererNative,
32464 _swigc__p_wxRendererVersion,
32465 _swigc__p_wxScreenDC,
32466 _swigc__p_wxScrollEvent,
32467 _swigc__p_wxScrollWinEvent,
32468 _swigc__p_wxSetCursorEvent,
32469 _swigc__p_wxShowEvent,
32470 _swigc__p_wxSize,
32471 _swigc__p_wxSizeEvent,
32472 _swigc__p_wxSizer,
32473 _swigc__p_wxSizerItem,
32474 _swigc__p_wxSplitterRenderParams,
32475 _swigc__p_wxStaticBoxSizer,
32476 _swigc__p_wxStdDialogButtonSizer,
32477 _swigc__p_wxStockGDI,
32478 _swigc__p_wxString,
32479 _swigc__p_wxSysColourChangedEvent,
32480 _swigc__p_wxTIFFHandler,
32481 _swigc__p_wxUpdateUIEvent,
32482 _swigc__p_wxValidator,
32483 _swigc__p_wxWindow,
32484 _swigc__p_wxWindowCreateEvent,
32485 _swigc__p_wxWindowDC,
32486 _swigc__p_wxWindowDestroyEvent,
32487 _swigc__p_wxXPMHandler,
32488 };
32489
32490
32491 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32492
32493 static swig_const_info swig_const_table[] = {
32494 {0, 0, 0, 0.0, 0, 0}};
32495
32496 #ifdef __cplusplus
32497 }
32498 #endif
32499 /* -----------------------------------------------------------------------------
32500 * Type initialization:
32501 * This problem is tough by the requirement that no dynamic
32502 * memory is used. Also, since swig_type_info structures store pointers to
32503 * swig_cast_info structures and swig_cast_info structures store pointers back
32504 * to swig_type_info structures, we need some lookup code at initialization.
32505 * The idea is that swig generates all the structures that are needed.
32506 * The runtime then collects these partially filled structures.
32507 * The SWIG_InitializeModule function takes these initial arrays out of
32508 * swig_module, and does all the lookup, filling in the swig_module.types
32509 * array with the correct data and linking the correct swig_cast_info
32510 * structures together.
32511 *
32512 * The generated swig_type_info structures are assigned staticly to an initial
32513 * array. We just loop though that array, and handle each type individually.
32514 * First we lookup if this type has been already loaded, and if so, use the
32515 * loaded structure instead of the generated one. Then we have to fill in the
32516 * cast linked list. The cast data is initially stored in something like a
32517 * two-dimensional array. Each row corresponds to a type (there are the same
32518 * number of rows as there are in the swig_type_initial array). Each entry in
32519 * a column is one of the swig_cast_info structures for that type.
32520 * The cast_initial array is actually an array of arrays, because each row has
32521 * a variable number of columns. So to actually build the cast linked list,
32522 * we find the array of casts associated with the type, and loop through it
32523 * adding the casts to the list. The one last trick we need to do is making
32524 * sure the type pointer in the swig_cast_info struct is correct.
32525 *
32526 * First off, we lookup the cast->type name to see if it is already loaded.
32527 * There are three cases to handle:
32528 * 1) If the cast->type has already been loaded AND the type we are adding
32529 * casting info to has not been loaded (it is in this module), THEN we
32530 * replace the cast->type pointer with the type pointer that has already
32531 * been loaded.
32532 * 2) If BOTH types (the one we are adding casting info to, and the
32533 * cast->type) are loaded, THEN the cast info has already been loaded by
32534 * the previous module so we just ignore it.
32535 * 3) Finally, if cast->type has not already been loaded, then we add that
32536 * swig_cast_info to the linked list (because the cast->type) pointer will
32537 * be correct.
32538 * ----------------------------------------------------------------------------- */
32539
32540 #ifdef __cplusplus
32541 extern "C" {
32542 #if 0
32543 } /* c-mode */
32544 #endif
32545 #endif
32546
32547 #if 0
32548 #define SWIGRUNTIME_DEBUG
32549 #endif
32550
32551 SWIGRUNTIME void
32552 SWIG_InitializeModule(void *clientdata) {
32553 size_t i;
32554 swig_module_info *module_head;
32555 static int init_run = 0;
32556
32557 clientdata = clientdata;
32558
32559 if (init_run) return;
32560 init_run = 1;
32561
32562 /* Initialize the swig_module */
32563 swig_module.type_initial = swig_type_initial;
32564 swig_module.cast_initial = swig_cast_initial;
32565
32566 /* Try and load any already created modules */
32567 module_head = SWIG_GetModule(clientdata);
32568 if (module_head) {
32569 swig_module.next = module_head->next;
32570 module_head->next = &swig_module;
32571 } else {
32572 /* This is the first module loaded */
32573 swig_module.next = &swig_module;
32574 SWIG_SetModule(clientdata, &swig_module);
32575 }
32576
32577 /* Now work on filling in swig_module.types */
32578 #ifdef SWIGRUNTIME_DEBUG
32579 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32580 #endif
32581 for (i = 0; i < swig_module.size; ++i) {
32582 swig_type_info *type = 0;
32583 swig_type_info *ret;
32584 swig_cast_info *cast;
32585
32586 #ifdef SWIGRUNTIME_DEBUG
32587 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32588 #endif
32589
32590 /* if there is another module already loaded */
32591 if (swig_module.next != &swig_module) {
32592 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
32593 }
32594 if (type) {
32595 /* Overwrite clientdata field */
32596 #ifdef SWIGRUNTIME_DEBUG
32597 printf("SWIG_InitializeModule: found type %s\n", type->name);
32598 #endif
32599 if (swig_module.type_initial[i]->clientdata) {
32600 type->clientdata = swig_module.type_initial[i]->clientdata;
32601 #ifdef SWIGRUNTIME_DEBUG
32602 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32603 #endif
32604 }
32605 } else {
32606 type = swig_module.type_initial[i];
32607 }
32608
32609 /* Insert casting types */
32610 cast = swig_module.cast_initial[i];
32611 while (cast->type) {
32612 /* Don't need to add information already in the list */
32613 ret = 0;
32614 #ifdef SWIGRUNTIME_DEBUG
32615 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32616 #endif
32617 if (swig_module.next != &swig_module) {
32618 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32619 #ifdef SWIGRUNTIME_DEBUG
32620 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32621 #endif
32622 }
32623 if (ret) {
32624 if (type == swig_module.type_initial[i]) {
32625 #ifdef SWIGRUNTIME_DEBUG
32626 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32627 #endif
32628 cast->type = ret;
32629 ret = 0;
32630 } else {
32631 /* Check for casting already in the list */
32632 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32633 #ifdef SWIGRUNTIME_DEBUG
32634 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32635 #endif
32636 if (!ocast) ret = 0;
32637 }
32638 }
32639
32640 if (!ret) {
32641 #ifdef SWIGRUNTIME_DEBUG
32642 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32643 #endif
32644 if (type->cast) {
32645 type->cast->prev = cast;
32646 cast->next = type->cast;
32647 }
32648 type->cast = cast;
32649 }
32650 cast++;
32651 }
32652 /* Set entry in modules->types array equal to the type */
32653 swig_module.types[i] = type;
32654 }
32655 swig_module.types[i] = 0;
32656
32657 #ifdef SWIGRUNTIME_DEBUG
32658 printf("**** SWIG_InitializeModule: Cast List ******\n");
32659 for (i = 0; i < swig_module.size; ++i) {
32660 int j = 0;
32661 swig_cast_info *cast = swig_module.cast_initial[i];
32662 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32663 while (cast->type) {
32664 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
32665 cast++;
32666 ++j;
32667 }
32668 printf("---- Total casts: %d\n",j);
32669 }
32670 printf("**** SWIG_InitializeModule: Cast List ******\n");
32671 #endif
32672 }
32673
32674 /* This function will propagate the clientdata field of type to
32675 * any new swig_type_info structures that have been added into the list
32676 * of equivalent types. It is like calling
32677 * SWIG_TypeClientData(type, clientdata) a second time.
32678 */
32679 SWIGRUNTIME void
32680 SWIG_PropagateClientData(void) {
32681 size_t i;
32682 swig_cast_info *equiv;
32683 static int init_run = 0;
32684
32685 if (init_run) return;
32686 init_run = 1;
32687
32688 for (i = 0; i < swig_module.size; i++) {
32689 if (swig_module.types[i]->clientdata) {
32690 equiv = swig_module.types[i]->cast;
32691 while (equiv) {
32692 if (!equiv->converter) {
32693 if (equiv->type && !equiv->type->clientdata)
32694 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32695 }
32696 equiv = equiv->next;
32697 }
32698 }
32699 }
32700 }
32701
32702 #ifdef __cplusplus
32703 #if 0
32704 {
32705 /* c-mode */
32706 #endif
32707 }
32708 #endif
32709
32710
32711
32712 #ifdef __cplusplus
32713 extern "C" {
32714 #endif
32715
32716 /* Python-specific SWIG API */
32717 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32718 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32719 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32720
32721 /* -----------------------------------------------------------------------------
32722 * global variable support code.
32723 * ----------------------------------------------------------------------------- */
32724
32725 typedef struct swig_globalvar {
32726 char *name; /* Name of global variable */
32727 PyObject *(*get_attr)(void); /* Return the current value */
32728 int (*set_attr)(PyObject *); /* Set the value */
32729 struct swig_globalvar *next;
32730 } swig_globalvar;
32731
32732 typedef struct swig_varlinkobject {
32733 PyObject_HEAD
32734 swig_globalvar *vars;
32735 } swig_varlinkobject;
32736
32737 SWIGINTERN PyObject *
32738 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
32739 return PyString_FromString("<Swig global variables>");
32740 }
32741
32742 SWIGINTERN PyObject *
32743 swig_varlink_str(swig_varlinkobject *v) {
32744 PyObject *str = PyString_FromString("(");
32745 swig_globalvar *var;
32746 for (var = v->vars; var; var=var->next) {
32747 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
32748 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
32749 }
32750 PyString_ConcatAndDel(&str,PyString_FromString(")"));
32751 return str;
32752 }
32753
32754 SWIGINTERN int
32755 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
32756 PyObject *str = swig_varlink_str(v);
32757 fprintf(fp,"Swig global variables ");
32758 fprintf(fp,"%s\n", PyString_AsString(str));
32759 Py_DECREF(str);
32760 return 0;
32761 }
32762
32763 SWIGINTERN void
32764 swig_varlink_dealloc(swig_varlinkobject *v) {
32765 swig_globalvar *var = v->vars;
32766 while (var) {
32767 swig_globalvar *n = var->next;
32768 free(var->name);
32769 free(var);
32770 var = n;
32771 }
32772 }
32773
32774 SWIGINTERN PyObject *
32775 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32776 PyObject *res = NULL;
32777 swig_globalvar *var = v->vars;
32778 while (var) {
32779 if (strcmp(var->name,n) == 0) {
32780 res = (*var->get_attr)();
32781 break;
32782 }
32783 var = var->next;
32784 }
32785 if (res == NULL && !PyErr_Occurred()) {
32786 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32787 }
32788 return res;
32789 }
32790
32791 SWIGINTERN int
32792 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32793 int res = 1;
32794 swig_globalvar *var = v->vars;
32795 while (var) {
32796 if (strcmp(var->name,n) == 0) {
32797 res = (*var->set_attr)(p);
32798 break;
32799 }
32800 var = var->next;
32801 }
32802 if (res == 1 && !PyErr_Occurred()) {
32803 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32804 }
32805 return res;
32806 }
32807
32808 SWIGINTERN PyTypeObject*
32809 swig_varlink_type(void) {
32810 static char varlink__doc__[] = "Swig var link object";
32811 static PyTypeObject varlink_type;
32812 static int type_init = 0;
32813 if (!type_init) {
32814 const PyTypeObject tmp
32815 = {
32816 PyObject_HEAD_INIT(NULL)
32817 0, /* Number of items in variable part (ob_size) */
32818 (char *)"swigvarlink", /* Type name (tp_name) */
32819 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32820 0, /* Itemsize (tp_itemsize) */
32821 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
32822 (printfunc) swig_varlink_print, /* Print (tp_print) */
32823 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32824 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32825 0, /* tp_compare */
32826 (reprfunc) swig_varlink_repr, /* tp_repr */
32827 0, /* tp_as_number */
32828 0, /* tp_as_sequence */
32829 0, /* tp_as_mapping */
32830 0, /* tp_hash */
32831 0, /* tp_call */
32832 (reprfunc)swig_varlink_str, /* tp_str */
32833 0, /* tp_getattro */
32834 0, /* tp_setattro */
32835 0, /* tp_as_buffer */
32836 0, /* tp_flags */
32837 varlink__doc__, /* tp_doc */
32838 0, /* tp_traverse */
32839 0, /* tp_clear */
32840 0, /* tp_richcompare */
32841 0, /* tp_weaklistoffset */
32842 #if PY_VERSION_HEX >= 0x02020000
32843 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32844 #endif
32845 #if PY_VERSION_HEX >= 0x02030000
32846 0, /* tp_del */
32847 #endif
32848 #ifdef COUNT_ALLOCS
32849 0,0,0,0 /* tp_alloc -> tp_next */
32850 #endif
32851 };
32852 varlink_type = tmp;
32853 varlink_type.ob_type = &PyType_Type;
32854 type_init = 1;
32855 }
32856 return &varlink_type;
32857 }
32858
32859 /* Create a variable linking object for use later */
32860 SWIGINTERN PyObject *
32861 SWIG_Python_newvarlink(void) {
32862 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
32863 if (result) {
32864 result->vars = 0;
32865 }
32866 return ((PyObject*) result);
32867 }
32868
32869 SWIGINTERN void
32870 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32871 swig_varlinkobject *v = (swig_varlinkobject *) p;
32872 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32873 if (gv) {
32874 size_t size = strlen(name)+1;
32875 gv->name = (char *)malloc(size);
32876 if (gv->name) {
32877 strncpy(gv->name,name,size);
32878 gv->get_attr = get_attr;
32879 gv->set_attr = set_attr;
32880 gv->next = v->vars;
32881 }
32882 }
32883 v->vars = gv;
32884 }
32885
32886 SWIGINTERN PyObject *
32887 SWIG_globals() {
32888 static PyObject *_SWIG_globals = 0;
32889 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
32890 return _SWIG_globals;
32891 }
32892
32893 /* -----------------------------------------------------------------------------
32894 * constants/methods manipulation
32895 * ----------------------------------------------------------------------------- */
32896
32897 /* Install Constants */
32898 SWIGINTERN void
32899 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32900 PyObject *obj = 0;
32901 size_t i;
32902 for (i = 0; constants[i].type; ++i) {
32903 switch(constants[i].type) {
32904 case SWIG_PY_POINTER:
32905 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32906 break;
32907 case SWIG_PY_BINARY:
32908 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32909 break;
32910 default:
32911 obj = 0;
32912 break;
32913 }
32914 if (obj) {
32915 PyDict_SetItemString(d, constants[i].name, obj);
32916 Py_DECREF(obj);
32917 }
32918 }
32919 }
32920
32921 /* -----------------------------------------------------------------------------*/
32922 /* Fix SwigMethods to carry the callback ptrs when needed */
32923 /* -----------------------------------------------------------------------------*/
32924
32925 SWIGINTERN void
32926 SWIG_Python_FixMethods(PyMethodDef *methods,
32927 swig_const_info *const_table,
32928 swig_type_info **types,
32929 swig_type_info **types_initial) {
32930 size_t i;
32931 for (i = 0; methods[i].ml_name; ++i) {
32932 const char *c = methods[i].ml_doc;
32933 if (c && (c = strstr(c, "swig_ptr: "))) {
32934 int j;
32935 swig_const_info *ci = 0;
32936 const char *name = c + 10;
32937 for (j = 0; const_table[j].type; ++j) {
32938 if (strncmp(const_table[j].name, name,
32939 strlen(const_table[j].name)) == 0) {
32940 ci = &(const_table[j]);
32941 break;
32942 }
32943 }
32944 if (ci) {
32945 size_t shift = (ci->ptype) - types;
32946 swig_type_info *ty = types_initial[shift];
32947 size_t ldoc = (c - methods[i].ml_doc);
32948 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32949 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32950 if (ndoc) {
32951 char *buff = ndoc;
32952 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
32953 if (ptr) {
32954 strncpy(buff, methods[i].ml_doc, ldoc);
32955 buff += ldoc;
32956 strncpy(buff, "swig_ptr: ", 10);
32957 buff += 10;
32958 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32959 methods[i].ml_doc = ndoc;
32960 }
32961 }
32962 }
32963 }
32964 }
32965 }
32966
32967 #ifdef __cplusplus
32968 }
32969 #endif
32970
32971 /* -----------------------------------------------------------------------------*
32972 * Partial Init method
32973 * -----------------------------------------------------------------------------*/
32974
32975 #ifdef __cplusplus
32976 extern "C"
32977 #endif
32978 SWIGEXPORT void SWIG_init(void) {
32979 PyObject *m, *d;
32980
32981 /* Fix SwigMethods to carry the callback ptrs when needed */
32982 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
32983
32984 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32985 d = PyModule_GetDict(m);
32986
32987 SWIG_InitializeModule(0);
32988 SWIG_InstallConstants(d,swig_const_table);
32989
32990
32991 SWIG_Python_SetConstant(d, "C2S_NAME",SWIG_From_int(static_cast< int >(wxC2S_NAME)));
32992 SWIG_Python_SetConstant(d, "C2S_CSS_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_CSS_SYNTAX)));
32993 SWIG_Python_SetConstant(d, "C2S_HTML_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_HTML_SYNTAX)));
32994 SWIG_Python_SetConstant(d, "ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxALPHA_TRANSPARENT)));
32995 SWIG_Python_SetConstant(d, "ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxALPHA_OPAQUE)));
32996 SWIG_Python_SetConstant(d, "OutRegion",SWIG_From_int(static_cast< int >(wxOutRegion)));
32997 SWIG_Python_SetConstant(d, "PartRegion",SWIG_From_int(static_cast< int >(wxPartRegion)));
32998 SWIG_Python_SetConstant(d, "InRegion",SWIG_From_int(static_cast< int >(wxInRegion)));
32999 SWIG_Python_SetConstant(d, "FONTFAMILY_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DEFAULT)));
33000 SWIG_Python_SetConstant(d, "FONTFAMILY_DECORATIVE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DECORATIVE)));
33001 SWIG_Python_SetConstant(d, "FONTFAMILY_ROMAN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_ROMAN)));
33002 SWIG_Python_SetConstant(d, "FONTFAMILY_SCRIPT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SCRIPT)));
33003 SWIG_Python_SetConstant(d, "FONTFAMILY_SWISS",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SWISS)));
33004 SWIG_Python_SetConstant(d, "FONTFAMILY_MODERN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MODERN)));
33005 SWIG_Python_SetConstant(d, "FONTFAMILY_TELETYPE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_TELETYPE)));
33006 SWIG_Python_SetConstant(d, "FONTFAMILY_MAX",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MAX)));
33007 SWIG_Python_SetConstant(d, "FONTFAMILY_UNKNOWN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_UNKNOWN)));
33008 SWIG_Python_SetConstant(d, "FONTSTYLE_NORMAL",SWIG_From_int(static_cast< int >(wxFONTSTYLE_NORMAL)));
33009 SWIG_Python_SetConstant(d, "FONTSTYLE_ITALIC",SWIG_From_int(static_cast< int >(wxFONTSTYLE_ITALIC)));
33010 SWIG_Python_SetConstant(d, "FONTSTYLE_SLANT",SWIG_From_int(static_cast< int >(wxFONTSTYLE_SLANT)));
33011 SWIG_Python_SetConstant(d, "FONTSTYLE_MAX",SWIG_From_int(static_cast< int >(wxFONTSTYLE_MAX)));
33012 SWIG_Python_SetConstant(d, "FONTWEIGHT_NORMAL",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_NORMAL)));
33013 SWIG_Python_SetConstant(d, "FONTWEIGHT_LIGHT",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_LIGHT)));
33014 SWIG_Python_SetConstant(d, "FONTWEIGHT_BOLD",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_BOLD)));
33015 SWIG_Python_SetConstant(d, "FONTWEIGHT_MAX",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_MAX)));
33016 SWIG_Python_SetConstant(d, "FONTFLAG_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFLAG_DEFAULT)));
33017 SWIG_Python_SetConstant(d, "FONTFLAG_ITALIC",SWIG_From_int(static_cast< int >(wxFONTFLAG_ITALIC)));
33018 SWIG_Python_SetConstant(d, "FONTFLAG_SLANT",SWIG_From_int(static_cast< int >(wxFONTFLAG_SLANT)));
33019 SWIG_Python_SetConstant(d, "FONTFLAG_LIGHT",SWIG_From_int(static_cast< int >(wxFONTFLAG_LIGHT)));
33020 SWIG_Python_SetConstant(d, "FONTFLAG_BOLD",SWIG_From_int(static_cast< int >(wxFONTFLAG_BOLD)));
33021 SWIG_Python_SetConstant(d, "FONTFLAG_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_ANTIALIASED)));
33022 SWIG_Python_SetConstant(d, "FONTFLAG_NOT_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_NOT_ANTIALIASED)));
33023 SWIG_Python_SetConstant(d, "FONTFLAG_UNDERLINED",SWIG_From_int(static_cast< int >(wxFONTFLAG_UNDERLINED)));
33024 SWIG_Python_SetConstant(d, "FONTFLAG_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxFONTFLAG_STRIKETHROUGH)));
33025 SWIG_Python_SetConstant(d, "FONTFLAG_MASK",SWIG_From_int(static_cast< int >(wxFONTFLAG_MASK)));
33026 SWIG_Python_SetConstant(d, "FONTENCODING_SYSTEM",SWIG_From_int(static_cast< int >(wxFONTENCODING_SYSTEM)));
33027 SWIG_Python_SetConstant(d, "FONTENCODING_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTENCODING_DEFAULT)));
33028 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_1",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_1)));
33029 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_2",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_2)));
33030 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_3",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_3)));
33031 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_4",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_4)));
33032 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_5",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_5)));
33033 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_6",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_6)));
33034 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_7",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_7)));
33035 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_8",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_8)));
33036 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_9",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_9)));
33037 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_10",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_10)));
33038 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_11",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_11)));
33039 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_12",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_12)));
33040 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_13",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_13)));
33041 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_14",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_14)));
33042 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_15",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_15)));
33043 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_MAX)));
33044 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8)));
33045 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8_U",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8_U)));
33046 SWIG_Python_SetConstant(d, "FONTENCODING_ALTERNATIVE",SWIG_From_int(static_cast< int >(wxFONTENCODING_ALTERNATIVE)));
33047 SWIG_Python_SetConstant(d, "FONTENCODING_BULGARIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_BULGARIAN)));
33048 SWIG_Python_SetConstant(d, "FONTENCODING_CP437",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP437)));
33049 SWIG_Python_SetConstant(d, "FONTENCODING_CP850",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP850)));
33050 SWIG_Python_SetConstant(d, "FONTENCODING_CP852",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP852)));
33051 SWIG_Python_SetConstant(d, "FONTENCODING_CP855",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP855)));
33052 SWIG_Python_SetConstant(d, "FONTENCODING_CP866",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP866)));
33053 SWIG_Python_SetConstant(d, "FONTENCODING_CP874",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP874)));
33054 SWIG_Python_SetConstant(d, "FONTENCODING_CP932",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP932)));
33055 SWIG_Python_SetConstant(d, "FONTENCODING_CP936",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP936)));
33056 SWIG_Python_SetConstant(d, "FONTENCODING_CP949",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP949)));
33057 SWIG_Python_SetConstant(d, "FONTENCODING_CP950",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP950)));
33058 SWIG_Python_SetConstant(d, "FONTENCODING_CP1250",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1250)));
33059 SWIG_Python_SetConstant(d, "FONTENCODING_CP1251",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1251)));
33060 SWIG_Python_SetConstant(d, "FONTENCODING_CP1252",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1252)));
33061 SWIG_Python_SetConstant(d, "FONTENCODING_CP1253",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1253)));
33062 SWIG_Python_SetConstant(d, "FONTENCODING_CP1254",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1254)));
33063 SWIG_Python_SetConstant(d, "FONTENCODING_CP1255",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1255)));
33064 SWIG_Python_SetConstant(d, "FONTENCODING_CP1256",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1256)));
33065 SWIG_Python_SetConstant(d, "FONTENCODING_CP1257",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1257)));
33066 SWIG_Python_SetConstant(d, "FONTENCODING_CP12_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP12_MAX)));
33067 SWIG_Python_SetConstant(d, "FONTENCODING_UTF7",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF7)));
33068 SWIG_Python_SetConstant(d, "FONTENCODING_UTF8",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF8)));
33069 SWIG_Python_SetConstant(d, "FONTENCODING_EUC_JP",SWIG_From_int(static_cast< int >(wxFONTENCODING_EUC_JP)));
33070 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16BE)));
33071 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16LE)));
33072 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32BE)));
33073 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32LE)));
33074 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMAN)));
33075 SWIG_Python_SetConstant(d, "FONTENCODING_MACJAPANESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACJAPANESE)));
33076 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESETRAD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESETRAD)));
33077 SWIG_Python_SetConstant(d, "FONTENCODING_MACKOREAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKOREAN)));
33078 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABIC)));
33079 SWIG_Python_SetConstant(d, "FONTENCODING_MACHEBREW",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACHEBREW)));
33080 SWIG_Python_SetConstant(d, "FONTENCODING_MACGREEK",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGREEK)));
33081 SWIG_Python_SetConstant(d, "FONTENCODING_MACCYRILLIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCYRILLIC)));
33082 SWIG_Python_SetConstant(d, "FONTENCODING_MACDEVANAGARI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDEVANAGARI)));
33083 SWIG_Python_SetConstant(d, "FONTENCODING_MACGURMUKHI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGURMUKHI)));
33084 SWIG_Python_SetConstant(d, "FONTENCODING_MACGUJARATI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGUJARATI)));
33085 SWIG_Python_SetConstant(d, "FONTENCODING_MACORIYA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACORIYA)));
33086 SWIG_Python_SetConstant(d, "FONTENCODING_MACBENGALI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBENGALI)));
33087 SWIG_Python_SetConstant(d, "FONTENCODING_MACTAMIL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTAMIL)));
33088 SWIG_Python_SetConstant(d, "FONTENCODING_MACTELUGU",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTELUGU)));
33089 SWIG_Python_SetConstant(d, "FONTENCODING_MACKANNADA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKANNADA)));
33090 SWIG_Python_SetConstant(d, "FONTENCODING_MACMALAJALAM",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMALAJALAM)));
33091 SWIG_Python_SetConstant(d, "FONTENCODING_MACSINHALESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSINHALESE)));
33092 SWIG_Python_SetConstant(d, "FONTENCODING_MACBURMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBURMESE)));
33093 SWIG_Python_SetConstant(d, "FONTENCODING_MACKHMER",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKHMER)));
33094 SWIG_Python_SetConstant(d, "FONTENCODING_MACTHAI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTHAI)));
33095 SWIG_Python_SetConstant(d, "FONTENCODING_MACLAOTIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACLAOTIAN)));
33096 SWIG_Python_SetConstant(d, "FONTENCODING_MACGEORGIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGEORGIAN)));
33097 SWIG_Python_SetConstant(d, "FONTENCODING_MACARMENIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARMENIAN)));
33098 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESESIMP",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESESIMP)));
33099 SWIG_Python_SetConstant(d, "FONTENCODING_MACTIBETAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTIBETAN)));
33100 SWIG_Python_SetConstant(d, "FONTENCODING_MACMONGOLIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMONGOLIAN)));
33101 SWIG_Python_SetConstant(d, "FONTENCODING_MACETHIOPIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACETHIOPIC)));
33102 SWIG_Python_SetConstant(d, "FONTENCODING_MACCENTRALEUR",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCENTRALEUR)));
33103 SWIG_Python_SetConstant(d, "FONTENCODING_MACVIATNAMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACVIATNAMESE)));
33104 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABICEXT",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABICEXT)));
33105 SWIG_Python_SetConstant(d, "FONTENCODING_MACSYMBOL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSYMBOL)));
33106 SWIG_Python_SetConstant(d, "FONTENCODING_MACDINGBATS",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDINGBATS)));
33107 SWIG_Python_SetConstant(d, "FONTENCODING_MACTURKISH",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTURKISH)));
33108 SWIG_Python_SetConstant(d, "FONTENCODING_MACCROATIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCROATIAN)));
33109 SWIG_Python_SetConstant(d, "FONTENCODING_MACICELANDIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACICELANDIC)));
33110 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMANIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMANIAN)));
33111 SWIG_Python_SetConstant(d, "FONTENCODING_MACCELTIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCELTIC)));
33112 SWIG_Python_SetConstant(d, "FONTENCODING_MACGAELIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGAELIC)));
33113 SWIG_Python_SetConstant(d, "FONTENCODING_MACKEYBOARD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKEYBOARD)));
33114 SWIG_Python_SetConstant(d, "FONTENCODING_MACMIN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMIN)));
33115 SWIG_Python_SetConstant(d, "FONTENCODING_MACMAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMAX)));
33116 SWIG_Python_SetConstant(d, "FONTENCODING_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MAX)));
33117 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16)));
33118 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32)));
33119 SWIG_Python_SetConstant(d, "FONTENCODING_UNICODE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UNICODE)));
33120 SWIG_Python_SetConstant(d, "FONTENCODING_GB2312",SWIG_From_int(static_cast< int >(wxFONTENCODING_GB2312)));
33121 SWIG_Python_SetConstant(d, "FONTENCODING_BIG5",SWIG_From_int(static_cast< int >(wxFONTENCODING_BIG5)));
33122 SWIG_Python_SetConstant(d, "FONTENCODING_SHIFT_JIS",SWIG_From_int(static_cast< int >(wxFONTENCODING_SHIFT_JIS)));
33123
33124 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
33125
33126 SWIG_Python_SetConstant(d, "LANGUAGE_DEFAULT",SWIG_From_int(static_cast< int >(wxLANGUAGE_DEFAULT)));
33127 SWIG_Python_SetConstant(d, "LANGUAGE_UNKNOWN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UNKNOWN)));
33128 SWIG_Python_SetConstant(d, "LANGUAGE_ABKHAZIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ABKHAZIAN)));
33129 SWIG_Python_SetConstant(d, "LANGUAGE_AFAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFAR)));
33130 SWIG_Python_SetConstant(d, "LANGUAGE_AFRIKAANS",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFRIKAANS)));
33131 SWIG_Python_SetConstant(d, "LANGUAGE_ALBANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ALBANIAN)));
33132 SWIG_Python_SetConstant(d, "LANGUAGE_AMHARIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AMHARIC)));
33133 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC)));
33134 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_ALGERIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_ALGERIA)));
33135 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_BAHRAIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_BAHRAIN)));
33136 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_EGYPT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_EGYPT)));
33137 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_IRAQ",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_IRAQ)));
33138 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_JORDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_JORDAN)));
33139 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_KUWAIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_KUWAIT)));
33140 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LEBANON",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LEBANON)));
33141 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LIBYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LIBYA)));
33142 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_MOROCCO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_MOROCCO)));
33143 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_OMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_OMAN)));
33144 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_QATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_QATAR)));
33145 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SAUDI_ARABIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
33146 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SUDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SUDAN)));
33147 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SYRIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SYRIA)));
33148 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_TUNISIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_TUNISIA)));
33149 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_UAE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_UAE)));
33150 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_YEMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_YEMEN)));
33151 SWIG_Python_SetConstant(d, "LANGUAGE_ARMENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARMENIAN)));
33152 SWIG_Python_SetConstant(d, "LANGUAGE_ASSAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ASSAMESE)));
33153 SWIG_Python_SetConstant(d, "LANGUAGE_AYMARA",SWIG_From_int(static_cast< int >(wxLANGUAGE_AYMARA)));
33154 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI)));
33155 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_CYRILLIC)));
33156 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_LATIN)));
33157 SWIG_Python_SetConstant(d, "LANGUAGE_BASHKIR",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASHKIR)));
33158 SWIG_Python_SetConstant(d, "LANGUAGE_BASQUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASQUE)));
33159 SWIG_Python_SetConstant(d, "LANGUAGE_BELARUSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BELARUSIAN)));
33160 SWIG_Python_SetConstant(d, "LANGUAGE_BENGALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BENGALI)));
33161 SWIG_Python_SetConstant(d, "LANGUAGE_BHUTANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BHUTANI)));
33162 SWIG_Python_SetConstant(d, "LANGUAGE_BIHARI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BIHARI)));
33163 SWIG_Python_SetConstant(d, "LANGUAGE_BISLAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_BISLAMA)));
33164 SWIG_Python_SetConstant(d, "LANGUAGE_BRETON",SWIG_From_int(static_cast< int >(wxLANGUAGE_BRETON)));
33165 SWIG_Python_SetConstant(d, "LANGUAGE_BULGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BULGARIAN)));
33166 SWIG_Python_SetConstant(d, "LANGUAGE_BURMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BURMESE)));
33167 SWIG_Python_SetConstant(d, "LANGUAGE_CAMBODIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CAMBODIAN)));
33168 SWIG_Python_SetConstant(d, "LANGUAGE_CATALAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CATALAN)));
33169 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE)));
33170 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SIMPLIFIED",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SIMPLIFIED)));
33171 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TRADITIONAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TRADITIONAL)));
33172 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_HONGKONG",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_HONGKONG)));
33173 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_MACAU",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_MACAU)));
33174 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SINGAPORE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SINGAPORE)));
33175 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TAIWAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TAIWAN)));
33176 SWIG_Python_SetConstant(d, "LANGUAGE_CORSICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CORSICAN)));
33177 SWIG_Python_SetConstant(d, "LANGUAGE_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CROATIAN)));
33178 SWIG_Python_SetConstant(d, "LANGUAGE_CZECH",SWIG_From_int(static_cast< int >(wxLANGUAGE_CZECH)));
33179 SWIG_Python_SetConstant(d, "LANGUAGE_DANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DANISH)));
33180 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH)));
33181 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH_BELGIAN)));
33182 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH)));
33183 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_UK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_UK)));
33184 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_US)));
33185 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_AUSTRALIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_AUSTRALIA)));
33186 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BELIZE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BELIZE)));
33187 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BOTSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BOTSWANA)));
33188 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CANADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CANADA)));
33189 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CARIBBEAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CARIBBEAN)));
33190 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_DENMARK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_DENMARK)));
33191 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_EIRE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_EIRE)));
33192 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_JAMAICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_JAMAICA)));
33193 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_NEW_ZEALAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
33194 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_PHILIPPINES",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_PHILIPPINES)));
33195 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_SOUTH_AFRICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
33196 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_TRINIDAD",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_TRINIDAD)));
33197 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_ZIMBABWE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_ZIMBABWE)));
33198 SWIG_Python_SetConstant(d, "LANGUAGE_ESPERANTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESPERANTO)));
33199 SWIG_Python_SetConstant(d, "LANGUAGE_ESTONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESTONIAN)));
33200 SWIG_Python_SetConstant(d, "LANGUAGE_FAEROESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_FAEROESE)));
33201 SWIG_Python_SetConstant(d, "LANGUAGE_FARSI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FARSI)));
33202 SWIG_Python_SetConstant(d, "LANGUAGE_FIJI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FIJI)));
33203 SWIG_Python_SetConstant(d, "LANGUAGE_FINNISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FINNISH)));
33204 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH)));
33205 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_BELGIAN)));
33206 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_CANADIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_CANADIAN)));
33207 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_LUXEMBOURG)));
33208 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_MONACO",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_MONACO)));
33209 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_SWISS)));
33210 SWIG_Python_SetConstant(d, "LANGUAGE_FRISIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRISIAN)));
33211 SWIG_Python_SetConstant(d, "LANGUAGE_GALICIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GALICIAN)));
33212 SWIG_Python_SetConstant(d, "LANGUAGE_GEORGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GEORGIAN)));
33213 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN)));
33214 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_AUSTRIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_AUSTRIAN)));
33215 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_BELGIUM",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_BELGIUM)));
33216 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LIECHTENSTEIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
33217 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LUXEMBOURG)));
33218 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_SWISS)));
33219 SWIG_Python_SetConstant(d, "LANGUAGE_GREEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREEK)));
33220 SWIG_Python_SetConstant(d, "LANGUAGE_GREENLANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREENLANDIC)));
33221 SWIG_Python_SetConstant(d, "LANGUAGE_GUARANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUARANI)));
33222 SWIG_Python_SetConstant(d, "LANGUAGE_GUJARATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUJARATI)));
33223 SWIG_Python_SetConstant(d, "LANGUAGE_HAUSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_HAUSA)));
33224 SWIG_Python_SetConstant(d, "LANGUAGE_HEBREW",SWIG_From_int(static_cast< int >(wxLANGUAGE_HEBREW)));
33225 SWIG_Python_SetConstant(d, "LANGUAGE_HINDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_HINDI)));
33226 SWIG_Python_SetConstant(d, "LANGUAGE_HUNGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_HUNGARIAN)));
33227 SWIG_Python_SetConstant(d, "LANGUAGE_ICELANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ICELANDIC)));
33228 SWIG_Python_SetConstant(d, "LANGUAGE_INDONESIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_INDONESIAN)));
33229 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUA)));
33230 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUE)));
33231 SWIG_Python_SetConstant(d, "LANGUAGE_INUKTITUT",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUKTITUT)));
33232 SWIG_Python_SetConstant(d, "LANGUAGE_INUPIAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUPIAK)));
33233 SWIG_Python_SetConstant(d, "LANGUAGE_IRISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_IRISH)));
33234 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN)));
33235 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN_SWISS)));
33236 SWIG_Python_SetConstant(d, "LANGUAGE_JAPANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAPANESE)));
33237 SWIG_Python_SetConstant(d, "LANGUAGE_JAVANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAVANESE)));
33238 SWIG_Python_SetConstant(d, "LANGUAGE_KANNADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KANNADA)));
33239 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI)));
33240 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI_INDIA)));
33241 SWIG_Python_SetConstant(d, "LANGUAGE_KAZAKH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KAZAKH)));
33242 SWIG_Python_SetConstant(d, "LANGUAGE_KERNEWEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_KERNEWEK)));
33243 SWIG_Python_SetConstant(d, "LANGUAGE_KINYARWANDA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KINYARWANDA)));
33244 SWIG_Python_SetConstant(d, "LANGUAGE_KIRGHIZ",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRGHIZ)));
33245 SWIG_Python_SetConstant(d, "LANGUAGE_KIRUNDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRUNDI)));
33246 SWIG_Python_SetConstant(d, "LANGUAGE_KONKANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KONKANI)));
33247 SWIG_Python_SetConstant(d, "LANGUAGE_KOREAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_KOREAN)));
33248 SWIG_Python_SetConstant(d, "LANGUAGE_KURDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KURDISH)));
33249 SWIG_Python_SetConstant(d, "LANGUAGE_LAOTHIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LAOTHIAN)));
33250 SWIG_Python_SetConstant(d, "LANGUAGE_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATIN)));
33251 SWIG_Python_SetConstant(d, "LANGUAGE_LATVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATVIAN)));
33252 SWIG_Python_SetConstant(d, "LANGUAGE_LINGALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_LINGALA)));
33253 SWIG_Python_SetConstant(d, "LANGUAGE_LITHUANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LITHUANIAN)));
33254 SWIG_Python_SetConstant(d, "LANGUAGE_MACEDONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MACEDONIAN)));
33255 SWIG_Python_SetConstant(d, "LANGUAGE_MALAGASY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAGASY)));
33256 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY)));
33257 SWIG_Python_SetConstant(d, "LANGUAGE_MALAYALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAYALAM)));
33258 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_BRUNEI_DARUSSALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
33259 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_MALAYSIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_MALAYSIA)));
33260 SWIG_Python_SetConstant(d, "LANGUAGE_MALTESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALTESE)));
33261 SWIG_Python_SetConstant(d, "LANGUAGE_MANIPURI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MANIPURI)));
33262 SWIG_Python_SetConstant(d, "LANGUAGE_MAORI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MAORI)));
33263 SWIG_Python_SetConstant(d, "LANGUAGE_MARATHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MARATHI)));
33264 SWIG_Python_SetConstant(d, "LANGUAGE_MOLDAVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MOLDAVIAN)));
33265 SWIG_Python_SetConstant(d, "LANGUAGE_MONGOLIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MONGOLIAN)));
33266 SWIG_Python_SetConstant(d, "LANGUAGE_NAURU",SWIG_From_int(static_cast< int >(wxLANGUAGE_NAURU)));
33267 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI)));
33268 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI_INDIA)));
33269 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_BOKMAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_BOKMAL)));
33270 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_NYNORSK",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_NYNORSK)));
33271 SWIG_Python_SetConstant(d, "LANGUAGE_OCCITAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_OCCITAN)));
33272 SWIG_Python_SetConstant(d, "LANGUAGE_ORIYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ORIYA)));
33273 SWIG_Python_SetConstant(d, "LANGUAGE_OROMO",SWIG_From_int(static_cast< int >(wxLANGUAGE_OROMO)));
33274 SWIG_Python_SetConstant(d, "LANGUAGE_PASHTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_PASHTO)));
33275 SWIG_Python_SetConstant(d, "LANGUAGE_POLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_POLISH)));
33276 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE)));
33277 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE_BRAZILIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
33278 SWIG_Python_SetConstant(d, "LANGUAGE_PUNJABI",SWIG_From_int(static_cast< int >(wxLANGUAGE_PUNJABI)));
33279 SWIG_Python_SetConstant(d, "LANGUAGE_QUECHUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_QUECHUA)));
33280 SWIG_Python_SetConstant(d, "LANGUAGE_RHAETO_ROMANCE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RHAETO_ROMANCE)));
33281 SWIG_Python_SetConstant(d, "LANGUAGE_ROMANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ROMANIAN)));
33282 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN)));
33283 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN_UKRAINE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN_UKRAINE)));
33284 SWIG_Python_SetConstant(d, "LANGUAGE_SAMOAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SAMOAN)));
33285 SWIG_Python_SetConstant(d, "LANGUAGE_SANGHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANGHO)));
33286 SWIG_Python_SetConstant(d, "LANGUAGE_SANSKRIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANSKRIT)));
33287 SWIG_Python_SetConstant(d, "LANGUAGE_SCOTS_GAELIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SCOTS_GAELIC)));
33288 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN)));
33289 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_CYRILLIC)));
33290 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_LATIN)));
33291 SWIG_Python_SetConstant(d, "LANGUAGE_SERBO_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBO_CROATIAN)));
33292 SWIG_Python_SetConstant(d, "LANGUAGE_SESOTHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SESOTHO)));
33293 SWIG_Python_SetConstant(d, "LANGUAGE_SETSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SETSWANA)));
33294 SWIG_Python_SetConstant(d, "LANGUAGE_SHONA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SHONA)));
33295 SWIG_Python_SetConstant(d, "LANGUAGE_SINDHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINDHI)));
33296 SWIG_Python_SetConstant(d, "LANGUAGE_SINHALESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINHALESE)));
33297 SWIG_Python_SetConstant(d, "LANGUAGE_SISWATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SISWATI)));
33298 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVAK)));
33299 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVENIAN)));
33300 SWIG_Python_SetConstant(d, "LANGUAGE_SOMALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SOMALI)));
33301 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH)));
33302 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ARGENTINA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ARGENTINA)));
33303 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_BOLIVIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_BOLIVIA)));
33304 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_CHILE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_CHILE)));
33305 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COLOMBIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COLOMBIA)));
33306 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COSTA_RICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COSTA_RICA)));
33307 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_DOMINICAN_REPUBLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
33308 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ECUADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ECUADOR)));
33309 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_EL_SALVADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_EL_SALVADOR)));
33310 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_GUATEMALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_GUATEMALA)));
33311 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_HONDURAS",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_HONDURAS)));
33312 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MEXICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MEXICAN)));
33313 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MODERN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MODERN)));
33314 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_NICARAGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_NICARAGUA)));
33315 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PANAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PANAMA)));
33316 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PARAGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PARAGUAY)));
33317 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PERU",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PERU)));
33318 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PUERTO_RICO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PUERTO_RICO)));
33319 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_URUGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_URUGUAY)));
33320 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_US)));
33321 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_VENEZUELA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_VENEZUELA)));
33322 SWIG_Python_SetConstant(d, "LANGUAGE_SUNDANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SUNDANESE)));
33323 SWIG_Python_SetConstant(d, "LANGUAGE_SWAHILI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWAHILI)));
33324 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH)));
33325 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH_FINLAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH_FINLAND)));
33326 SWIG_Python_SetConstant(d, "LANGUAGE_TAGALOG",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAGALOG)));
33327 SWIG_Python_SetConstant(d, "LANGUAGE_TAJIK",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAJIK)));
33328 SWIG_Python_SetConstant(d, "LANGUAGE_TAMIL",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAMIL)));
33329 SWIG_Python_SetConstant(d, "LANGUAGE_TATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_TATAR)));
33330 SWIG_Python_SetConstant(d, "LANGUAGE_TELUGU",SWIG_From_int(static_cast< int >(wxLANGUAGE_TELUGU)));
33331 SWIG_Python_SetConstant(d, "LANGUAGE_THAI",SWIG_From_int(static_cast< int >(wxLANGUAGE_THAI)));
33332 SWIG_Python_SetConstant(d, "LANGUAGE_TIBETAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIBETAN)));
33333 SWIG_Python_SetConstant(d, "LANGUAGE_TIGRINYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIGRINYA)));
33334 SWIG_Python_SetConstant(d, "LANGUAGE_TONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TONGA)));
33335 SWIG_Python_SetConstant(d, "LANGUAGE_TSONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TSONGA)));
33336 SWIG_Python_SetConstant(d, "LANGUAGE_TURKISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKISH)));
33337 SWIG_Python_SetConstant(d, "LANGUAGE_TURKMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKMEN)));
33338 SWIG_Python_SetConstant(d, "LANGUAGE_TWI",SWIG_From_int(static_cast< int >(wxLANGUAGE_TWI)));
33339 SWIG_Python_SetConstant(d, "LANGUAGE_UIGHUR",SWIG_From_int(static_cast< int >(wxLANGUAGE_UIGHUR)));
33340 SWIG_Python_SetConstant(d, "LANGUAGE_UKRAINIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UKRAINIAN)));
33341 SWIG_Python_SetConstant(d, "LANGUAGE_URDU",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU)));
33342 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_INDIA)));
33343 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_PAKISTAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_PAKISTAN)));
33344 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK)));
33345 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_CYRILLIC)));
33346 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_LATIN)));
33347 SWIG_Python_SetConstant(d, "LANGUAGE_VIETNAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_VIETNAMESE)));
33348 SWIG_Python_SetConstant(d, "LANGUAGE_VOLAPUK",SWIG_From_int(static_cast< int >(wxLANGUAGE_VOLAPUK)));
33349 SWIG_Python_SetConstant(d, "LANGUAGE_WELSH",SWIG_From_int(static_cast< int >(wxLANGUAGE_WELSH)));
33350 SWIG_Python_SetConstant(d, "LANGUAGE_WOLOF",SWIG_From_int(static_cast< int >(wxLANGUAGE_WOLOF)));
33351 SWIG_Python_SetConstant(d, "LANGUAGE_XHOSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_XHOSA)));
33352 SWIG_Python_SetConstant(d, "LANGUAGE_YIDDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_YIDDISH)));
33353 SWIG_Python_SetConstant(d, "LANGUAGE_YORUBA",SWIG_From_int(static_cast< int >(wxLANGUAGE_YORUBA)));
33354 SWIG_Python_SetConstant(d, "LANGUAGE_ZHUANG",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZHUANG)));
33355 SWIG_Python_SetConstant(d, "LANGUAGE_ZULU",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZULU)));
33356 SWIG_Python_SetConstant(d, "LANGUAGE_USER_DEFINED",SWIG_From_int(static_cast< int >(wxLANGUAGE_USER_DEFINED)));
33357 SWIG_Python_SetConstant(d, "LOCALE_CAT_NUMBER",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_NUMBER)));
33358 SWIG_Python_SetConstant(d, "LOCALE_CAT_DATE",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_DATE)));
33359 SWIG_Python_SetConstant(d, "LOCALE_CAT_MONEY",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MONEY)));
33360 SWIG_Python_SetConstant(d, "LOCALE_CAT_MAX",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MAX)));
33361 SWIG_Python_SetConstant(d, "LOCALE_THOUSANDS_SEP",SWIG_From_int(static_cast< int >(wxLOCALE_THOUSANDS_SEP)));
33362 SWIG_Python_SetConstant(d, "LOCALE_DECIMAL_POINT",SWIG_From_int(static_cast< int >(wxLOCALE_DECIMAL_POINT)));
33363 SWIG_Python_SetConstant(d, "LOCALE_LOAD_DEFAULT",SWIG_From_int(static_cast< int >(wxLOCALE_LOAD_DEFAULT)));
33364 SWIG_Python_SetConstant(d, "LOCALE_CONV_ENCODING",SWIG_From_int(static_cast< int >(wxLOCALE_CONV_ENCODING)));
33365 SWIG_Python_SetConstant(d, "CONVERT_STRICT",SWIG_From_int(static_cast< int >(wxCONVERT_STRICT)));
33366 SWIG_Python_SetConstant(d, "CONVERT_SUBSTITUTE",SWIG_From_int(static_cast< int >(wxCONVERT_SUBSTITUTE)));
33367 SWIG_Python_SetConstant(d, "PLATFORM_CURRENT",SWIG_From_int(static_cast< int >(wxPLATFORM_CURRENT)));
33368 SWIG_Python_SetConstant(d, "PLATFORM_UNIX",SWIG_From_int(static_cast< int >(wxPLATFORM_UNIX)));
33369 SWIG_Python_SetConstant(d, "PLATFORM_WINDOWS",SWIG_From_int(static_cast< int >(wxPLATFORM_WINDOWS)));
33370 SWIG_Python_SetConstant(d, "PLATFORM_OS2",SWIG_From_int(static_cast< int >(wxPLATFORM_OS2)));
33371 SWIG_Python_SetConstant(d, "PLATFORM_MAC",SWIG_From_int(static_cast< int >(wxPLATFORM_MAC)));
33372 SWIG_Python_SetConstant(d, "BUFFER_VIRTUAL_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_VIRTUAL_AREA)));
33373 SWIG_Python_SetConstant(d, "BUFFER_CLIENT_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_CLIENT_AREA)));
33374 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_NORMAL)));
33375 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_TRANSPARENT)));
33376 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_SELECTED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_SELECTED)));
33377 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_FOCUSED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_FOCUSED)));
33378 SWIG_Python_SetConstant(d, "IMAGE_LIST_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_NORMAL)));
33379 SWIG_Python_SetConstant(d, "IMAGE_LIST_SMALL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_SMALL)));
33380 SWIG_Python_SetConstant(d, "IMAGE_LIST_STATE",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_STATE)));
33381 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLACK)));
33382 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLUE)));
33383 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_CYAN)));
33384 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREEN)));
33385 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREY)));
33386 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_LIGHTGREY)));
33387 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_MEDIUMGREY)));
33388 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_RED",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_RED)));
33389 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_TRANSPARENT)));
33390 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_WHITE)));
33391 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLACK)));
33392 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLUE)));
33393 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_CYAN)));
33394 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_GREEN)));
33395 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_LIGHTGREY)));
33396 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_RED",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_RED)));
33397 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_WHITE)));
33398 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_CROSS)));
33399 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_HOURGLASS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_HOURGLASS)));
33400 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_STANDARD",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_STANDARD)));
33401 SWIG_Python_SetConstant(d, "StockGDI_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_ITALIC)));
33402 SWIG_Python_SetConstant(d, "StockGDI_FONT_NORMAL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_NORMAL)));
33403 SWIG_Python_SetConstant(d, "StockGDI_FONT_SMALL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SMALL)));
33404 SWIG_Python_SetConstant(d, "StockGDI_FONT_SWISS",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SWISS)));
33405 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACK)));
33406 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACKDASHED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACKDASHED)));
33407 SWIG_Python_SetConstant(d, "StockGDI_PEN_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_CYAN)));
33408 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREEN)));
33409 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREY)));
33410 SWIG_Python_SetConstant(d, "StockGDI_PEN_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_LIGHTGREY)));
33411 SWIG_Python_SetConstant(d, "StockGDI_PEN_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_MEDIUMGREY)));
33412 SWIG_Python_SetConstant(d, "StockGDI_PEN_RED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_RED)));
33413 SWIG_Python_SetConstant(d, "StockGDI_PEN_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_TRANSPARENT)));
33414 SWIG_Python_SetConstant(d, "StockGDI_PEN_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_WHITE)));
33415 SWIG_Python_SetConstant(d, "StockGDI_ITEMCOUNT",SWIG_From_int(static_cast< int >(wxStockGDI::ITEMCOUNT)));
33416 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
33417 SWIG_addvarlink(SWIG_globals(),(char*)"NullBitmap",NullBitmap_get, NullBitmap_set);
33418 SWIG_addvarlink(SWIG_globals(),(char*)"NullIcon",NullIcon_get, NullIcon_set);
33419 SWIG_addvarlink(SWIG_globals(),(char*)"NullCursor",NullCursor_get, NullCursor_set);
33420 SWIG_addvarlink(SWIG_globals(),(char*)"NullPen",NullPen_get, NullPen_set);
33421 SWIG_addvarlink(SWIG_globals(),(char*)"NullBrush",NullBrush_get, NullBrush_set);
33422 SWIG_addvarlink(SWIG_globals(),(char*)"NullPalette",NullPalette_get, NullPalette_set);
33423 SWIG_addvarlink(SWIG_globals(),(char*)"NullFont",NullFont_get, NullFont_set);
33424 SWIG_addvarlink(SWIG_globals(),(char*)"NullColour",NullColour_get, NullColour_set);
33425 SWIG_Python_SetConstant(d, "CONTROL_DISABLED",SWIG_From_int(static_cast< int >(wxCONTROL_DISABLED)));
33426 SWIG_Python_SetConstant(d, "CONTROL_FOCUSED",SWIG_From_int(static_cast< int >(wxCONTROL_FOCUSED)));
33427 SWIG_Python_SetConstant(d, "CONTROL_PRESSED",SWIG_From_int(static_cast< int >(wxCONTROL_PRESSED)));
33428 SWIG_Python_SetConstant(d, "CONTROL_ISDEFAULT",SWIG_From_int(static_cast< int >(wxCONTROL_ISDEFAULT)));
33429 SWIG_Python_SetConstant(d, "CONTROL_ISSUBMENU",SWIG_From_int(static_cast< int >(wxCONTROL_ISSUBMENU)));
33430 SWIG_Python_SetConstant(d, "CONTROL_EXPANDED",SWIG_From_int(static_cast< int >(wxCONTROL_EXPANDED)));
33431 SWIG_Python_SetConstant(d, "CONTROL_CURRENT",SWIG_From_int(static_cast< int >(wxCONTROL_CURRENT)));
33432 SWIG_Python_SetConstant(d, "CONTROL_SELECTED",SWIG_From_int(static_cast< int >(wxCONTROL_SELECTED)));
33433 SWIG_Python_SetConstant(d, "CONTROL_CHECKED",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKED)));
33434 SWIG_Python_SetConstant(d, "CONTROL_CHECKABLE",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKABLE)));
33435 SWIG_Python_SetConstant(d, "CONTROL_UNDETERMINED",SWIG_From_int(static_cast< int >(wxCONTROL_UNDETERMINED)));
33436 SWIG_Python_SetConstant(d, "CONTROL_FLAGS_MASK",SWIG_From_int(static_cast< int >(wxCONTROL_FLAGS_MASK)));
33437 SWIG_Python_SetConstant(d, "CONTROL_DIRTY",SWIG_From_int(static_cast< int >(wxCONTROL_DIRTY)));
33438 SWIG_Python_SetConstant(d, "RendererVersion_Current_Version",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Version)));
33439 SWIG_Python_SetConstant(d, "RendererVersion_Current_Age",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Age)));
33440
33441 // Work around a chicken/egg problem in drawlist.cpp
33442 wxPyDrawList_SetAPIPtr();
33443
33444 }
33445
wxWidgets (Impactor)