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


9a48da37f259bcd634b1dcade044e4a6abd6c536
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_double swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_unsigned_char swig_types[4]
2467 #define SWIGTYPE_p_unsigned_int swig_types[5]
2468 #define SWIGTYPE_p_unsigned_long swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxBMPHandler swig_types[10]
2473 #define SWIGTYPE_p_wxBitmap swig_types[11]
2474 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2475 #define SWIGTYPE_p_wxBrush swig_types[13]
2476 #define SWIGTYPE_p_wxBrushList swig_types[14]
2477 #define SWIGTYPE_p_wxBufferedDC swig_types[15]
2478 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxChildFocusEvent swig_types[18]
2481 #define SWIGTYPE_p_wxClientDC swig_types[19]
2482 #define SWIGTYPE_p_wxCloseEvent swig_types[20]
2483 #define SWIGTYPE_p_wxColour swig_types[21]
2484 #define SWIGTYPE_p_wxColourDatabase swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDash swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEffects swig_types[34]
2497 #define SWIGTYPE_p_wxEncodingConverter swig_types[35]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEvent swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2504 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2505 #define SWIGTYPE_p_wxFont swig_types[43]
2506 #define SWIGTYPE_p_wxFontList swig_types[44]
2507 #define SWIGTYPE_p_wxFontMapper swig_types[45]
2508 #define SWIGTYPE_p_wxGBSizerItem swig_types[46]
2509 #define SWIGTYPE_p_wxGDIObject swig_types[47]
2510 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2511 #define SWIGTYPE_p_wxGridBagSizer swig_types[49]
2512 #define SWIGTYPE_p_wxGridSizer swig_types[50]
2513 #define SWIGTYPE_p_wxICOHandler swig_types[51]
2514 #define SWIGTYPE_p_wxIcon swig_types[52]
2515 #define SWIGTYPE_p_wxIconBundle swig_types[53]
2516 #define SWIGTYPE_p_wxIconLocation swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageList swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxJPEGHandler swig_types[62]
2525 #define SWIGTYPE_p_wxKeyEvent swig_types[63]
2526 #define SWIGTYPE_p_wxLanguageInfo swig_types[64]
2527 #define SWIGTYPE_p_wxLayoutConstraints swig_types[65]
2528 #define SWIGTYPE_p_wxLocale swig_types[66]
2529 #define SWIGTYPE_p_wxMask swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryDC swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuEvent swig_types[72]
2535 #define SWIGTYPE_p_wxMenuItem swig_types[73]
2536 #define SWIGTYPE_p_wxMetaFile swig_types[74]
2537 #define SWIGTYPE_p_wxMetaFileDC swig_types[75]
2538 #define SWIGTYPE_p_wxMirrorDC swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[80]
2543 #define SWIGTYPE_p_wxNativeFontInfo swig_types[81]
2544 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2546 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2547 #define SWIGTYPE_p_wxObject swig_types[85]
2548 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2551 #define SWIGTYPE_p_wxPaintDC swig_types[89]
2552 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2553 #define SWIGTYPE_p_wxPalette swig_types[91]
2554 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2555 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2556 #define SWIGTYPE_p_wxPen swig_types[94]
2557 #define SWIGTYPE_p_wxPenList swig_types[95]
2558 #define SWIGTYPE_p_wxPoint swig_types[96]
2559 #define SWIGTYPE_p_wxPostScriptDC swig_types[97]
2560 #define SWIGTYPE_p_wxPrintData swig_types[98]
2561 #define SWIGTYPE_p_wxPrinterDC swig_types[99]
2562 #define SWIGTYPE_p_wxPyApp swig_types[100]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[101]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[103]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2567 #define SWIGTYPE_p_wxPySizer swig_types[105]
2568 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2569 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2570 #define SWIGTYPE_p_wxRect swig_types[108]
2571 #define SWIGTYPE_p_wxRegion swig_types[109]
2572 #define SWIGTYPE_p_wxRegionIterator swig_types[110]
2573 #define SWIGTYPE_p_wxRendererNative swig_types[111]
2574 #define SWIGTYPE_p_wxRendererVersion swig_types[112]
2575 #define SWIGTYPE_p_wxScreenDC swig_types[113]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2580 #define SWIGTYPE_p_wxSize swig_types[118]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2582 #define SWIGTYPE_p_wxSizer swig_types[120]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2584 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[122]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2587 #define SWIGTYPE_p_wxString swig_types[125]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[128]
2591 #define SWIGTYPE_p_wxValidator swig_types[129]
2592 #define SWIGTYPE_p_wxWindow swig_types[130]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2594 #define SWIGTYPE_p_wxWindowDC swig_types[132]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[133]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[134]
2597 static swig_type_info *swig_types[136];
2598 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _gdi_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_gdi_
2623
2624 #define SWIG_name "_gdi_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython.h"
2697 #include "wx/wxPython/pyclasses.h"
2698
2699
2700 static const wxString wxPyEmptyString(wxEmptyString);
2701
2702 SWIGINTERN int
2703 SWIG_AsVal_long (PyObject* obj, long* val)
2704 {
2705 if (PyNumber_Check(obj)) {
2706 if (val) *val = PyInt_AsLong(obj);
2707 return SWIG_OK;
2708 }
2709 return SWIG_TypeError;
2710 }
2711
2712
2713 SWIGINTERN int
2714 SWIG_AsVal_bool (PyObject *obj, bool *val)
2715 {
2716 if (obj == Py_True) {
2717 if (val) *val = true;
2718 return SWIG_OK;
2719 } else if (obj == Py_False) {
2720 if (val) *val = false;
2721 return SWIG_OK;
2722 } else {
2723 long v = 0;
2724 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2725 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2726 return res;
2727 }
2728 }
2729
2730
2731 #include <limits.h>
2732 #ifndef LLONG_MIN
2733 # define LLONG_MIN LONG_LONG_MIN
2734 #endif
2735 #ifndef LLONG_MAX
2736 # define LLONG_MAX LONG_LONG_MAX
2737 #endif
2738 #ifndef ULLONG_MAX
2739 # define ULLONG_MAX ULONG_LONG_MAX
2740 #endif
2741
2742
2743 SWIGINTERN int
2744 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2745 {
2746 long v = 0;
2747 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2748 return SWIG_TypeError;
2749 }
2750 else if (val)
2751 *val = (unsigned long)v;
2752 return SWIG_OK;
2753 }
2754
2755
2756 SWIGINTERN int
2757 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
2758 {
2759 unsigned long v;
2760 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2761 if (SWIG_IsOK(res)) {
2762 if ((v > UCHAR_MAX)) {
2763 return SWIG_OverflowError;
2764 } else {
2765 if (val) *val = static_cast< unsigned char >(v);
2766 }
2767 }
2768 return res;
2769 }
2770
2771
2772 #define SWIG_From_long PyInt_FromLong
2773
2774
2775 SWIGINTERNINLINE PyObject*
2776 SWIG_From_unsigned_SS_long (unsigned long value)
2777 {
2778 return (value > LONG_MAX) ?
2779 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2780 }
2781
2782
2783 SWIGINTERNINLINE PyObject *
2784 SWIG_From_unsigned_SS_char (unsigned char value)
2785 {
2786 return SWIG_From_unsigned_SS_long (value);
2787 }
2788
2789 SWIGINTERN bool wxColour___eq__(wxColour *self,PyObject *other){
2790 wxColour temp, *obj = &temp;
2791 if ( other == Py_None ) return false;
2792 if ( ! wxColour_helper(other, &obj) ) {
2793 PyErr_Clear();
2794 return false;
2795 }
2796 return self->operator==(*obj);
2797 }
2798 SWIGINTERN bool wxColour___ne__(wxColour *self,PyObject *other){
2799 wxColour temp, *obj = &temp;
2800 if ( other == Py_None ) return true;
2801 if ( ! wxColour_helper(other, &obj)) {
2802 PyErr_Clear();
2803 return true;
2804 }
2805 return self->operator!=(*obj);
2806 }
2807 SWIGINTERN PyObject *wxColour_Get(wxColour *self){
2808 PyObject* rv = PyTuple_New(3);
2809 int red = -1;
2810 int green = -1;
2811 int blue = -1;
2812 if (self->Ok()) {
2813 red = self->Red();
2814 green = self->Green();
2815 blue = self->Blue();
2816 }
2817 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
2818 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
2819 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
2820 return rv;
2821 }
2822 SWIGINTERN unsigned long wxColour_GetRGB(wxColour *self){
2823 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
2824 }
2825
2826 SWIGINTERN int
2827 SWIG_AsVal_int (PyObject * obj, int *val)
2828 {
2829 long v;
2830 int res = SWIG_AsVal_long (obj, &v);
2831 if (SWIG_IsOK(res)) {
2832 if ((v < INT_MIN || v > INT_MAX)) {
2833 return SWIG_OverflowError;
2834 } else {
2835 if (val) *val = static_cast< int >(v);
2836 }
2837 }
2838 return res;
2839 }
2840
2841
2842 SWIGINTERNINLINE PyObject *
2843 SWIG_From_int (int value)
2844 {
2845 return SWIG_From_long (value);
2846 }
2847
2848 SWIGINTERN PyObject *wxPen_GetDashes(wxPen *self){
2849 wxDash* dashes;
2850 int count = self->GetDashes(&dashes);
2851 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2852 PyObject* retval = PyList_New(0);
2853 for (int x=0; x<count; x++) {
2854 PyObject* pyint = PyInt_FromLong(dashes[x]);
2855 PyList_Append(retval, pyint);
2856 Py_DECREF(pyint);
2857 }
2858 wxPyEndBlockThreads(blocked);
2859 return retval;
2860 }
2861 SWIGINTERN void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
2862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2863 int size = PyList_Size(pyDashes);
2864 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
2865
2866 // black magic warning! The array of wxDashes needs to exist as
2867 // long as the pen does because wxPen does not copy the array. So
2868 // stick a copy in a Python string object and attach it to _self,
2869 // and then call SetDashes with a pointer to that array. Then
2870 // when the Python pen object is destroyed the array will be
2871 // cleaned up too.
2872 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
2873 PyObject_SetAttrString(_self, "_dashes", strDashes);
2874
2875 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
2876 delete [] dashes;
2877 Py_DECREF(strDashes);
2878 wxPyEndBlockThreads(blocked);
2879 }
2880 SWIGINTERN bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
2881 SWIGINTERN bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
2882
2883 SWIGINTERNINLINE PyObject *
2884 SWIG_From_short (short value)
2885 {
2886 return SWIG_From_long (value);
2887 }
2888
2889
2890 SWIGINTERN int
2891 SWIG_AsVal_short (PyObject * obj, short *val)
2892 {
2893 long v;
2894 int res = SWIG_AsVal_long (obj, &v);
2895 if (SWIG_IsOK(res)) {
2896 if ((v < SHRT_MIN || v > SHRT_MAX)) {
2897 return SWIG_OverflowError;
2898 } else {
2899 if (val) *val = static_cast< short >(v);
2900 }
2901 }
2902 return res;
2903 }
2904
2905
2906 #include <wx/image.h>
2907
2908 static char** ConvertListOfStrings(PyObject* listOfStrings) {
2909 char** cArray = NULL;
2910 int count;
2911
2912 if (!PyList_Check(listOfStrings)) {
2913 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2914 return NULL;
2915 }
2916 count = PyList_Size(listOfStrings);
2917 cArray = new char*[count];
2918
2919 for(int x=0; x<count; x++) {
2920 // TODO: Need some validation and error checking here
2921 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
2922 }
2923 return cArray;
2924 }
2925
2926
2927 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *listOfStrings){
2928 char** cArray = NULL;
2929 wxBitmap* bmp;
2930
2931 cArray = ConvertListOfStrings(listOfStrings);
2932 if (! cArray)
2933 return NULL;
2934 bmp = new wxBitmap(cArray);
2935 delete [] cArray;
2936 return bmp;
2937 }
2938 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
2939 char* buf;
2940 int length;
2941 PyString_AsStringAndSize(bits, &buf, &length);
2942 return new wxBitmap(buf, width, height, depth);
2943 }
2944 SWIGINTERN wxSize wxBitmap_GetSize(wxBitmap *self){
2945 wxSize size(self->GetWidth(), self->GetHeight());
2946 return size;
2947 }
2948 SWIGINTERN void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
2949 wxMask *mask = new wxMask(*self, colour);
2950 self->SetMask(mask);
2951 }
2952 SWIGINTERN void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
2953 self->SetWidth(size.x);
2954 self->SetHeight(size.y);
2955 }
2956 SWIGINTERN bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
2957 SWIGINTERN bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
2958 SWIGINTERN wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
2959 if ( !colour.Ok() )
2960 return new wxMask(bitmap, *wxBLACK);
2961 else
2962 return new wxMask(bitmap, colour);
2963 }
2964
2965 #include <wx/iconbndl.h>
2966
2967 SWIGINTERN wxIcon *new_wxIcon(wxBitmap const &bmp){
2968 wxIcon* icon = new wxIcon();
2969 icon->CopyFromBitmap(bmp);
2970 return icon;
2971 }
2972 SWIGINTERN wxIcon *new_wxIcon(PyObject *listOfStrings){
2973 char** cArray = NULL;
2974 wxIcon* icon;
2975
2976 cArray = ConvertListOfStrings(listOfStrings);
2977 if (! cArray)
2978 return NULL;
2979 icon = new wxIcon(cArray);
2980 delete [] cArray;
2981 return icon;
2982 }
2983 SWIGINTERN wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
2984
2985
2986
2987 return new wxIconLocation(*filename);
2988
2989 }
2990 SWIGINTERN void wxIconLocation_SetIndex(wxIconLocation *self,int num){
2991
2992
2993
2994 // do nothing
2995
2996 }
2997 SWIGINTERN int wxIconLocation_GetIndex(wxIconLocation *self){
2998
2999
3000
3001 return -1;
3002
3003 }
3004 SWIGINTERN wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
3005 #ifdef __WXGTK__
3006 wxImage img(cursorName, type);
3007 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
3008 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
3009 return new wxCursor(img);
3010 #else
3011 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
3012 #endif
3013 }
3014
3015
3016 SWIGINTERN void wxRegionIterator_Next(wxRegionIterator *self){
3017 (*self) ++;
3018 }
3019 SWIGINTERN bool wxRegionIterator___nonzero__(wxRegionIterator *self){
3020 return self->operator bool();
3021 }
3022
3023 #include <wx/fontutil.h>
3024 #include <wx/fontmap.h>
3025 #include <wx/fontenum.h>
3026
3027 SWIGINTERN wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
3028 return self->ToString();
3029 }
3030
3031 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
3032 static wxNativeEncodingInfo info;
3033 if ( wxGetNativeFontEncoding(encoding, &info) )
3034 return &info;
3035 else
3036 return NULL;
3037 }
3038
3039
3040 SWIGINTERNINLINE PyObject *
3041 SWIG_From_size_t (size_t value)
3042 {
3043 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3044 }
3045
3046
3047 SWIGINTERNINLINE int
3048 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3049 {
3050 unsigned long v;
3051 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3052 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3053 return res;
3054 }
3055
3056 SWIGINTERN PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
3057 wxFontEncoding alt_enc;
3058 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
3059 return PyInt_FromLong(alt_enc);
3060 else {
3061 Py_INCREF(Py_None);
3062 return Py_None;
3063 }
3064 }
3065 SWIGINTERN wxFont *new_wxFont(wxString const &info){
3066 wxNativeFontInfo nfi;
3067 nfi.FromString(info);
3068 return new wxFont(nfi);
3069 }
3070 SWIGINTERN wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3071 return wxFont::New(pointSize, family, flags, face, encoding);
3072 }
3073 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3074 return wxFontBase::New(pixelSize, family,
3075 style, weight, underlined,
3076 face, encoding);
3077 }
3078 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3079 return wxFontBase::New(pixelSize, family, flags, face, encoding);
3080 }
3081 SWIGINTERN bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
3082 SWIGINTERN bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
3083
3084 class wxPyFontEnumerator : public wxFontEnumerator {
3085 public:
3086 wxPyFontEnumerator() {}
3087 ~wxPyFontEnumerator() {}
3088
3089 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
3090 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
3091
3092 PYPRIVATE;
3093 };
3094
3095 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
3096 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
3097
3098
3099 SWIGINTERN PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
3100 PyObject* ret;
3101 wxArrayString* arr = self->GetEncodings();
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 if (arr)
3104 ret = wxArrayString2PyList_helper(*arr);
3105 else
3106 ret = PyList_New(0);
3107 wxPyEndBlockThreads(blocked);
3108 return ret;
3109 }
3110 SWIGINTERN PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
3111 PyObject* ret;
3112 wxArrayString* arr = self->GetFacenames();
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3114 if (arr)
3115 ret = wxArrayString2PyList_helper(*arr);
3116 else
3117 ret = PyList_New(0);
3118 wxPyEndBlockThreads(blocked);
3119 return ret;
3120 }
3121
3122 #include <locale.h>
3123
3124 SWIGINTERN wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3125 wxLocale* loc;
3126 if (language == -1)
3127 loc = new wxLocale();
3128 else
3129 loc = new wxLocale(language, flags);
3130 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3131 // for the floating point conversions and such to work right.
3132 #if PY_VERSION_HEX < 0x02040000
3133 setlocale(LC_NUMERIC, "C");
3134 #endif
3135 return loc;
3136 }
3137 SWIGINTERN bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
3138 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
3139 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3140 // for the floating point conversions and such to work right.
3141 #if PY_VERSION_HEX < 0x02040000
3142 setlocale(LC_NUMERIC, "C");
3143 #endif
3144 return rc;
3145 }
3146 SWIGINTERN bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3147 bool rc = self->Init(language, flags);
3148 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3149 // for the floating point conversions and such to work right.
3150 #if PY_VERSION_HEX < 0x02040000
3151 setlocale(LC_NUMERIC, "C");
3152 #endif
3153 return rc;
3154 }
3155
3156 #include "wx/wxPython/pydrawxxx.h"
3157
3158 SWIGINTERN wxColour wxDC_GetPixel(wxDC *self,int x,int y){
3159 wxColour col;
3160 self->GetPixel(x, y, &col);
3161 return col;
3162 }
3163 SWIGINTERN wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
3164 wxColour col;
3165 self->GetPixel(pt, &col);
3166 return col;
3167 }
3168
3169 SWIGINTERN int
3170 SWIG_AsVal_double (PyObject *obj, double* val)
3171 {
3172 if (PyNumber_Check(obj)) {
3173 if (val) *val = PyFloat_AsDouble(obj);
3174 return SWIG_OK;
3175 }
3176 return SWIG_TypeError;
3177 }
3178
3179 SWIGINTERN wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
3180 wxRect rv;
3181 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
3182 return rv;
3183 }
3184 SWIGINTERN wxRect wxDC_GetClippingRect(wxDC *self){
3185 wxRect rect;
3186 self->GetClippingBox(rect);
3187 return rect;
3188 }
3189 SWIGINTERN wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
3190 wxArrayInt widths;
3191 self->GetPartialTextExtents(text, widths);
3192 return widths;
3193 }
3194
3195 #define SWIG_From_double PyFloat_FromDouble
3196
3197 SWIGINTERN void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
3198 self->SetLogicalOrigin(point.x, point.y);
3199 }
3200 SWIGINTERN void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
3201 self->SetDeviceOrigin(point.x, point.y);
3202 }
3203 SWIGINTERN void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
3204 self->CalcBoundingBox(point.x, point.y);
3205 }
3206 SWIGINTERN PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3207 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
3208 }
3209 SWIGINTERN PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3210 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
3211 }
3212 SWIGINTERN PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3213 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
3214 }
3215 SWIGINTERN PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3216 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
3217 }
3218 SWIGINTERN PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3219 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
3220 }
3221 SWIGINTERN PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
3222 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
3223 }
3224
3225 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
3226 *x1 = dc->MinX();
3227 *y1 = dc->MinY();
3228 *x2 = dc->MaxX();
3229 *y2 = dc->MaxY();
3230 }
3231
3232
3233 #include <wx/dcbuffer.h>
3234
3235
3236 #include <wx/dcps.h>
3237
3238
3239 #include <wx/metafile.h>
3240
3241
3242
3243 SWIGINTERN void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
3244 self->AddColour(name, wxColour(red, green, blue));
3245 }
3246
3247 #include <wx/effects.h>
3248
3249
3250 #include "wx/renderer.h"
3251
3252
3253 SWIGINTERNINLINE PyObject*
3254 SWIG_From_bool (bool value)
3255 {
3256 return PyBool_FromLong(value ? 1 : 0);
3257 }
3258
3259 #ifdef __cplusplus
3260 extern "C" {
3261 #endif
3262 SWIGINTERN PyObject *_wrap_new_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3263 PyObject *resultobj = 0;
3264 wxGDIObject *result = 0 ;
3265
3266 if (!SWIG_Python_UnpackTuple(args,"new_GDIObject",0,0,0)) SWIG_fail;
3267 {
3268 if (!wxPyCheckForApp()) SWIG_fail;
3269 PyThreadState* __tstate = wxPyBeginAllowThreads();
3270 result = (wxGDIObject *)new wxGDIObject();
3271 wxPyEndAllowThreads(__tstate);
3272 if (PyErr_Occurred()) SWIG_fail;
3273 }
3274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObject, SWIG_POINTER_NEW | 0 );
3275 return resultobj;
3276 fail:
3277 return NULL;
3278 }
3279
3280
3281 SWIGINTERN PyObject *_wrap_delete_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3282 PyObject *resultobj = 0;
3283 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3284 void *argp1 = 0 ;
3285 int res1 = 0 ;
3286 PyObject *swig_obj[1] ;
3287
3288 if (!args) SWIG_fail;
3289 swig_obj[0] = args;
3290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, SWIG_POINTER_DISOWN | 0 );
3291 if (!SWIG_IsOK(res1)) {
3292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObject" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3293 }
3294 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3295 {
3296 PyThreadState* __tstate = wxPyBeginAllowThreads();
3297 delete arg1;
3298
3299 wxPyEndAllowThreads(__tstate);
3300 if (PyErr_Occurred()) SWIG_fail;
3301 }
3302 resultobj = SWIG_Py_Void();
3303 return resultobj;
3304 fail:
3305 return NULL;
3306 }
3307
3308
3309 SWIGINTERN PyObject *_wrap_GDIObject_GetVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3310 PyObject *resultobj = 0;
3311 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3312 bool result;
3313 void *argp1 = 0 ;
3314 int res1 = 0 ;
3315 PyObject *swig_obj[1] ;
3316
3317 if (!args) SWIG_fail;
3318 swig_obj[0] = args;
3319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3320 if (!SWIG_IsOK(res1)) {
3321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_GetVisible" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3322 }
3323 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3324 {
3325 PyThreadState* __tstate = wxPyBeginAllowThreads();
3326 result = (bool)(arg1)->GetVisible();
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 {
3331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3332 }
3333 return resultobj;
3334 fail:
3335 return NULL;
3336 }
3337
3338
3339 SWIGINTERN PyObject *_wrap_GDIObject_SetVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj = 0;
3341 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3342 bool arg2 ;
3343 void *argp1 = 0 ;
3344 int res1 = 0 ;
3345 bool val2 ;
3346 int ecode2 = 0 ;
3347 PyObject * obj0 = 0 ;
3348 PyObject * obj1 = 0 ;
3349 char * kwnames[] = {
3350 (char *) "self",(char *) "visible", NULL
3351 };
3352
3353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) SWIG_fail;
3354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3355 if (!SWIG_IsOK(res1)) {
3356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_SetVisible" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3357 }
3358 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3359 ecode2 = SWIG_AsVal_bool(obj1, &val2);
3360 if (!SWIG_IsOK(ecode2)) {
3361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GDIObject_SetVisible" "', expected argument " "2"" of type '" "bool""'");
3362 }
3363 arg2 = static_cast< bool >(val2);
3364 {
3365 PyThreadState* __tstate = wxPyBeginAllowThreads();
3366 (arg1)->SetVisible(arg2);
3367 wxPyEndAllowThreads(__tstate);
3368 if (PyErr_Occurred()) SWIG_fail;
3369 }
3370 resultobj = SWIG_Py_Void();
3371 return resultobj;
3372 fail:
3373 return NULL;
3374 }
3375
3376
3377 SWIGINTERN PyObject *_wrap_GDIObject_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3378 PyObject *resultobj = 0;
3379 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3380 bool result;
3381 void *argp1 = 0 ;
3382 int res1 = 0 ;
3383 PyObject *swig_obj[1] ;
3384
3385 if (!args) SWIG_fail;
3386 swig_obj[0] = args;
3387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3388 if (!SWIG_IsOK(res1)) {
3389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_IsNull" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3390 }
3391 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3392 {
3393 PyThreadState* __tstate = wxPyBeginAllowThreads();
3394 result = (bool)(arg1)->IsNull();
3395 wxPyEndAllowThreads(__tstate);
3396 if (PyErr_Occurred()) SWIG_fail;
3397 }
3398 {
3399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3400 }
3401 return resultobj;
3402 fail:
3403 return NULL;
3404 }
3405
3406
3407 SWIGINTERN PyObject *GDIObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3408 PyObject *obj;
3409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3410 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObject, SWIG_NewClientData(obj));
3411 return SWIG_Py_Void();
3412 }
3413
3414 SWIGINTERN PyObject *GDIObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3415 return SWIG_Python_InitShadowInstance(args);
3416 }
3417
3418 SWIGINTERN PyObject *_wrap_new_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj = 0;
3420 byte arg1 = (byte) 0 ;
3421 byte arg2 = (byte) 0 ;
3422 byte arg3 = (byte) 0 ;
3423 wxColour *result = 0 ;
3424 unsigned char val1 ;
3425 int ecode1 = 0 ;
3426 unsigned char val2 ;
3427 int ecode2 = 0 ;
3428 unsigned char val3 ;
3429 int ecode3 = 0 ;
3430 PyObject * obj0 = 0 ;
3431 PyObject * obj1 = 0 ;
3432 PyObject * obj2 = 0 ;
3433 char * kwnames[] = {
3434 (char *) "red",(char *) "green",(char *) "blue", NULL
3435 };
3436
3437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3438 if (obj0) {
3439 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
3440 if (!SWIG_IsOK(ecode1)) {
3441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Colour" "', expected argument " "1"" of type '" "byte""'");
3442 }
3443 arg1 = static_cast< byte >(val1);
3444 }
3445 if (obj1) {
3446 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3447 if (!SWIG_IsOK(ecode2)) {
3448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Colour" "', expected argument " "2"" of type '" "byte""'");
3449 }
3450 arg2 = static_cast< byte >(val2);
3451 }
3452 if (obj2) {
3453 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3454 if (!SWIG_IsOK(ecode3)) {
3455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Colour" "', expected argument " "3"" of type '" "byte""'");
3456 }
3457 arg3 = static_cast< byte >(val3);
3458 }
3459 {
3460 PyThreadState* __tstate = wxPyBeginAllowThreads();
3461 result = (wxColour *)new wxColour(arg1,arg2,arg3);
3462 wxPyEndAllowThreads(__tstate);
3463 if (PyErr_Occurred()) SWIG_fail;
3464 }
3465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_NEW | 0 );
3466 return resultobj;
3467 fail:
3468 return NULL;
3469 }
3470
3471
3472 SWIGINTERN PyObject *_wrap_new_NamedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3473 PyObject *resultobj = 0;
3474 wxString *arg1 = 0 ;
3475 wxColour *result = 0 ;
3476 bool temp1 = false ;
3477 PyObject * obj0 = 0 ;
3478 char * kwnames[] = {
3479 (char *) "colorName", NULL
3480 };
3481
3482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) SWIG_fail;
3483 {
3484 arg1 = wxString_in_helper(obj0);
3485 if (arg1 == NULL) SWIG_fail;
3486 temp1 = true;
3487 }
3488 {
3489 if (!wxPyCheckForApp()) SWIG_fail;
3490 PyThreadState* __tstate = wxPyBeginAllowThreads();
3491 result = (wxColour *)new wxColour((wxString const &)*arg1);
3492 wxPyEndAllowThreads(__tstate);
3493 if (PyErr_Occurred()) SWIG_fail;
3494 }
3495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3496 {
3497 if (temp1)
3498 delete arg1;
3499 }
3500 return resultobj;
3501 fail:
3502 {
3503 if (temp1)
3504 delete arg1;
3505 }
3506 return NULL;
3507 }
3508
3509
3510 SWIGINTERN PyObject *_wrap_new_ColourRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3511 PyObject *resultobj = 0;
3512 unsigned long arg1 ;
3513 wxColour *result = 0 ;
3514 unsigned long val1 ;
3515 int ecode1 = 0 ;
3516 PyObject * obj0 = 0 ;
3517 char * kwnames[] = {
3518 (char *) "colRGB", NULL
3519 };
3520
3521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) SWIG_fail;
3522 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
3523 if (!SWIG_IsOK(ecode1)) {
3524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourRGB" "', expected argument " "1"" of type '" "unsigned long""'");
3525 }
3526 arg1 = static_cast< unsigned long >(val1);
3527 {
3528 PyThreadState* __tstate = wxPyBeginAllowThreads();
3529 result = (wxColour *)new wxColour(arg1);
3530 wxPyEndAllowThreads(__tstate);
3531 if (PyErr_Occurred()) SWIG_fail;
3532 }
3533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3534 return resultobj;
3535 fail:
3536 return NULL;
3537 }
3538
3539
3540 SWIGINTERN PyObject *_wrap_delete_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3541 PyObject *resultobj = 0;
3542 wxColour *arg1 = (wxColour *) 0 ;
3543 void *argp1 = 0 ;
3544 int res1 = 0 ;
3545 PyObject *swig_obj[1] ;
3546
3547 if (!args) SWIG_fail;
3548 swig_obj[0] = args;
3549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, SWIG_POINTER_DISOWN | 0 );
3550 if (!SWIG_IsOK(res1)) {
3551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Colour" "', expected argument " "1"" of type '" "wxColour *""'");
3552 }
3553 arg1 = reinterpret_cast< wxColour * >(argp1);
3554 {
3555 PyThreadState* __tstate = wxPyBeginAllowThreads();
3556 delete arg1;
3557
3558 wxPyEndAllowThreads(__tstate);
3559 if (PyErr_Occurred()) SWIG_fail;
3560 }
3561 resultobj = SWIG_Py_Void();
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 SWIGINTERN PyObject *_wrap_Colour_Red(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3569 PyObject *resultobj = 0;
3570 wxColour *arg1 = (wxColour *) 0 ;
3571 byte result;
3572 void *argp1 = 0 ;
3573 int res1 = 0 ;
3574 PyObject *swig_obj[1] ;
3575
3576 if (!args) SWIG_fail;
3577 swig_obj[0] = args;
3578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3579 if (!SWIG_IsOK(res1)) {
3580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Red" "', expected argument " "1"" of type '" "wxColour *""'");
3581 }
3582 arg1 = reinterpret_cast< wxColour * >(argp1);
3583 {
3584 PyThreadState* __tstate = wxPyBeginAllowThreads();
3585 result = (byte)(arg1)->Red();
3586 wxPyEndAllowThreads(__tstate);
3587 if (PyErr_Occurred()) SWIG_fail;
3588 }
3589 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 SWIGINTERN PyObject *_wrap_Colour_Green(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3597 PyObject *resultobj = 0;
3598 wxColour *arg1 = (wxColour *) 0 ;
3599 byte result;
3600 void *argp1 = 0 ;
3601 int res1 = 0 ;
3602 PyObject *swig_obj[1] ;
3603
3604 if (!args) SWIG_fail;
3605 swig_obj[0] = args;
3606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3607 if (!SWIG_IsOK(res1)) {
3608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Green" "', expected argument " "1"" of type '" "wxColour *""'");
3609 }
3610 arg1 = reinterpret_cast< wxColour * >(argp1);
3611 {
3612 PyThreadState* __tstate = wxPyBeginAllowThreads();
3613 result = (byte)(arg1)->Green();
3614 wxPyEndAllowThreads(__tstate);
3615 if (PyErr_Occurred()) SWIG_fail;
3616 }
3617 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3618 return resultobj;
3619 fail:
3620 return NULL;
3621 }
3622
3623
3624 SWIGINTERN PyObject *_wrap_Colour_Blue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3625 PyObject *resultobj = 0;
3626 wxColour *arg1 = (wxColour *) 0 ;
3627 byte result;
3628 void *argp1 = 0 ;
3629 int res1 = 0 ;
3630 PyObject *swig_obj[1] ;
3631
3632 if (!args) SWIG_fail;
3633 swig_obj[0] = args;
3634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3635 if (!SWIG_IsOK(res1)) {
3636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Blue" "', expected argument " "1"" of type '" "wxColour *""'");
3637 }
3638 arg1 = reinterpret_cast< wxColour * >(argp1);
3639 {
3640 PyThreadState* __tstate = wxPyBeginAllowThreads();
3641 result = (byte)(arg1)->Blue();
3642 wxPyEndAllowThreads(__tstate);
3643 if (PyErr_Occurred()) SWIG_fail;
3644 }
3645 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3646 return resultobj;
3647 fail:
3648 return NULL;
3649 }
3650
3651
3652 SWIGINTERN PyObject *_wrap_Colour_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3653 PyObject *resultobj = 0;
3654 wxColour *arg1 = (wxColour *) 0 ;
3655 bool result;
3656 void *argp1 = 0 ;
3657 int res1 = 0 ;
3658 PyObject *swig_obj[1] ;
3659
3660 if (!args) SWIG_fail;
3661 swig_obj[0] = args;
3662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3663 if (!SWIG_IsOK(res1)) {
3664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Ok" "', expected argument " "1"" of type '" "wxColour *""'");
3665 }
3666 arg1 = reinterpret_cast< wxColour * >(argp1);
3667 {
3668 PyThreadState* __tstate = wxPyBeginAllowThreads();
3669 result = (bool)(arg1)->Ok();
3670 wxPyEndAllowThreads(__tstate);
3671 if (PyErr_Occurred()) SWIG_fail;
3672 }
3673 {
3674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3675 }
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 SWIGINTERN PyObject *_wrap_Colour_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj = 0;
3684 wxColour *arg1 = (wxColour *) 0 ;
3685 byte arg2 ;
3686 byte arg3 ;
3687 byte arg4 ;
3688 void *argp1 = 0 ;
3689 int res1 = 0 ;
3690 unsigned char val2 ;
3691 int ecode2 = 0 ;
3692 unsigned char val3 ;
3693 int ecode3 = 0 ;
3694 unsigned char val4 ;
3695 int ecode4 = 0 ;
3696 PyObject * obj0 = 0 ;
3697 PyObject * obj1 = 0 ;
3698 PyObject * obj2 = 0 ;
3699 PyObject * obj3 = 0 ;
3700 char * kwnames[] = {
3701 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
3702 };
3703
3704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3706 if (!SWIG_IsOK(res1)) {
3707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Set" "', expected argument " "1"" of type '" "wxColour *""'");
3708 }
3709 arg1 = reinterpret_cast< wxColour * >(argp1);
3710 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3711 if (!SWIG_IsOK(ecode2)) {
3712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Set" "', expected argument " "2"" of type '" "byte""'");
3713 }
3714 arg2 = static_cast< byte >(val2);
3715 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3716 if (!SWIG_IsOK(ecode3)) {
3717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Colour_Set" "', expected argument " "3"" of type '" "byte""'");
3718 }
3719 arg3 = static_cast< byte >(val3);
3720 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3721 if (!SWIG_IsOK(ecode4)) {
3722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Colour_Set" "', expected argument " "4"" of type '" "byte""'");
3723 }
3724 arg4 = static_cast< byte >(val4);
3725 {
3726 PyThreadState* __tstate = wxPyBeginAllowThreads();
3727 (arg1)->Set(arg2,arg3,arg4);
3728 wxPyEndAllowThreads(__tstate);
3729 if (PyErr_Occurred()) SWIG_fail;
3730 }
3731 resultobj = SWIG_Py_Void();
3732 return resultobj;
3733 fail:
3734 return NULL;
3735 }
3736
3737
3738 SWIGINTERN PyObject *_wrap_Colour_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3739 PyObject *resultobj = 0;
3740 wxColour *arg1 = (wxColour *) 0 ;
3741 unsigned long arg2 ;
3742 void *argp1 = 0 ;
3743 int res1 = 0 ;
3744 unsigned long val2 ;
3745 int ecode2 = 0 ;
3746 PyObject * obj0 = 0 ;
3747 PyObject * obj1 = 0 ;
3748 char * kwnames[] = {
3749 (char *) "self",(char *) "colRGB", NULL
3750 };
3751
3752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
3753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3754 if (!SWIG_IsOK(res1)) {
3755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
3756 }
3757 arg1 = reinterpret_cast< wxColour * >(argp1);
3758 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
3759 if (!SWIG_IsOK(ecode2)) {
3760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_SetRGB" "', expected argument " "2"" of type '" "unsigned long""'");
3761 }
3762 arg2 = static_cast< unsigned long >(val2);
3763 {
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 (arg1)->Set(arg2);
3766 wxPyEndAllowThreads(__tstate);
3767 if (PyErr_Occurred()) SWIG_fail;
3768 }
3769 resultobj = SWIG_Py_Void();
3770 return resultobj;
3771 fail:
3772 return NULL;
3773 }
3774
3775
3776 SWIGINTERN PyObject *_wrap_Colour_SetFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3777 PyObject *resultobj = 0;
3778 wxColour *arg1 = (wxColour *) 0 ;
3779 wxString *arg2 = 0 ;
3780 void *argp1 = 0 ;
3781 int res1 = 0 ;
3782 bool temp2 = false ;
3783 PyObject * obj0 = 0 ;
3784 PyObject * obj1 = 0 ;
3785 char * kwnames[] = {
3786 (char *) "self",(char *) "colourName", NULL
3787 };
3788
3789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) SWIG_fail;
3790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3791 if (!SWIG_IsOK(res1)) {
3792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetFromName" "', expected argument " "1"" of type '" "wxColour *""'");
3793 }
3794 arg1 = reinterpret_cast< wxColour * >(argp1);
3795 {
3796 arg2 = wxString_in_helper(obj1);
3797 if (arg2 == NULL) SWIG_fail;
3798 temp2 = true;
3799 }
3800 {
3801 PyThreadState* __tstate = wxPyBeginAllowThreads();
3802 (arg1)->InitFromName((wxString const &)*arg2);
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 resultobj = SWIG_Py_Void();
3807 {
3808 if (temp2)
3809 delete arg2;
3810 }
3811 return resultobj;
3812 fail:
3813 {
3814 if (temp2)
3815 delete arg2;
3816 }
3817 return NULL;
3818 }
3819
3820
3821 SWIGINTERN PyObject *_wrap_Colour_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3822 PyObject *resultobj = 0;
3823 wxColour *arg1 = (wxColour *) 0 ;
3824 long result;
3825 void *argp1 = 0 ;
3826 int res1 = 0 ;
3827 PyObject *swig_obj[1] ;
3828
3829 if (!args) SWIG_fail;
3830 swig_obj[0] = args;
3831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3832 if (!SWIG_IsOK(res1)) {
3833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetPixel" "', expected argument " "1"" of type '" "wxColour const *""'");
3834 }
3835 arg1 = reinterpret_cast< wxColour * >(argp1);
3836 {
3837 PyThreadState* __tstate = wxPyBeginAllowThreads();
3838 result = (long)((wxColour const *)arg1)->GetPixel();
3839 wxPyEndAllowThreads(__tstate);
3840 if (PyErr_Occurred()) SWIG_fail;
3841 }
3842 resultobj = SWIG_From_long(static_cast< long >(result));
3843 return resultobj;
3844 fail:
3845 return NULL;
3846 }
3847
3848
3849 SWIGINTERN PyObject *_wrap_Colour___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3850 PyObject *resultobj = 0;
3851 wxColour *arg1 = (wxColour *) 0 ;
3852 PyObject *arg2 = (PyObject *) 0 ;
3853 bool result;
3854 void *argp1 = 0 ;
3855 int res1 = 0 ;
3856 PyObject * obj0 = 0 ;
3857 PyObject * obj1 = 0 ;
3858 char * kwnames[] = {
3859 (char *) "self",(char *) "other", NULL
3860 };
3861
3862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
3863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3864 if (!SWIG_IsOK(res1)) {
3865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___eq__" "', expected argument " "1"" of type '" "wxColour *""'");
3866 }
3867 arg1 = reinterpret_cast< wxColour * >(argp1);
3868 arg2 = obj1;
3869 {
3870 result = (bool)wxColour___eq__(arg1,arg2);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 {
3874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3875 }
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 SWIGINTERN PyObject *_wrap_Colour___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj = 0;
3884 wxColour *arg1 = (wxColour *) 0 ;
3885 PyObject *arg2 = (PyObject *) 0 ;
3886 bool result;
3887 void *argp1 = 0 ;
3888 int res1 = 0 ;
3889 PyObject * obj0 = 0 ;
3890 PyObject * obj1 = 0 ;
3891 char * kwnames[] = {
3892 (char *) "self",(char *) "other", NULL
3893 };
3894
3895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
3896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3897 if (!SWIG_IsOK(res1)) {
3898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___ne__" "', expected argument " "1"" of type '" "wxColour *""'");
3899 }
3900 arg1 = reinterpret_cast< wxColour * >(argp1);
3901 arg2 = obj1;
3902 {
3903 result = (bool)wxColour___ne__(arg1,arg2);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 {
3907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3908 }
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 SWIGINTERN PyObject *_wrap_Colour_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3916 PyObject *resultobj = 0;
3917 wxColour *arg1 = (wxColour *) 0 ;
3918 PyObject *result = 0 ;
3919 void *argp1 = 0 ;
3920 int res1 = 0 ;
3921 PyObject *swig_obj[1] ;
3922
3923 if (!args) SWIG_fail;
3924 swig_obj[0] = args;
3925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3926 if (!SWIG_IsOK(res1)) {
3927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Get" "', expected argument " "1"" of type '" "wxColour *""'");
3928 }
3929 arg1 = reinterpret_cast< wxColour * >(argp1);
3930 {
3931 PyThreadState* __tstate = wxPyBeginAllowThreads();
3932 result = (PyObject *)wxColour_Get(arg1);
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 resultobj = result;
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 SWIGINTERN PyObject *_wrap_Colour_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3944 PyObject *resultobj = 0;
3945 wxColour *arg1 = (wxColour *) 0 ;
3946 unsigned long result;
3947 void *argp1 = 0 ;
3948 int res1 = 0 ;
3949 PyObject *swig_obj[1] ;
3950
3951 if (!args) SWIG_fail;
3952 swig_obj[0] = args;
3953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3954 if (!SWIG_IsOK(res1)) {
3955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
3956 }
3957 arg1 = reinterpret_cast< wxColour * >(argp1);
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 result = (unsigned long)wxColour_GetRGB(arg1);
3961 wxPyEndAllowThreads(__tstate);
3962 if (PyErr_Occurred()) SWIG_fail;
3963 }
3964 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 SWIGINTERN PyObject *Colour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3972 PyObject *obj;
3973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3974 SWIG_TypeNewClientData(SWIGTYPE_p_wxColour, SWIG_NewClientData(obj));
3975 return SWIG_Py_Void();
3976 }
3977
3978 SWIGINTERN PyObject *Colour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3979 return SWIG_Python_InitShadowInstance(args);
3980 }
3981
3982 SWIGINTERN PyObject *_wrap_new_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj = 0;
3984 int arg1 ;
3985 unsigned char *arg2 = (unsigned char *) 0 ;
3986 unsigned char *arg3 = (unsigned char *) 0 ;
3987 unsigned char *arg4 = (unsigned char *) 0 ;
3988 wxPalette *result = 0 ;
3989 int val1 ;
3990 int ecode1 = 0 ;
3991 void *argp2 = 0 ;
3992 int res2 = 0 ;
3993 void *argp3 = 0 ;
3994 int res3 = 0 ;
3995 void *argp4 = 0 ;
3996 int res4 = 0 ;
3997 PyObject * obj0 = 0 ;
3998 PyObject * obj1 = 0 ;
3999 PyObject * obj2 = 0 ;
4000 PyObject * obj3 = 0 ;
4001 char * kwnames[] = {
4002 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
4003 };
4004
4005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4006 ecode1 = SWIG_AsVal_int(obj0, &val1);
4007 if (!SWIG_IsOK(ecode1)) {
4008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Palette" "', expected argument " "1"" of type '" "int""'");
4009 }
4010 arg1 = static_cast< int >(val1);
4011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4012 if (!SWIG_IsOK(res2)) {
4013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Palette" "', expected argument " "2"" of type '" "unsigned char const *""'");
4014 }
4015 arg2 = reinterpret_cast< unsigned char * >(argp2);
4016 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
4017 if (!SWIG_IsOK(res3)) {
4018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Palette" "', expected argument " "3"" of type '" "unsigned char const *""'");
4019 }
4020 arg3 = reinterpret_cast< unsigned char * >(argp3);
4021 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
4022 if (!SWIG_IsOK(res4)) {
4023 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Palette" "', expected argument " "4"" of type '" "unsigned char const *""'");
4024 }
4025 arg4 = reinterpret_cast< unsigned char * >(argp4);
4026 {
4027 if (!wxPyCheckForApp()) SWIG_fail;
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
4030 wxPyEndAllowThreads(__tstate);
4031 if (PyErr_Occurred()) SWIG_fail;
4032 }
4033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, SWIG_POINTER_NEW | 0 );
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 SWIGINTERN PyObject *_wrap_delete_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4041 PyObject *resultobj = 0;
4042 wxPalette *arg1 = (wxPalette *) 0 ;
4043 void *argp1 = 0 ;
4044 int res1 = 0 ;
4045 PyObject *swig_obj[1] ;
4046
4047 if (!args) SWIG_fail;
4048 swig_obj[0] = args;
4049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, SWIG_POINTER_DISOWN | 0 );
4050 if (!SWIG_IsOK(res1)) {
4051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Palette" "', expected argument " "1"" of type '" "wxPalette *""'");
4052 }
4053 arg1 = reinterpret_cast< wxPalette * >(argp1);
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 delete arg1;
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 resultobj = SWIG_Py_Void();
4062 return resultobj;
4063 fail:
4064 return NULL;
4065 }
4066
4067
4068 SWIGINTERN PyObject *_wrap_Palette_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj = 0;
4070 wxPalette *arg1 = (wxPalette *) 0 ;
4071 byte arg2 ;
4072 byte arg3 ;
4073 byte arg4 ;
4074 int result;
4075 void *argp1 = 0 ;
4076 int res1 = 0 ;
4077 unsigned char val2 ;
4078 int ecode2 = 0 ;
4079 unsigned char val3 ;
4080 int ecode3 = 0 ;
4081 unsigned char val4 ;
4082 int ecode4 = 0 ;
4083 PyObject * obj0 = 0 ;
4084 PyObject * obj1 = 0 ;
4085 PyObject * obj2 = 0 ;
4086 PyObject * obj3 = 0 ;
4087 char * kwnames[] = {
4088 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
4089 };
4090
4091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4093 if (!SWIG_IsOK(res1)) {
4094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetPixel" "', expected argument " "1"" of type '" "wxPalette *""'");
4095 }
4096 arg1 = reinterpret_cast< wxPalette * >(argp1);
4097 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4098 if (!SWIG_IsOK(ecode2)) {
4099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetPixel" "', expected argument " "2"" of type '" "byte""'");
4100 }
4101 arg2 = static_cast< byte >(val2);
4102 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4103 if (!SWIG_IsOK(ecode3)) {
4104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Palette_GetPixel" "', expected argument " "3"" of type '" "byte""'");
4105 }
4106 arg3 = static_cast< byte >(val3);
4107 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4108 if (!SWIG_IsOK(ecode4)) {
4109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Palette_GetPixel" "', expected argument " "4"" of type '" "byte""'");
4110 }
4111 arg4 = static_cast< byte >(val4);
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_From_int(static_cast< int >(result));
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 SWIGINTERN PyObject *_wrap_Palette_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 wxPalette *arg1 = (wxPalette *) 0 ;
4128 int arg2 ;
4129 byte *arg3 = (byte *) 0 ;
4130 byte *arg4 = (byte *) 0 ;
4131 byte *arg5 = (byte *) 0 ;
4132 bool result;
4133 void *argp1 = 0 ;
4134 int res1 = 0 ;
4135 int val2 ;
4136 int ecode2 = 0 ;
4137 byte temp3 ;
4138 int res3 = SWIG_TMPOBJ ;
4139 byte temp4 ;
4140 int res4 = SWIG_TMPOBJ ;
4141 byte temp5 ;
4142 int res5 = SWIG_TMPOBJ ;
4143 PyObject * obj0 = 0 ;
4144 PyObject * obj1 = 0 ;
4145 char * kwnames[] = {
4146 (char *) "self",(char *) "pixel", NULL
4147 };
4148
4149 arg3 = &temp3;
4150 arg4 = &temp4;
4151 arg5 = &temp5;
4152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4154 if (!SWIG_IsOK(res1)) {
4155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetRGB" "', expected argument " "1"" of type '" "wxPalette *""'");
4156 }
4157 arg1 = reinterpret_cast< wxPalette * >(argp1);
4158 ecode2 = SWIG_AsVal_int(obj1, &val2);
4159 if (!SWIG_IsOK(ecode2)) {
4160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetRGB" "', expected argument " "2"" of type '" "int""'");
4161 }
4162 arg2 = static_cast< int >(val2);
4163 {
4164 PyThreadState* __tstate = wxPyBeginAllowThreads();
4165 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
4166 wxPyEndAllowThreads(__tstate);
4167 if (PyErr_Occurred()) SWIG_fail;
4168 }
4169 {
4170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4171 }
4172 if (SWIG_IsTmpObj(res3)) {
4173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
4174 } else {
4175 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
4177 }
4178 if (SWIG_IsTmpObj(res4)) {
4179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
4180 } else {
4181 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
4183 }
4184 if (SWIG_IsTmpObj(res5)) {
4185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)));
4186 } else {
4187 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags));
4189 }
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 SWIGINTERN PyObject *_wrap_Palette_GetColoursCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4197 PyObject *resultobj = 0;
4198 wxPalette *arg1 = (wxPalette *) 0 ;
4199 int result;
4200 void *argp1 = 0 ;
4201 int res1 = 0 ;
4202 PyObject *swig_obj[1] ;
4203
4204 if (!args) SWIG_fail;
4205 swig_obj[0] = args;
4206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4207 if (!SWIG_IsOK(res1)) {
4208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetColoursCount" "', expected argument " "1"" of type '" "wxPalette const *""'");
4209 }
4210 arg1 = reinterpret_cast< wxPalette * >(argp1);
4211 {
4212 PyThreadState* __tstate = wxPyBeginAllowThreads();
4213 result = (int)((wxPalette const *)arg1)->GetColoursCount();
4214 wxPyEndAllowThreads(__tstate);
4215 if (PyErr_Occurred()) SWIG_fail;
4216 }
4217 resultobj = SWIG_From_int(static_cast< int >(result));
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_Palette_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225 PyObject *resultobj = 0;
4226 wxPalette *arg1 = (wxPalette *) 0 ;
4227 bool result;
4228 void *argp1 = 0 ;
4229 int res1 = 0 ;
4230 PyObject *swig_obj[1] ;
4231
4232 if (!args) SWIG_fail;
4233 swig_obj[0] = args;
4234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4235 if (!SWIG_IsOK(res1)) {
4236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_Ok" "', expected argument " "1"" of type '" "wxPalette *""'");
4237 }
4238 arg1 = reinterpret_cast< wxPalette * >(argp1);
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (bool)(arg1)->Ok();
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 {
4246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4247 }
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 SWIGINTERN PyObject *Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255 PyObject *obj;
4256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4257 SWIG_TypeNewClientData(SWIGTYPE_p_wxPalette, SWIG_NewClientData(obj));
4258 return SWIG_Py_Void();
4259 }
4260
4261 SWIGINTERN PyObject *Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4262 return SWIG_Python_InitShadowInstance(args);
4263 }
4264
4265 SWIGINTERN PyObject *_wrap_new_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4266 PyObject *resultobj = 0;
4267 wxColour *arg1 = 0 ;
4268 int arg2 = (int) 1 ;
4269 int arg3 = (int) wxSOLID ;
4270 wxPen *result = 0 ;
4271 wxColour temp1 ;
4272 int val2 ;
4273 int ecode2 = 0 ;
4274 int val3 ;
4275 int ecode3 = 0 ;
4276 PyObject * obj0 = 0 ;
4277 PyObject * obj1 = 0 ;
4278 PyObject * obj2 = 0 ;
4279 char * kwnames[] = {
4280 (char *) "colour",(char *) "width",(char *) "style", NULL
4281 };
4282
4283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4284 {
4285 arg1 = &temp1;
4286 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4287 }
4288 if (obj1) {
4289 ecode2 = SWIG_AsVal_int(obj1, &val2);
4290 if (!SWIG_IsOK(ecode2)) {
4291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pen" "', expected argument " "2"" of type '" "int""'");
4292 }
4293 arg2 = static_cast< int >(val2);
4294 }
4295 if (obj2) {
4296 ecode3 = SWIG_AsVal_int(obj2, &val3);
4297 if (!SWIG_IsOK(ecode3)) {
4298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pen" "', expected argument " "3"" of type '" "int""'");
4299 }
4300 arg3 = static_cast< int >(val3);
4301 }
4302 {
4303 if (!wxPyCheckForApp()) SWIG_fail;
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, SWIG_POINTER_NEW | 0 );
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *_wrap_delete_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4317 PyObject *resultobj = 0;
4318 wxPen *arg1 = (wxPen *) 0 ;
4319 void *argp1 = 0 ;
4320 int res1 = 0 ;
4321 PyObject *swig_obj[1] ;
4322
4323 if (!args) SWIG_fail;
4324 swig_obj[0] = args;
4325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, SWIG_POINTER_DISOWN | 0 );
4326 if (!SWIG_IsOK(res1)) {
4327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pen" "', expected argument " "1"" of type '" "wxPen *""'");
4328 }
4329 arg1 = reinterpret_cast< wxPen * >(argp1);
4330 {
4331 PyThreadState* __tstate = wxPyBeginAllowThreads();
4332 delete arg1;
4333
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 resultobj = SWIG_Py_Void();
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 SWIGINTERN PyObject *_wrap_Pen_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4345 PyObject *resultobj = 0;
4346 wxPen *arg1 = (wxPen *) 0 ;
4347 int result;
4348 void *argp1 = 0 ;
4349 int res1 = 0 ;
4350 PyObject *swig_obj[1] ;
4351
4352 if (!args) SWIG_fail;
4353 swig_obj[0] = args;
4354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4355 if (!SWIG_IsOK(res1)) {
4356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4357 }
4358 arg1 = reinterpret_cast< wxPen * >(argp1);
4359 {
4360 PyThreadState* __tstate = wxPyBeginAllowThreads();
4361 result = (int)(arg1)->GetCap();
4362 wxPyEndAllowThreads(__tstate);
4363 if (PyErr_Occurred()) SWIG_fail;
4364 }
4365 resultobj = SWIG_From_int(static_cast< int >(result));
4366 return resultobj;
4367 fail:
4368 return NULL;
4369 }
4370
4371
4372 SWIGINTERN PyObject *_wrap_Pen_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4373 PyObject *resultobj = 0;
4374 wxPen *arg1 = (wxPen *) 0 ;
4375 wxColour result;
4376 void *argp1 = 0 ;
4377 int res1 = 0 ;
4378 PyObject *swig_obj[1] ;
4379
4380 if (!args) SWIG_fail;
4381 swig_obj[0] = args;
4382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4383 if (!SWIG_IsOK(res1)) {
4384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4385 }
4386 arg1 = reinterpret_cast< wxPen * >(argp1);
4387 {
4388 PyThreadState* __tstate = wxPyBeginAllowThreads();
4389 result = (arg1)->GetColour();
4390 wxPyEndAllowThreads(__tstate);
4391 if (PyErr_Occurred()) SWIG_fail;
4392 }
4393 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 SWIGINTERN PyObject *_wrap_Pen_GetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4401 PyObject *resultobj = 0;
4402 wxPen *arg1 = (wxPen *) 0 ;
4403 int result;
4404 void *argp1 = 0 ;
4405 int res1 = 0 ;
4406 PyObject *swig_obj[1] ;
4407
4408 if (!args) SWIG_fail;
4409 swig_obj[0] = args;
4410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4411 if (!SWIG_IsOK(res1)) {
4412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4413 }
4414 arg1 = reinterpret_cast< wxPen * >(argp1);
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 result = (int)(arg1)->GetJoin();
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_From_int(static_cast< int >(result));
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_Pen_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4429 PyObject *resultobj = 0;
4430 wxPen *arg1 = (wxPen *) 0 ;
4431 int result;
4432 void *argp1 = 0 ;
4433 int res1 = 0 ;
4434 PyObject *swig_obj[1] ;
4435
4436 if (!args) SWIG_fail;
4437 swig_obj[0] = args;
4438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4439 if (!SWIG_IsOK(res1)) {
4440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4441 }
4442 arg1 = reinterpret_cast< wxPen * >(argp1);
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = (int)(arg1)->GetStyle();
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 resultobj = SWIG_From_int(static_cast< int >(result));
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_Pen_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxPen *arg1 = (wxPen *) 0 ;
4459 int result;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 PyObject *swig_obj[1] ;
4463
4464 if (!args) SWIG_fail;
4465 swig_obj[0] = args;
4466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4467 if (!SWIG_IsOK(res1)) {
4468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4469 }
4470 arg1 = reinterpret_cast< wxPen * >(argp1);
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = (int)(arg1)->GetWidth();
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 resultobj = SWIG_From_int(static_cast< int >(result));
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 SWIGINTERN PyObject *_wrap_Pen_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4485 PyObject *resultobj = 0;
4486 wxPen *arg1 = (wxPen *) 0 ;
4487 bool result;
4488 void *argp1 = 0 ;
4489 int res1 = 0 ;
4490 PyObject *swig_obj[1] ;
4491
4492 if (!args) SWIG_fail;
4493 swig_obj[0] = args;
4494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4495 if (!SWIG_IsOK(res1)) {
4496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_Ok" "', expected argument " "1"" of type '" "wxPen *""'");
4497 }
4498 arg1 = reinterpret_cast< wxPen * >(argp1);
4499 {
4500 PyThreadState* __tstate = wxPyBeginAllowThreads();
4501 result = (bool)(arg1)->Ok();
4502 wxPyEndAllowThreads(__tstate);
4503 if (PyErr_Occurred()) SWIG_fail;
4504 }
4505 {
4506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4507 }
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Pen_SetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4515 PyObject *resultobj = 0;
4516 wxPen *arg1 = (wxPen *) 0 ;
4517 int arg2 ;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 int val2 ;
4521 int ecode2 = 0 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char * kwnames[] = {
4525 (char *) "self",(char *) "cap_style", NULL
4526 };
4527
4528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4532 }
4533 arg1 = reinterpret_cast< wxPen * >(argp1);
4534 ecode2 = SWIG_AsVal_int(obj1, &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetCap" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 {
4540 PyThreadState* __tstate = wxPyBeginAllowThreads();
4541 (arg1)->SetCap(arg2);
4542 wxPyEndAllowThreads(__tstate);
4543 if (PyErr_Occurred()) SWIG_fail;
4544 }
4545 resultobj = SWIG_Py_Void();
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 SWIGINTERN PyObject *_wrap_Pen_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj = 0;
4554 wxPen *arg1 = (wxPen *) 0 ;
4555 wxColour *arg2 = 0 ;
4556 void *argp1 = 0 ;
4557 int res1 = 0 ;
4558 wxColour temp2 ;
4559 PyObject * obj0 = 0 ;
4560 PyObject * obj1 = 0 ;
4561 char * kwnames[] = {
4562 (char *) "self",(char *) "colour", NULL
4563 };
4564
4565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
4566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4567 if (!SWIG_IsOK(res1)) {
4568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4569 }
4570 arg1 = reinterpret_cast< wxPen * >(argp1);
4571 {
4572 arg2 = &temp2;
4573 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4574 }
4575 {
4576 PyThreadState* __tstate = wxPyBeginAllowThreads();
4577 (arg1)->SetColour(*arg2);
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 resultobj = SWIG_Py_Void();
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_Pen_SetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj = 0;
4590 wxPen *arg1 = (wxPen *) 0 ;
4591 int arg2 ;
4592 void *argp1 = 0 ;
4593 int res1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "self",(char *) "join_style", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) SWIG_fail;
4603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4606 }
4607 arg1 = reinterpret_cast< wxPen * >(argp1);
4608 ecode2 = SWIG_AsVal_int(obj1, &val2);
4609 if (!SWIG_IsOK(ecode2)) {
4610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetJoin" "', expected argument " "2"" of type '" "int""'");
4611 }
4612 arg2 = static_cast< int >(val2);
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 (arg1)->SetJoin(arg2);
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_Py_Void();
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_Pen_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj = 0;
4628 wxPen *arg1 = (wxPen *) 0 ;
4629 int arg2 ;
4630 void *argp1 = 0 ;
4631 int res1 = 0 ;
4632 int val2 ;
4633 int ecode2 = 0 ;
4634 PyObject * obj0 = 0 ;
4635 PyObject * obj1 = 0 ;
4636 char * kwnames[] = {
4637 (char *) "self",(char *) "style", NULL
4638 };
4639
4640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
4641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4644 }
4645 arg1 = reinterpret_cast< wxPen * >(argp1);
4646 ecode2 = SWIG_AsVal_int(obj1, &val2);
4647 if (!SWIG_IsOK(ecode2)) {
4648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetStyle" "', expected argument " "2"" of type '" "int""'");
4649 }
4650 arg2 = static_cast< int >(val2);
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 (arg1)->SetStyle(arg2);
4654 wxPyEndAllowThreads(__tstate);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 resultobj = SWIG_Py_Void();
4658 return resultobj;
4659 fail:
4660 return NULL;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_Pen_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4665 PyObject *resultobj = 0;
4666 wxPen *arg1 = (wxPen *) 0 ;
4667 int arg2 ;
4668 void *argp1 = 0 ;
4669 int res1 = 0 ;
4670 int val2 ;
4671 int ecode2 = 0 ;
4672 PyObject * obj0 = 0 ;
4673 PyObject * obj1 = 0 ;
4674 char * kwnames[] = {
4675 (char *) "self",(char *) "width", NULL
4676 };
4677
4678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4680 if (!SWIG_IsOK(res1)) {
4681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4682 }
4683 arg1 = reinterpret_cast< wxPen * >(argp1);
4684 ecode2 = SWIG_AsVal_int(obj1, &val2);
4685 if (!SWIG_IsOK(ecode2)) {
4686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetWidth" "', expected argument " "2"" of type '" "int""'");
4687 }
4688 arg2 = static_cast< int >(val2);
4689 {
4690 PyThreadState* __tstate = wxPyBeginAllowThreads();
4691 (arg1)->SetWidth(arg2);
4692 wxPyEndAllowThreads(__tstate);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 resultobj = SWIG_Py_Void();
4696 return resultobj;
4697 fail:
4698 return NULL;
4699 }
4700
4701
4702 SWIGINTERN PyObject *_wrap_Pen_SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4703 PyObject *resultobj = 0;
4704 wxPen *arg1 = (wxPen *) 0 ;
4705 int arg2 ;
4706 wxDash *arg3 = (wxDash *) 0 ;
4707 void *argp1 = 0 ;
4708 int res1 = 0 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 char * kwnames[] = {
4712 (char *) "self",(char *) "dashes", NULL
4713 };
4714
4715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) SWIG_fail;
4716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4717 if (!SWIG_IsOK(res1)) {
4718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4719 }
4720 arg1 = reinterpret_cast< wxPen * >(argp1);
4721 {
4722 arg2 = PyList_Size(obj1);
4723 arg3 = (wxDash*)byte_LIST_helper(obj1);
4724 if (arg3 == NULL) SWIG_fail;
4725 }
4726 {
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 (arg1)->SetDashes(arg2,arg3);
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 resultobj = SWIG_Py_Void();
4733 {
4734 if (arg3) delete [] arg3;
4735 }
4736 return resultobj;
4737 fail:
4738 {
4739 if (arg3) delete [] arg3;
4740 }
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Pen_GetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4746 PyObject *resultobj = 0;
4747 wxPen *arg1 = (wxPen *) 0 ;
4748 PyObject *result = 0 ;
4749 void *argp1 = 0 ;
4750 int res1 = 0 ;
4751 PyObject *swig_obj[1] ;
4752
4753 if (!args) SWIG_fail;
4754 swig_obj[0] = args;
4755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4758 }
4759 arg1 = reinterpret_cast< wxPen * >(argp1);
4760 {
4761 PyThreadState* __tstate = wxPyBeginAllowThreads();
4762 result = (PyObject *)wxPen_GetDashes(arg1);
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = result;
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_Pen__SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 wxPen *arg1 = (wxPen *) 0 ;
4776 PyObject *arg2 = (PyObject *) 0 ;
4777 PyObject *arg3 = (PyObject *) 0 ;
4778 void *argp1 = 0 ;
4779 int res1 = 0 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 PyObject * obj2 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen__SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4791 }
4792 arg1 = reinterpret_cast< wxPen * >(argp1);
4793 arg2 = obj1;
4794 arg3 = obj2;
4795 {
4796 PyThreadState* __tstate = wxPyBeginAllowThreads();
4797 wxPen__SetDashes(arg1,arg2,arg3);
4798 wxPyEndAllowThreads(__tstate);
4799 if (PyErr_Occurred()) SWIG_fail;
4800 }
4801 resultobj = SWIG_Py_Void();
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 SWIGINTERN PyObject *_wrap_Pen___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj = 0;
4810 wxPen *arg1 = (wxPen *) 0 ;
4811 wxPen *arg2 = (wxPen *) 0 ;
4812 bool result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 void *argp2 = 0 ;
4816 int res2 = 0 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "other", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___eq__" "', expected argument " "1"" of type '" "wxPen *""'");
4827 }
4828 arg1 = reinterpret_cast< wxPen * >(argp1);
4829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
4830 if (!SWIG_IsOK(res2)) {
4831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___eq__" "', expected argument " "2"" of type '" "wxPen const *""'");
4832 }
4833 arg2 = reinterpret_cast< wxPen * >(argp2);
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Pen___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxPen *arg1 = (wxPen *) 0 ;
4852 wxPen *arg2 = (wxPen *) 0 ;
4853 bool result;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 void *argp2 = 0 ;
4857 int res2 = 0 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "self",(char *) "other", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4866 if (!SWIG_IsOK(res1)) {
4867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___ne__" "', expected argument " "1"" of type '" "wxPen *""'");
4868 }
4869 arg1 = reinterpret_cast< wxPen * >(argp1);
4870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
4871 if (!SWIG_IsOK(res2)) {
4872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___ne__" "', expected argument " "2"" of type '" "wxPen const *""'");
4873 }
4874 arg2 = reinterpret_cast< wxPen * >(argp2);
4875 {
4876 PyThreadState* __tstate = wxPyBeginAllowThreads();
4877 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
4878 wxPyEndAllowThreads(__tstate);
4879 if (PyErr_Occurred()) SWIG_fail;
4880 }
4881 {
4882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4883 }
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 SWIGINTERN PyObject *Pen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4891 PyObject *obj;
4892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPen, SWIG_NewClientData(obj));
4894 return SWIG_Py_Void();
4895 }
4896
4897 SWIGINTERN PyObject *Pen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4898 return SWIG_Python_InitShadowInstance(args);
4899 }
4900
4901 SWIGINTERN PyObject *_wrap_new_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxColour *arg1 = 0 ;
4904 int arg2 = (int) wxSOLID ;
4905 wxBrush *result = 0 ;
4906 wxColour temp1 ;
4907 int val2 ;
4908 int ecode2 = 0 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "colour",(char *) "style", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) SWIG_fail;
4916 {
4917 arg1 = &temp1;
4918 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4919 }
4920 if (obj1) {
4921 ecode2 = SWIG_AsVal_int(obj1, &val2);
4922 if (!SWIG_IsOK(ecode2)) {
4923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Brush" "', expected argument " "2"" of type '" "int""'");
4924 }
4925 arg2 = static_cast< int >(val2);
4926 }
4927 {
4928 if (!wxPyCheckForApp()) SWIG_fail;
4929 PyThreadState* __tstate = wxPyBeginAllowThreads();
4930 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
4931 wxPyEndAllowThreads(__tstate);
4932 if (PyErr_Occurred()) SWIG_fail;
4933 }
4934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_NEW | 0 );
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_new_BrushFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj = 0;
4943 wxBitmap *arg1 = 0 ;
4944 wxBrush *result = 0 ;
4945 void *argp1 = 0 ;
4946 int res1 = 0 ;
4947 PyObject * obj0 = 0 ;
4948 char * kwnames[] = {
4949 (char *) "stippleBitmap", NULL
4950 };
4951
4952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) SWIG_fail;
4953 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
4954 if (!SWIG_IsOK(res1)) {
4955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
4956 }
4957 if (!argp1) {
4958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
4959 }
4960 arg1 = reinterpret_cast< wxBitmap * >(argp1);
4961 {
4962 if (!wxPyCheckForApp()) SWIG_fail;
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_OWN | 0 );
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_delete_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977 wxBrush *arg1 = (wxBrush *) 0 ;
4978 void *argp1 = 0 ;
4979 int res1 = 0 ;
4980 PyObject *swig_obj[1] ;
4981
4982 if (!args) SWIG_fail;
4983 swig_obj[0] = args;
4984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, SWIG_POINTER_DISOWN | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brush" "', expected argument " "1"" of type '" "wxBrush *""'");
4987 }
4988 arg1 = reinterpret_cast< wxBrush * >(argp1);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 delete arg1;
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 resultobj = SWIG_Py_Void();
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_Brush_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = 0;
5005 wxBrush *arg1 = (wxBrush *) 0 ;
5006 wxColour *arg2 = 0 ;
5007 void *argp1 = 0 ;
5008 int res1 = 0 ;
5009 wxColour temp2 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "col", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetColour" "', expected argument " "1"" of type '" "wxBrush *""'");
5020 }
5021 arg1 = reinterpret_cast< wxBrush * >(argp1);
5022 {
5023 arg2 = &temp2;
5024 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetColour((wxColour const &)*arg2);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_Py_Void();
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Brush_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj = 0;
5041 wxBrush *arg1 = (wxBrush *) 0 ;
5042 int arg2 ;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 int val2 ;
5046 int ecode2 = 0 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 char * kwnames[] = {
5050 (char *) "self",(char *) "style", NULL
5051 };
5052
5053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5055 if (!SWIG_IsOK(res1)) {
5056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStyle" "', expected argument " "1"" of type '" "wxBrush *""'");
5057 }
5058 arg1 = reinterpret_cast< wxBrush * >(argp1);
5059 ecode2 = SWIG_AsVal_int(obj1, &val2);
5060 if (!SWIG_IsOK(ecode2)) {
5061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_SetStyle" "', expected argument " "2"" of type '" "int""'");
5062 }
5063 arg2 = static_cast< int >(val2);
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 (arg1)->SetStyle(arg2);
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_Py_Void();
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_Brush_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj = 0;
5079 wxBrush *arg1 = (wxBrush *) 0 ;
5080 wxBitmap *arg2 = 0 ;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 void *argp2 = 0 ;
5084 int res2 = 0 ;
5085 PyObject * obj0 = 0 ;
5086 PyObject * obj1 = 0 ;
5087 char * kwnames[] = {
5088 (char *) "self",(char *) "stipple", NULL
5089 };
5090
5091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5093 if (!SWIG_IsOK(res1)) {
5094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStipple" "', expected argument " "1"" of type '" "wxBrush *""'");
5095 }
5096 arg1 = reinterpret_cast< wxBrush * >(argp1);
5097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
5098 if (!SWIG_IsOK(res2)) {
5099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5100 }
5101 if (!argp2) {
5102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5103 }
5104 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 (arg1)->SetStipple((wxBitmap const &)*arg2);
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 resultobj = SWIG_Py_Void();
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 SWIGINTERN PyObject *_wrap_Brush_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *resultobj = 0;
5120 wxBrush *arg1 = (wxBrush *) 0 ;
5121 wxColour result;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 PyObject *swig_obj[1] ;
5125
5126 if (!args) SWIG_fail;
5127 swig_obj[0] = args;
5128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetColour" "', expected argument " "1"" of type '" "wxBrush const *""'");
5131 }
5132 arg1 = reinterpret_cast< wxBrush * >(argp1);
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = ((wxBrush const *)arg1)->GetColour();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Brush_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxBrush *arg1 = (wxBrush *) 0 ;
5149 int result;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStyle" "', expected argument " "1"" of type '" "wxBrush const *""'");
5159 }
5160 arg1 = reinterpret_cast< wxBrush * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (int)((wxBrush const *)arg1)->GetStyle();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = SWIG_From_int(static_cast< int >(result));
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *_wrap_Brush_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *resultobj = 0;
5176 wxBrush *arg1 = (wxBrush *) 0 ;
5177 wxBitmap *result = 0 ;
5178 void *argp1 = 0 ;
5179 int res1 = 0 ;
5180 PyObject *swig_obj[1] ;
5181
5182 if (!args) SWIG_fail;
5183 swig_obj[0] = args;
5184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5185 if (!SWIG_IsOK(res1)) {
5186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStipple" "', expected argument " "1"" of type '" "wxBrush const *""'");
5187 }
5188 arg1 = reinterpret_cast< wxBrush * >(argp1);
5189 {
5190 PyThreadState* __tstate = wxPyBeginAllowThreads();
5191 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
5192 wxPyEndAllowThreads(__tstate);
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
5202 SWIGINTERN PyObject *_wrap_Brush_IsHatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *resultobj = 0;
5204 wxBrush *arg1 = (wxBrush *) 0 ;
5205 bool result;
5206 void *argp1 = 0 ;
5207 int res1 = 0 ;
5208 PyObject *swig_obj[1] ;
5209
5210 if (!args) SWIG_fail;
5211 swig_obj[0] = args;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_IsHatch" "', expected argument " "1"" of type '" "wxBrush const *""'");
5215 }
5216 arg1 = reinterpret_cast< wxBrush * >(argp1);
5217 {
5218 PyThreadState* __tstate = wxPyBeginAllowThreads();
5219 result = (bool)((wxBrush const *)arg1)->IsHatch();
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 {
5224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5225 }
5226 return resultobj;
5227 fail:
5228 return NULL;
5229 }
5230
5231
5232 SWIGINTERN PyObject *_wrap_Brush_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5233 PyObject *resultobj = 0;
5234 wxBrush *arg1 = (wxBrush *) 0 ;
5235 bool result;
5236 void *argp1 = 0 ;
5237 int res1 = 0 ;
5238 PyObject *swig_obj[1] ;
5239
5240 if (!args) SWIG_fail;
5241 swig_obj[0] = args;
5242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5243 if (!SWIG_IsOK(res1)) {
5244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_Ok" "', expected argument " "1"" of type '" "wxBrush *""'");
5245 }
5246 arg1 = reinterpret_cast< wxBrush * >(argp1);
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 result = (bool)(arg1)->Ok();
5250 wxPyEndAllowThreads(__tstate);
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 {
5254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_Brush_MacGetTheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5263 PyObject *resultobj = 0;
5264 wxBrush *arg1 = (wxBrush *) 0 ;
5265 short result;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 PyObject *swig_obj[1] ;
5269
5270 if (!args) SWIG_fail;
5271 swig_obj[0] = args;
5272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5273 if (!SWIG_IsOK(res1)) {
5274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_MacGetTheme" "', expected argument " "1"" of type '" "wxBrush *""'");
5275 }
5276 arg1 = reinterpret_cast< wxBrush * >(argp1);
5277 {
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 result = (short)(arg1)->MacGetTheme();
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 resultobj = SWIG_From_short(static_cast< short >(result));
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 SWIGINTERN PyObject *_wrap_Brush_MacSetTheme(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5291 PyObject *resultobj = 0;
5292 wxBrush *arg1 = (wxBrush *) 0 ;
5293 short arg2 ;
5294 void *argp1 = 0 ;
5295 int res1 = 0 ;
5296 short val2 ;
5297 int ecode2 = 0 ;
5298 PyObject * obj0 = 0 ;
5299 PyObject * obj1 = 0 ;
5300 char * kwnames[] = {
5301 (char *) "self",(char *) "macThemeBrush", NULL
5302 };
5303
5304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) SWIG_fail;
5305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_MacSetTheme" "', expected argument " "1"" of type '" "wxBrush *""'");
5308 }
5309 arg1 = reinterpret_cast< wxBrush * >(argp1);
5310 ecode2 = SWIG_AsVal_short(obj1, &val2);
5311 if (!SWIG_IsOK(ecode2)) {
5312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_MacSetTheme" "', expected argument " "2"" of type '" "short""'");
5313 }
5314 arg2 = static_cast< short >(val2);
5315 {
5316 PyThreadState* __tstate = wxPyBeginAllowThreads();
5317 (arg1)->MacSetTheme(arg2);
5318 wxPyEndAllowThreads(__tstate);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 resultobj = SWIG_Py_Void();
5322 return resultobj;
5323 fail:
5324 return NULL;
5325 }
5326
5327
5328 SWIGINTERN PyObject *Brush_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5329 PyObject *obj;
5330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5331 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrush, SWIG_NewClientData(obj));
5332 return SWIG_Py_Void();
5333 }
5334
5335 SWIGINTERN PyObject *Brush_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 return SWIG_Python_InitShadowInstance(args);
5337 }
5338
5339 SWIGINTERN PyObject *_wrap_new_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5340 PyObject *resultobj = 0;
5341 wxString *arg1 = 0 ;
5342 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
5343 wxBitmap *result = 0 ;
5344 bool temp1 = false ;
5345 int val2 ;
5346 int ecode2 = 0 ;
5347 PyObject * obj0 = 0 ;
5348 PyObject * obj1 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "name",(char *) "type", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5354 {
5355 arg1 = wxString_in_helper(obj0);
5356 if (arg1 == NULL) SWIG_fail;
5357 temp1 = true;
5358 }
5359 if (obj1) {
5360 ecode2 = SWIG_AsVal_int(obj1, &val2);
5361 if (!SWIG_IsOK(ecode2)) {
5362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Bitmap" "', expected argument " "2"" of type '" "wxBitmapType""'");
5363 }
5364 arg2 = static_cast< wxBitmapType >(val2);
5365 }
5366 {
5367 if (!wxPyCheckForApp()) SWIG_fail;
5368 PyThreadState* __tstate = wxPyBeginAllowThreads();
5369 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,arg2);
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_NEW | 0 );
5374 {
5375 if (temp1)
5376 delete arg1;
5377 }
5378 return resultobj;
5379 fail:
5380 {
5381 if (temp1)
5382 delete arg1;
5383 }
5384 return NULL;
5385 }
5386
5387
5388 SWIGINTERN PyObject *_wrap_delete_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5389 PyObject *resultobj = 0;
5390 wxBitmap *arg1 = (wxBitmap *) 0 ;
5391 void *argp1 = 0 ;
5392 int res1 = 0 ;
5393 PyObject *swig_obj[1] ;
5394
5395 if (!args) SWIG_fail;
5396 swig_obj[0] = args;
5397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, SWIG_POINTER_DISOWN | 0 );
5398 if (!SWIG_IsOK(res1)) {
5399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bitmap" "', expected argument " "1"" of type '" "wxBitmap *""'");
5400 }
5401 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 delete arg1;
5405
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 resultobj = SWIG_Py_Void();
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_new_EmptyBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj = 0;
5418 int arg1 ;
5419 int arg2 ;
5420 int arg3 = (int) -1 ;
5421 wxBitmap *result = 0 ;
5422 int val1 ;
5423 int ecode1 = 0 ;
5424 int val2 ;
5425 int ecode2 = 0 ;
5426 int val3 ;
5427 int ecode3 = 0 ;
5428 PyObject * obj0 = 0 ;
5429 PyObject * obj1 = 0 ;
5430 PyObject * obj2 = 0 ;
5431 char * kwnames[] = {
5432 (char *) "width",(char *) "height",(char *) "depth", NULL
5433 };
5434
5435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5436 ecode1 = SWIG_AsVal_int(obj0, &val1);
5437 if (!SWIG_IsOK(ecode1)) {
5438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyBitmap" "', expected argument " "1"" of type '" "int""'");
5439 }
5440 arg1 = static_cast< int >(val1);
5441 ecode2 = SWIG_AsVal_int(obj1, &val2);
5442 if (!SWIG_IsOK(ecode2)) {
5443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyBitmap" "', expected argument " "2"" of type '" "int""'");
5444 }
5445 arg2 = static_cast< int >(val2);
5446 if (obj2) {
5447 ecode3 = SWIG_AsVal_int(obj2, &val3);
5448 if (!SWIG_IsOK(ecode3)) {
5449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyBitmap" "', expected argument " "3"" of type '" "int""'");
5450 }
5451 arg3 = static_cast< int >(val3);
5452 }
5453 {
5454 if (!wxPyCheckForApp()) SWIG_fail;
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
5457 wxPyEndAllowThreads(__tstate);
5458 if (PyErr_Occurred()) SWIG_fail;
5459 }
5460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5461 return resultobj;
5462 fail:
5463 return NULL;
5464 }
5465
5466
5467 SWIGINTERN PyObject *_wrap_new_BitmapFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj = 0;
5469 wxIcon *arg1 = 0 ;
5470 wxBitmap *result = 0 ;
5471 void *argp1 = 0 ;
5472 int res1 = 0 ;
5473 PyObject * obj0 = 0 ;
5474 char * kwnames[] = {
5475 (char *) "icon", NULL
5476 };
5477
5478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) SWIG_fail;
5479 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
5480 if (!SWIG_IsOK(res1)) {
5481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5482 }
5483 if (!argp1) {
5484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5485 }
5486 arg1 = reinterpret_cast< wxIcon * >(argp1);
5487 {
5488 if (!wxPyCheckForApp()) SWIG_fail;
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
5491 wxPyEndAllowThreads(__tstate);
5492 if (PyErr_Occurred()) SWIG_fail;
5493 }
5494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5495 return resultobj;
5496 fail:
5497 return NULL;
5498 }
5499
5500
5501 SWIGINTERN PyObject *_wrap_new_BitmapFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5502 PyObject *resultobj = 0;
5503 wxImage *arg1 = 0 ;
5504 int arg2 = (int) -1 ;
5505 wxBitmap *result = 0 ;
5506 void *argp1 = 0 ;
5507 int res1 = 0 ;
5508 int val2 ;
5509 int ecode2 = 0 ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 char * kwnames[] = {
5513 (char *) "image",(char *) "depth", NULL
5514 };
5515
5516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) SWIG_fail;
5517 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
5518 if (!SWIG_IsOK(res1)) {
5519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5520 }
5521 if (!argp1) {
5522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5523 }
5524 arg1 = reinterpret_cast< wxImage * >(argp1);
5525 if (obj1) {
5526 ecode2 = SWIG_AsVal_int(obj1, &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromImage" "', expected argument " "2"" of type '" "int""'");
5529 }
5530 arg2 = static_cast< int >(val2);
5531 }
5532 {
5533 if (!wxPyCheckForApp()) SWIG_fail;
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
5536 wxPyEndAllowThreads(__tstate);
5537 if (PyErr_Occurred()) SWIG_fail;
5538 }
5539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 SWIGINTERN PyObject *_wrap_new_BitmapFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj = 0;
5548 PyObject *arg1 = (PyObject *) 0 ;
5549 wxBitmap *result = 0 ;
5550 PyObject * obj0 = 0 ;
5551 char * kwnames[] = {
5552 (char *) "listOfStrings", NULL
5553 };
5554
5555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) SWIG_fail;
5556 arg1 = obj0;
5557 {
5558 if (!wxPyCheckForApp()) SWIG_fail;
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 result = (wxBitmap *)new_wxBitmap(arg1);
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5565 return resultobj;
5566 fail:
5567 return NULL;
5568 }
5569
5570
5571 SWIGINTERN PyObject *_wrap_new_BitmapFromBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj = 0;
5573 PyObject *arg1 = (PyObject *) 0 ;
5574 int arg2 ;
5575 int arg3 ;
5576 int arg4 = (int) 1 ;
5577 wxBitmap *result = 0 ;
5578 int val2 ;
5579 int ecode2 = 0 ;
5580 int val3 ;
5581 int ecode3 = 0 ;
5582 int val4 ;
5583 int ecode4 = 0 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 PyObject * obj2 = 0 ;
5587 PyObject * obj3 = 0 ;
5588 char * kwnames[] = {
5589 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
5590 };
5591
5592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5593 arg1 = obj0;
5594 ecode2 = SWIG_AsVal_int(obj1, &val2);
5595 if (!SWIG_IsOK(ecode2)) {
5596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromBits" "', expected argument " "2"" of type '" "int""'");
5597 }
5598 arg2 = static_cast< int >(val2);
5599 ecode3 = SWIG_AsVal_int(obj2, &val3);
5600 if (!SWIG_IsOK(ecode3)) {
5601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BitmapFromBits" "', expected argument " "3"" of type '" "int""'");
5602 }
5603 arg3 = static_cast< int >(val3);
5604 if (obj3) {
5605 ecode4 = SWIG_AsVal_int(obj3, &val4);
5606 if (!SWIG_IsOK(ecode4)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BitmapFromBits" "', expected argument " "4"" of type '" "int""'");
5608 }
5609 arg4 = static_cast< int >(val4);
5610 }
5611 {
5612 if (!wxPyCheckForApp()) SWIG_fail;
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
5615 wxPyEndAllowThreads(__tstate);
5616 if (PyErr_Occurred()) SWIG_fail;
5617 }
5618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 SWIGINTERN PyObject *_wrap_Bitmap_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5626 PyObject *resultobj = 0;
5627 wxBitmap *arg1 = (wxBitmap *) 0 ;
5628 bool result;
5629 void *argp1 = 0 ;
5630 int res1 = 0 ;
5631 PyObject *swig_obj[1] ;
5632
5633 if (!args) SWIG_fail;
5634 swig_obj[0] = args;
5635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5636 if (!SWIG_IsOK(res1)) {
5637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_Ok" "', expected argument " "1"" of type '" "wxBitmap *""'");
5638 }
5639 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5640 {
5641 PyThreadState* __tstate = wxPyBeginAllowThreads();
5642 result = (bool)(arg1)->Ok();
5643 wxPyEndAllowThreads(__tstate);
5644 if (PyErr_Occurred()) SWIG_fail;
5645 }
5646 {
5647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5648 }
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 SWIGINTERN PyObject *_wrap_Bitmap_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5656 PyObject *resultobj = 0;
5657 wxBitmap *arg1 = (wxBitmap *) 0 ;
5658 int result;
5659 void *argp1 = 0 ;
5660 int res1 = 0 ;
5661 PyObject *swig_obj[1] ;
5662
5663 if (!args) SWIG_fail;
5664 swig_obj[0] = args;
5665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5666 if (!SWIG_IsOK(res1)) {
5667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
5668 }
5669 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5670 {
5671 PyThreadState* __tstate = wxPyBeginAllowThreads();
5672 result = (int)(arg1)->GetWidth();
5673 wxPyEndAllowThreads(__tstate);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 resultobj = SWIG_From_int(static_cast< int >(result));
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 SWIGINTERN PyObject *_wrap_Bitmap_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5684 PyObject *resultobj = 0;
5685 wxBitmap *arg1 = (wxBitmap *) 0 ;
5686 int result;
5687 void *argp1 = 0 ;
5688 int res1 = 0 ;
5689 PyObject *swig_obj[1] ;
5690
5691 if (!args) SWIG_fail;
5692 swig_obj[0] = args;
5693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
5696 }
5697 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 result = (int)(arg1)->GetHeight();
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 resultobj = SWIG_From_int(static_cast< int >(result));
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 SWIGINTERN PyObject *_wrap_Bitmap_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5712 PyObject *resultobj = 0;
5713 wxBitmap *arg1 = (wxBitmap *) 0 ;
5714 int result;
5715 void *argp1 = 0 ;
5716 int res1 = 0 ;
5717 PyObject *swig_obj[1] ;
5718
5719 if (!args) SWIG_fail;
5720 swig_obj[0] = args;
5721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5722 if (!SWIG_IsOK(res1)) {
5723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
5724 }
5725 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 result = (int)(arg1)->GetDepth();
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 resultobj = SWIG_From_int(static_cast< int >(result));
5733 return resultobj;
5734 fail:
5735 return NULL;
5736 }
5737
5738
5739 SWIGINTERN PyObject *_wrap_Bitmap_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5740 PyObject *resultobj = 0;
5741 wxBitmap *arg1 = (wxBitmap *) 0 ;
5742 wxSize result;
5743 void *argp1 = 0 ;
5744 int res1 = 0 ;
5745 PyObject *swig_obj[1] ;
5746
5747 if (!args) SWIG_fail;
5748 swig_obj[0] = args;
5749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5750 if (!SWIG_IsOK(res1)) {
5751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
5752 }
5753 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5754 {
5755 PyThreadState* __tstate = wxPyBeginAllowThreads();
5756 result = wxBitmap_GetSize(arg1);
5757 wxPyEndAllowThreads(__tstate);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 SWIGINTERN PyObject *_wrap_Bitmap_ConvertToImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5768 PyObject *resultobj = 0;
5769 wxBitmap *arg1 = (wxBitmap *) 0 ;
5770 SwigValueWrapper<wxImage > result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject *swig_obj[1] ;
5774
5775 if (!args) SWIG_fail;
5776 swig_obj[0] = args;
5777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5778 if (!SWIG_IsOK(res1)) {
5779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_ConvertToImage" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5780 }
5781 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5782 {
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 result = ((wxBitmap const *)arg1)->ConvertToImage();
5785 wxPyEndAllowThreads(__tstate);
5786 if (PyErr_Occurred()) SWIG_fail;
5787 }
5788 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
5789 return resultobj;
5790 fail:
5791 return NULL;
5792 }
5793
5794
5795 SWIGINTERN PyObject *_wrap_Bitmap_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5796 PyObject *resultobj = 0;
5797 wxBitmap *arg1 = (wxBitmap *) 0 ;
5798 wxMask *result = 0 ;
5799 void *argp1 = 0 ;
5800 int res1 = 0 ;
5801 PyObject *swig_obj[1] ;
5802
5803 if (!args) SWIG_fail;
5804 swig_obj[0] = args;
5805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetMask" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5808 }
5809 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5810 {
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, 0 | 0 );
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_Bitmap_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj = 0;
5825 wxBitmap *arg1 = (wxBitmap *) 0 ;
5826 wxMask *arg2 = (wxMask *) 0 ;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 int res2 = 0 ;
5830 PyObject * obj0 = 0 ;
5831 PyObject * obj1 = 0 ;
5832 char * kwnames[] = {
5833 (char *) "self",(char *) "mask", NULL
5834 };
5835
5836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
5837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5838 if (!SWIG_IsOK(res1)) {
5839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMask" "', expected argument " "1"" of type '" "wxBitmap *""'");
5840 }
5841 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5842 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
5843 if (!SWIG_IsOK(res2)) {
5844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetMask" "', expected argument " "2"" of type '" "wxMask *""'");
5845 }
5846 {
5847 PyThreadState* __tstate = wxPyBeginAllowThreads();
5848 (arg1)->SetMask(arg2);
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 resultobj = SWIG_Py_Void();
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 SWIGINTERN PyObject *_wrap_Bitmap_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj = 0;
5861 wxBitmap *arg1 = (wxBitmap *) 0 ;
5862 wxColour *arg2 = 0 ;
5863 void *argp1 = 0 ;
5864 int res1 = 0 ;
5865 wxColour temp2 ;
5866 PyObject * obj0 = 0 ;
5867 PyObject * obj1 = 0 ;
5868 char * kwnames[] = {
5869 (char *) "self",(char *) "colour", NULL
5870 };
5871
5872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) SWIG_fail;
5873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5874 if (!SWIG_IsOK(res1)) {
5875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMaskColour" "', expected argument " "1"" of type '" "wxBitmap *""'");
5876 }
5877 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5878 {
5879 arg2 = &temp2;
5880 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
5885 wxPyEndAllowThreads(__tstate);
5886 if (PyErr_Occurred()) SWIG_fail;
5887 }
5888 resultobj = SWIG_Py_Void();
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 SWIGINTERN PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj = 0;
5897 wxBitmap *arg1 = (wxBitmap *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 SwigValueWrapper<wxBitmap > result;
5900 void *argp1 = 0 ;
5901 int res1 = 0 ;
5902 wxRect temp2 ;
5903 PyObject * obj0 = 0 ;
5904 PyObject * obj1 = 0 ;
5905 char * kwnames[] = {
5906 (char *) "self",(char *) "rect", NULL
5907 };
5908
5909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5911 if (!SWIG_IsOK(res1)) {
5912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSubBitmap" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5913 }
5914 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5915 {
5916 arg2 = &temp2;
5917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5918 }
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 SWIGINTERN PyObject *_wrap_Bitmap_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj = 0;
5934 wxBitmap *arg1 = (wxBitmap *) 0 ;
5935 wxString *arg2 = 0 ;
5936 wxBitmapType arg3 ;
5937 wxPalette *arg4 = (wxPalette *) NULL ;
5938 bool result;
5939 void *argp1 = 0 ;
5940 int res1 = 0 ;
5941 bool temp2 = false ;
5942 int val3 ;
5943 int ecode3 = 0 ;
5944 void *argp4 = 0 ;
5945 int res4 = 0 ;
5946 PyObject * obj0 = 0 ;
5947 PyObject * obj1 = 0 ;
5948 PyObject * obj2 = 0 ;
5949 PyObject * obj3 = 0 ;
5950 char * kwnames[] = {
5951 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
5952 };
5953
5954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SaveFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
5958 }
5959 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5960 {
5961 arg2 = wxString_in_helper(obj1);
5962 if (arg2 == NULL) SWIG_fail;
5963 temp2 = true;
5964 }
5965 ecode3 = SWIG_AsVal_int(obj2, &val3);
5966 if (!SWIG_IsOK(ecode3)) {
5967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_SaveFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
5968 }
5969 arg3 = static_cast< wxBitmapType >(val3);
5970 if (obj3) {
5971 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxPalette, 0 | 0 );
5972 if (!SWIG_IsOK(res4)) {
5973 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Bitmap_SaveFile" "', expected argument " "4"" of type '" "wxPalette *""'");
5974 }
5975 arg4 = reinterpret_cast< wxPalette * >(argp4);
5976 }
5977 {
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3,arg4);
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 {
5984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5985 }
5986 {
5987 if (temp2)
5988 delete arg2;
5989 }
5990 return resultobj;
5991 fail:
5992 {
5993 if (temp2)
5994 delete arg2;
5995 }
5996 return NULL;
5997 }
5998
5999
6000 SWIGINTERN PyObject *_wrap_Bitmap_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 wxBitmap *arg1 = (wxBitmap *) 0 ;
6003 wxString *arg2 = 0 ;
6004 wxBitmapType arg3 ;
6005 bool result;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 bool temp2 = false ;
6009 int val3 ;
6010 int ecode3 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 PyObject * obj2 = 0 ;
6014 char * kwnames[] = {
6015 (char *) "self",(char *) "name",(char *) "type", NULL
6016 };
6017
6018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6020 if (!SWIG_IsOK(res1)) {
6021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_LoadFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6022 }
6023 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6024 {
6025 arg2 = wxString_in_helper(obj1);
6026 if (arg2 == NULL) SWIG_fail;
6027 temp2 = true;
6028 }
6029 ecode3 = SWIG_AsVal_int(obj2, &val3);
6030 if (!SWIG_IsOK(ecode3)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6032 }
6033 arg3 = static_cast< wxBitmapType >(val3);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 {
6041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6042 }
6043 {
6044 if (temp2)
6045 delete arg2;
6046 }
6047 return resultobj;
6048 fail:
6049 {
6050 if (temp2)
6051 delete arg2;
6052 }
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_Bitmap_GetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6058 PyObject *resultobj = 0;
6059 wxBitmap *arg1 = (wxBitmap *) 0 ;
6060 wxPalette *result = 0 ;
6061 void *argp1 = 0 ;
6062 int res1 = 0 ;
6063 PyObject *swig_obj[1] ;
6064
6065 if (!args) SWIG_fail;
6066 swig_obj[0] = args;
6067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6068 if (!SWIG_IsOK(res1)) {
6069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetPalette" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6070 }
6071 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6072 {
6073 PyThreadState* __tstate = wxPyBeginAllowThreads();
6074 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, 0 | 0 );
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj = 0;
6087 wxBitmap *arg1 = (wxBitmap *) 0 ;
6088 wxIcon *arg2 = 0 ;
6089 bool result;
6090 void *argp1 = 0 ;
6091 int res1 = 0 ;
6092 void *argp2 = 0 ;
6093 int res2 = 0 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 char * kwnames[] = {
6097 (char *) "self",(char *) "icon", NULL
6098 };
6099
6100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) SWIG_fail;
6101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6102 if (!SWIG_IsOK(res1)) {
6103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "1"" of type '" "wxBitmap *""'");
6104 }
6105 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
6107 if (!SWIG_IsOK(res2)) {
6108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6109 }
6110 if (!argp2) {
6111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6112 }
6113 arg2 = reinterpret_cast< wxIcon * >(argp2);
6114 {
6115 PyThreadState* __tstate = wxPyBeginAllowThreads();
6116 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 SWIGINTERN PyObject *_wrap_Bitmap_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj = 0;
6131 wxBitmap *arg1 = (wxBitmap *) 0 ;
6132 int arg2 ;
6133 void *argp1 = 0 ;
6134 int res1 = 0 ;
6135 int val2 ;
6136 int ecode2 = 0 ;
6137 PyObject * obj0 = 0 ;
6138 PyObject * obj1 = 0 ;
6139 char * kwnames[] = {
6140 (char *) "self",(char *) "height", NULL
6141 };
6142
6143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6145 if (!SWIG_IsOK(res1)) {
6146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6147 }
6148 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6149 ecode2 = SWIG_AsVal_int(obj1, &val2);
6150 if (!SWIG_IsOK(ecode2)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHeight" "', expected argument " "2"" of type '" "int""'");
6152 }
6153 arg2 = static_cast< int >(val2);
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 (arg1)->SetHeight(arg2);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_Py_Void();
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_Bitmap_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 wxBitmap *arg1 = (wxBitmap *) 0 ;
6170 int arg2 ;
6171 void *argp1 = 0 ;
6172 int res1 = 0 ;
6173 int val2 ;
6174 int ecode2 = 0 ;
6175 PyObject * obj0 = 0 ;
6176 PyObject * obj1 = 0 ;
6177 char * kwnames[] = {
6178 (char *) "self",(char *) "width", NULL
6179 };
6180
6181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6183 if (!SWIG_IsOK(res1)) {
6184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6185 }
6186 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6187 ecode2 = SWIG_AsVal_int(obj1, &val2);
6188 if (!SWIG_IsOK(ecode2)) {
6189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetWidth" "', expected argument " "2"" of type '" "int""'");
6190 }
6191 arg2 = static_cast< int >(val2);
6192 {
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 (arg1)->SetWidth(arg2);
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 resultobj = SWIG_Py_Void();
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 SWIGINTERN PyObject *_wrap_Bitmap_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj = 0;
6207 wxBitmap *arg1 = (wxBitmap *) 0 ;
6208 int arg2 ;
6209 void *argp1 = 0 ;
6210 int res1 = 0 ;
6211 int val2 ;
6212 int ecode2 = 0 ;
6213 PyObject * obj0 = 0 ;
6214 PyObject * obj1 = 0 ;
6215 char * kwnames[] = {
6216 (char *) "self",(char *) "depth", NULL
6217 };
6218
6219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6221 if (!SWIG_IsOK(res1)) {
6222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6223 }
6224 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6225 ecode2 = SWIG_AsVal_int(obj1, &val2);
6226 if (!SWIG_IsOK(ecode2)) {
6227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetDepth" "', expected argument " "2"" of type '" "int""'");
6228 }
6229 arg2 = static_cast< int >(val2);
6230 {
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 (arg1)->SetDepth(arg2);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_Bitmap_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6244 PyObject *resultobj = 0;
6245 wxBitmap *arg1 = (wxBitmap *) 0 ;
6246 wxSize *arg2 = 0 ;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 wxSize temp2 ;
6250 PyObject * obj0 = 0 ;
6251 PyObject * obj1 = 0 ;
6252 char * kwnames[] = {
6253 (char *) "self",(char *) "size", NULL
6254 };
6255
6256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6258 if (!SWIG_IsOK(res1)) {
6259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6260 }
6261 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6262 {
6263 arg2 = &temp2;
6264 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6265 }
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 resultobj = SWIG_Py_Void();
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 SWIGINTERN PyObject *_wrap_Bitmap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj = 0;
6281 wxBitmap *arg1 = (wxBitmap *) 0 ;
6282 wxBitmap *arg2 = (wxBitmap *) 0 ;
6283 bool result;
6284 void *argp1 = 0 ;
6285 int res1 = 0 ;
6286 void *argp2 = 0 ;
6287 int res2 = 0 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 char * kwnames[] = {
6291 (char *) "self",(char *) "other", NULL
6292 };
6293
6294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) 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___eq__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6298 }
6299 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6301 if (!SWIG_IsOK(res2)) {
6302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___eq__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6303 }
6304 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 {
6312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6313 }
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 SWIGINTERN PyObject *_wrap_Bitmap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj = 0;
6322 wxBitmap *arg1 = (wxBitmap *) 0 ;
6323 wxBitmap *arg2 = (wxBitmap *) 0 ;
6324 bool result;
6325 void *argp1 = 0 ;
6326 int res1 = 0 ;
6327 void *argp2 = 0 ;
6328 int res2 = 0 ;
6329 PyObject * obj0 = 0 ;
6330 PyObject * obj1 = 0 ;
6331 char * kwnames[] = {
6332 (char *) "self",(char *) "other", NULL
6333 };
6334
6335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6337 if (!SWIG_IsOK(res1)) {
6338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___ne__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6339 }
6340 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6342 if (!SWIG_IsOK(res2)) {
6343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___ne__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6344 }
6345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6346 {
6347 PyThreadState* __tstate = wxPyBeginAllowThreads();
6348 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
6349 wxPyEndAllowThreads(__tstate);
6350 if (PyErr_Occurred()) SWIG_fail;
6351 }
6352 {
6353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6354 }
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *Bitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6362 PyObject *obj;
6363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6364 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmap, SWIG_NewClientData(obj));
6365 return SWIG_Py_Void();
6366 }
6367
6368 SWIGINTERN PyObject *Bitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6369 return SWIG_Python_InitShadowInstance(args);
6370 }
6371
6372 SWIGINTERN PyObject *_wrap_new_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxBitmap *arg1 = 0 ;
6375 wxColour const &arg2_defvalue = wxNullColour ;
6376 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
6377 wxMask *result = 0 ;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 wxColour temp2 ;
6381 PyObject * obj0 = 0 ;
6382 PyObject * obj1 = 0 ;
6383 char * kwnames[] = {
6384 (char *) "bitmap",(char *) "colour", NULL
6385 };
6386
6387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) SWIG_fail;
6388 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
6389 if (!SWIG_IsOK(res1)) {
6390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6391 }
6392 if (!argp1) {
6393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6394 }
6395 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6396 if (obj1) {
6397 {
6398 arg2 = &temp2;
6399 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6400 }
6401 }
6402 {
6403 if (!wxPyCheckForApp()) SWIG_fail;
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, SWIG_POINTER_NEW | 0 );
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 SWIGINTERN PyObject *_wrap_delete_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6417 PyObject *resultobj = 0;
6418 wxMask *arg1 = (wxMask *) 0 ;
6419 void *argp1 = 0 ;
6420 int res1 = 0 ;
6421 PyObject *swig_obj[1] ;
6422
6423 if (!args) SWIG_fail;
6424 swig_obj[0] = args;
6425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
6426 if (!SWIG_IsOK(res1)) {
6427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mask" "', expected argument " "1"" of type '" "wxMask *""'");
6428 }
6429 arg1 = reinterpret_cast< wxMask * >(argp1);
6430 {
6431 PyThreadState* __tstate = wxPyBeginAllowThreads();
6432 delete arg1;
6433
6434 wxPyEndAllowThreads(__tstate);
6435 if (PyErr_Occurred()) SWIG_fail;
6436 }
6437 resultobj = SWIG_Py_Void();
6438 return resultobj;
6439 fail:
6440 return NULL;
6441 }
6442
6443
6444 SWIGINTERN PyObject *Mask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6445 PyObject *obj;
6446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6447 SWIG_TypeNewClientData(SWIGTYPE_p_wxMask, SWIG_NewClientData(obj));
6448 return SWIG_Py_Void();
6449 }
6450
6451 SWIGINTERN PyObject *Mask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6452 return SWIG_Python_InitShadowInstance(args);
6453 }
6454
6455 SWIGINTERN PyObject *_wrap_new_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj = 0;
6457 wxString *arg1 = 0 ;
6458 wxBitmapType arg2 ;
6459 int arg3 = (int) -1 ;
6460 int arg4 = (int) -1 ;
6461 wxIcon *result = 0 ;
6462 bool temp1 = false ;
6463 int val2 ;
6464 int ecode2 = 0 ;
6465 int val3 ;
6466 int ecode3 = 0 ;
6467 int val4 ;
6468 int ecode4 = 0 ;
6469 PyObject * obj0 = 0 ;
6470 PyObject * obj1 = 0 ;
6471 PyObject * obj2 = 0 ;
6472 PyObject * obj3 = 0 ;
6473 char * kwnames[] = {
6474 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
6475 };
6476
6477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6478 {
6479 arg1 = wxString_in_helper(obj0);
6480 if (arg1 == NULL) SWIG_fail;
6481 temp1 = true;
6482 }
6483 ecode2 = SWIG_AsVal_int(obj1, &val2);
6484 if (!SWIG_IsOK(ecode2)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Icon" "', expected argument " "2"" of type '" "wxBitmapType""'");
6486 }
6487 arg2 = static_cast< wxBitmapType >(val2);
6488 if (obj2) {
6489 ecode3 = SWIG_AsVal_int(obj2, &val3);
6490 if (!SWIG_IsOK(ecode3)) {
6491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Icon" "', expected argument " "3"" of type '" "int""'");
6492 }
6493 arg3 = static_cast< int >(val3);
6494 }
6495 if (obj3) {
6496 ecode4 = SWIG_AsVal_int(obj3, &val4);
6497 if (!SWIG_IsOK(ecode4)) {
6498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Icon" "', expected argument " "4"" of type '" "int""'");
6499 }
6500 arg4 = static_cast< int >(val4);
6501 }
6502 {
6503 if (!wxPyCheckForApp()) SWIG_fail;
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (wxIcon *)new wxIcon((wxString const &)*arg1,arg2,arg3,arg4);
6506 wxPyEndAllowThreads(__tstate);
6507 if (PyErr_Occurred()) SWIG_fail;
6508 }
6509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_NEW | 0 );
6510 {
6511 if (temp1)
6512 delete arg1;
6513 }
6514 return resultobj;
6515 fail:
6516 {
6517 if (temp1)
6518 delete arg1;
6519 }
6520 return NULL;
6521 }
6522
6523
6524 SWIGINTERN PyObject *_wrap_delete_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6525 PyObject *resultobj = 0;
6526 wxIcon *arg1 = (wxIcon *) 0 ;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, SWIG_POINTER_DISOWN | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Icon" "', expected argument " "1"" of type '" "wxIcon *""'");
6536 }
6537 arg1 = reinterpret_cast< wxIcon * >(argp1);
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 delete arg1;
6541
6542 wxPyEndAllowThreads(__tstate);
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 resultobj = SWIG_Py_Void();
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_new_EmptyIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553 PyObject *resultobj = 0;
6554 wxIcon *result = 0 ;
6555
6556 if (!SWIG_Python_UnpackTuple(args,"new_EmptyIcon",0,0,0)) SWIG_fail;
6557 {
6558 if (!wxPyCheckForApp()) SWIG_fail;
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 result = (wxIcon *)new wxIcon();
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_new_IconFromLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj = 0;
6573 wxIconLocation *arg1 = 0 ;
6574 wxIcon *result = 0 ;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 PyObject * obj0 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "loc", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIconLocation, 0 | 0);
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
6586 }
6587 if (!argp1) {
6588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
6589 }
6590 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
6591 {
6592 if (!wxPyCheckForApp()) SWIG_fail;
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_new_IconFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6606 PyObject *resultobj = 0;
6607 wxBitmap *arg1 = 0 ;
6608 wxIcon *result = 0 ;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject * obj0 = 0 ;
6612 char * kwnames[] = {
6613 (char *) "bmp", NULL
6614 };
6615
6616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) SWIG_fail;
6617 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
6618 if (!SWIG_IsOK(res1)) {
6619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6620 }
6621 if (!argp1) {
6622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6623 }
6624 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6625 {
6626 if (!wxPyCheckForApp()) SWIG_fail;
6627 PyThreadState* __tstate = wxPyBeginAllowThreads();
6628 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
6629 wxPyEndAllowThreads(__tstate);
6630 if (PyErr_Occurred()) SWIG_fail;
6631 }
6632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 SWIGINTERN PyObject *_wrap_new_IconFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6640 PyObject *resultobj = 0;
6641 PyObject *arg1 = (PyObject *) 0 ;
6642 wxIcon *result = 0 ;
6643 PyObject * obj0 = 0 ;
6644 char * kwnames[] = {
6645 (char *) "listOfStrings", NULL
6646 };
6647
6648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) SWIG_fail;
6649 arg1 = obj0;
6650 {
6651 if (!wxPyCheckForApp()) SWIG_fail;
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = (wxIcon *)new_wxIcon(arg1);
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_Icon_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6665 PyObject *resultobj = 0;
6666 wxIcon *arg1 = (wxIcon *) 0 ;
6667 bool result;
6668 void *argp1 = 0 ;
6669 int res1 = 0 ;
6670 PyObject *swig_obj[1] ;
6671
6672 if (!args) SWIG_fail;
6673 swig_obj[0] = args;
6674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6675 if (!SWIG_IsOK(res1)) {
6676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_Ok" "', expected argument " "1"" of type '" "wxIcon *""'");
6677 }
6678 arg1 = reinterpret_cast< wxIcon * >(argp1);
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = (bool)(arg1)->Ok();
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 {
6686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6687 }
6688 return resultobj;
6689 fail:
6690 return NULL;
6691 }
6692
6693
6694 SWIGINTERN PyObject *_wrap_Icon_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6695 PyObject *resultobj = 0;
6696 wxIcon *arg1 = (wxIcon *) 0 ;
6697 int result;
6698 void *argp1 = 0 ;
6699 int res1 = 0 ;
6700 PyObject *swig_obj[1] ;
6701
6702 if (!args) SWIG_fail;
6703 swig_obj[0] = args;
6704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6705 if (!SWIG_IsOK(res1)) {
6706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
6707 }
6708 arg1 = reinterpret_cast< wxIcon * >(argp1);
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 result = (int)(arg1)->GetWidth();
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_From_int(static_cast< int >(result));
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_Icon_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6723 PyObject *resultobj = 0;
6724 wxIcon *arg1 = (wxIcon *) 0 ;
6725 int result;
6726 void *argp1 = 0 ;
6727 int res1 = 0 ;
6728 PyObject *swig_obj[1] ;
6729
6730 if (!args) SWIG_fail;
6731 swig_obj[0] = args;
6732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6733 if (!SWIG_IsOK(res1)) {
6734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
6735 }
6736 arg1 = reinterpret_cast< wxIcon * >(argp1);
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 result = (int)(arg1)->GetHeight();
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_From_int(static_cast< int >(result));
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Icon_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxIcon *arg1 = (wxIcon *) 0 ;
6753 int result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
6763 }
6764 arg1 = reinterpret_cast< wxIcon * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (int)(arg1)->GetDepth();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 resultobj = SWIG_From_int(static_cast< int >(result));
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_Icon_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj = 0;
6780 wxIcon *arg1 = (wxIcon *) 0 ;
6781 int arg2 ;
6782 void *argp1 = 0 ;
6783 int res1 = 0 ;
6784 int val2 ;
6785 int ecode2 = 0 ;
6786 PyObject * obj0 = 0 ;
6787 PyObject * obj1 = 0 ;
6788 char * kwnames[] = {
6789 (char *) "self",(char *) "w", NULL
6790 };
6791
6792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6794 if (!SWIG_IsOK(res1)) {
6795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
6796 }
6797 arg1 = reinterpret_cast< wxIcon * >(argp1);
6798 ecode2 = SWIG_AsVal_int(obj1, &val2);
6799 if (!SWIG_IsOK(ecode2)) {
6800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetWidth" "', expected argument " "2"" of type '" "int""'");
6801 }
6802 arg2 = static_cast< int >(val2);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 (arg1)->SetWidth(arg2);
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_Py_Void();
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_Icon_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj = 0;
6818 wxIcon *arg1 = (wxIcon *) 0 ;
6819 int arg2 ;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 int val2 ;
6823 int ecode2 = 0 ;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 char * kwnames[] = {
6827 (char *) "self",(char *) "h", NULL
6828 };
6829
6830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6832 if (!SWIG_IsOK(res1)) {
6833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
6834 }
6835 arg1 = reinterpret_cast< wxIcon * >(argp1);
6836 ecode2 = SWIG_AsVal_int(obj1, &val2);
6837 if (!SWIG_IsOK(ecode2)) {
6838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHeight" "', expected argument " "2"" of type '" "int""'");
6839 }
6840 arg2 = static_cast< int >(val2);
6841 {
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 (arg1)->SetHeight(arg2);
6844 wxPyEndAllowThreads(__tstate);
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_Py_Void();
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 SWIGINTERN PyObject *_wrap_Icon_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj = 0;
6856 wxIcon *arg1 = (wxIcon *) 0 ;
6857 int arg2 ;
6858 void *argp1 = 0 ;
6859 int res1 = 0 ;
6860 int val2 ;
6861 int ecode2 = 0 ;
6862 PyObject * obj0 = 0 ;
6863 PyObject * obj1 = 0 ;
6864 char * kwnames[] = {
6865 (char *) "self",(char *) "d", NULL
6866 };
6867
6868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
6872 }
6873 arg1 = reinterpret_cast< wxIcon * >(argp1);
6874 ecode2 = SWIG_AsVal_int(obj1, &val2);
6875 if (!SWIG_IsOK(ecode2)) {
6876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetDepth" "', expected argument " "2"" of type '" "int""'");
6877 }
6878 arg2 = static_cast< int >(val2);
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 (arg1)->SetDepth(arg2);
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_Py_Void();
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 SWIGINTERN PyObject *_wrap_Icon_CopyFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj = 0;
6894 wxIcon *arg1 = (wxIcon *) 0 ;
6895 wxBitmap *arg2 = 0 ;
6896 void *argp1 = 0 ;
6897 int res1 = 0 ;
6898 void *argp2 = 0 ;
6899 int res2 = 0 ;
6900 PyObject * obj0 = 0 ;
6901 PyObject * obj1 = 0 ;
6902 char * kwnames[] = {
6903 (char *) "self",(char *) "bmp", NULL
6904 };
6905
6906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
6907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6908 if (!SWIG_IsOK(res1)) {
6909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_CopyFromBitmap" "', expected argument " "1"" of type '" "wxIcon *""'");
6910 }
6911 arg1 = reinterpret_cast< wxIcon * >(argp1);
6912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
6913 if (!SWIG_IsOK(res2)) {
6914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
6915 }
6916 if (!argp2) {
6917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
6918 }
6919 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 resultobj = SWIG_Py_Void();
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 SWIGINTERN PyObject *Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6934 PyObject *obj;
6935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6936 SWIG_TypeNewClientData(SWIGTYPE_p_wxIcon, SWIG_NewClientData(obj));
6937 return SWIG_Py_Void();
6938 }
6939
6940 SWIGINTERN PyObject *Icon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941 return SWIG_Python_InitShadowInstance(args);
6942 }
6943
6944 SWIGINTERN PyObject *_wrap_new_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj = 0;
6946 wxString *arg1 = (wxString *) &wxPyEmptyString ;
6947 int arg2 = (int) 0 ;
6948 wxIconLocation *result = 0 ;
6949 bool temp1 = false ;
6950 int val2 ;
6951 int ecode2 = 0 ;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 char * kwnames[] = {
6955 (char *) "filename",(char *) "num", NULL
6956 };
6957
6958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) SWIG_fail;
6959 if (obj0) {
6960 {
6961 arg1 = wxString_in_helper(obj0);
6962 if (arg1 == NULL) SWIG_fail;
6963 temp1 = true;
6964 }
6965 }
6966 if (obj1) {
6967 ecode2 = SWIG_AsVal_int(obj1, &val2);
6968 if (!SWIG_IsOK(ecode2)) {
6969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconLocation" "', expected argument " "2"" of type '" "int""'");
6970 }
6971 arg2 = static_cast< int >(val2);
6972 }
6973 {
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconLocation, SWIG_POINTER_NEW | 0 );
6980 {
6981 if (temp1)
6982 delete arg1;
6983 }
6984 return resultobj;
6985 fail:
6986 {
6987 if (temp1)
6988 delete arg1;
6989 }
6990 return NULL;
6991 }
6992
6993
6994 SWIGINTERN PyObject *_wrap_delete_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6995 PyObject *resultobj = 0;
6996 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
6997 void *argp1 = 0 ;
6998 int res1 = 0 ;
6999 PyObject *swig_obj[1] ;
7000
7001 if (!args) SWIG_fail;
7002 swig_obj[0] = args;
7003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, SWIG_POINTER_DISOWN | 0 );
7004 if (!SWIG_IsOK(res1)) {
7005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconLocation" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7006 }
7007 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 delete arg1;
7011
7012 wxPyEndAllowThreads(__tstate);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 resultobj = SWIG_Py_Void();
7016 return resultobj;
7017 fail:
7018 return NULL;
7019 }
7020
7021
7022 SWIGINTERN PyObject *_wrap_IconLocation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7023 PyObject *resultobj = 0;
7024 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7025 bool result;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 PyObject *swig_obj[1] ;
7029
7030 if (!args) SWIG_fail;
7031 swig_obj[0] = args;
7032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_IsOk" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
7035 }
7036 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 result = (bool)((wxIconLocation const *)arg1)->IsOk();
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 {
7044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7045 }
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_IconLocation_SetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7053 PyObject *resultobj = 0;
7054 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7055 wxString *arg2 = 0 ;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 bool temp2 = false ;
7059 PyObject * obj0 = 0 ;
7060 PyObject * obj1 = 0 ;
7061 char * kwnames[] = {
7062 (char *) "self",(char *) "filename", NULL
7063 };
7064
7065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) SWIG_fail;
7066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7067 if (!SWIG_IsOK(res1)) {
7068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetFileName" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7069 }
7070 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7071 {
7072 arg2 = wxString_in_helper(obj1);
7073 if (arg2 == NULL) SWIG_fail;
7074 temp2 = true;
7075 }
7076 {
7077 PyThreadState* __tstate = wxPyBeginAllowThreads();
7078 (arg1)->SetFileName((wxString const &)*arg2);
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 resultobj = SWIG_Py_Void();
7083 {
7084 if (temp2)
7085 delete arg2;
7086 }
7087 return resultobj;
7088 fail:
7089 {
7090 if (temp2)
7091 delete arg2;
7092 }
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_IconLocation_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7100 wxString *result = 0 ;
7101 void *argp1 = 0 ;
7102 int res1 = 0 ;
7103 PyObject *swig_obj[1] ;
7104
7105 if (!args) SWIG_fail;
7106 swig_obj[0] = args;
7107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7108 if (!SWIG_IsOK(res1)) {
7109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetFileName" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
7110 }
7111 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7112 {
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 {
7115 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
7116 result = (wxString *) &_result_ref;
7117 }
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 {
7122 #if wxUSE_UNICODE
7123 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
7124 #else
7125 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
7126 #endif
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 SWIGINTERN PyObject *_wrap_IconLocation_SetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj = 0;
7136 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7137 int arg2 ;
7138 void *argp1 = 0 ;
7139 int res1 = 0 ;
7140 int val2 ;
7141 int ecode2 = 0 ;
7142 PyObject * obj0 = 0 ;
7143 PyObject * obj1 = 0 ;
7144 char * kwnames[] = {
7145 (char *) "self",(char *) "num", NULL
7146 };
7147
7148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) SWIG_fail;
7149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7150 if (!SWIG_IsOK(res1)) {
7151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7152 }
7153 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7154 ecode2 = SWIG_AsVal_int(obj1, &val2);
7155 if (!SWIG_IsOK(ecode2)) {
7156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IconLocation_SetIndex" "', expected argument " "2"" of type '" "int""'");
7157 }
7158 arg2 = static_cast< int >(val2);
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 wxIconLocation_SetIndex(arg1,arg2);
7162 wxPyEndAllowThreads(__tstate);
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_IconLocation_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7173 PyObject *resultobj = 0;
7174 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7175 int 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_wxIconLocation, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7185 }
7186 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 result = (int)wxIconLocation_GetIndex(arg1);
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_From_int(static_cast< int >(result));
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *IconLocation_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_wxIconLocation, SWIG_NewClientData(obj));
7204 return SWIG_Py_Void();
7205 }
7206
7207 SWIGINTERN PyObject *IconLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7208 return SWIG_Python_InitShadowInstance(args);
7209 }
7210
7211 SWIGINTERN PyObject *_wrap_new_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7212 PyObject *resultobj = 0;
7213 wxIconBundle *result = 0 ;
7214
7215 if (!SWIG_Python_UnpackTuple(args,"new_IconBundle",0,0,0)) SWIG_fail;
7216 {
7217 PyThreadState* __tstate = wxPyBeginAllowThreads();
7218 result = (wxIconBundle *)new wxIconBundle();
7219 wxPyEndAllowThreads(__tstate);
7220 if (PyErr_Occurred()) SWIG_fail;
7221 }
7222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_NEW | 0 );
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 SWIGINTERN PyObject *_wrap_new_IconBundleFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7230 PyObject *resultobj = 0;
7231 wxString *arg1 = 0 ;
7232 long arg2 ;
7233 wxIconBundle *result = 0 ;
7234 bool temp1 = false ;
7235 long val2 ;
7236 int ecode2 = 0 ;
7237 PyObject * obj0 = 0 ;
7238 PyObject * obj1 = 0 ;
7239 char * kwnames[] = {
7240 (char *) "file",(char *) "type", NULL
7241 };
7242
7243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) SWIG_fail;
7244 {
7245 arg1 = wxString_in_helper(obj0);
7246 if (arg1 == NULL) SWIG_fail;
7247 temp1 = true;
7248 }
7249 ecode2 = SWIG_AsVal_long(obj1, &val2);
7250 if (!SWIG_IsOK(ecode2)) {
7251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconBundleFromFile" "', expected argument " "2"" of type '" "long""'");
7252 }
7253 arg2 = static_cast< long >(val2);
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
7261 {
7262 if (temp1)
7263 delete arg1;
7264 }
7265 return resultobj;
7266 fail:
7267 {
7268 if (temp1)
7269 delete arg1;
7270 }
7271 return NULL;
7272 }
7273
7274
7275 SWIGINTERN PyObject *_wrap_new_IconBundleFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7276 PyObject *resultobj = 0;
7277 wxIcon *arg1 = 0 ;
7278 wxIconBundle *result = 0 ;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 PyObject * obj0 = 0 ;
7282 char * kwnames[] = {
7283 (char *) "icon", NULL
7284 };
7285
7286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) SWIG_fail;
7287 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
7288 if (!SWIG_IsOK(res1)) {
7289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
7290 }
7291 if (!argp1) {
7292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
7293 }
7294 arg1 = reinterpret_cast< wxIcon * >(argp1);
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 SWIGINTERN PyObject *_wrap_delete_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7309 PyObject *resultobj = 0;
7310 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7311 void *argp1 = 0 ;
7312 int res1 = 0 ;
7313 PyObject *swig_obj[1] ;
7314
7315 if (!args) SWIG_fail;
7316 swig_obj[0] = args;
7317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconBundle, SWIG_POINTER_DISOWN | 0 );
7318 if (!SWIG_IsOK(res1)) {
7319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconBundle" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7320 }
7321 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 delete arg1;
7325
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 resultobj = SWIG_Py_Void();
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_IconBundle_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj = 0;
7338 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7339 wxIcon *arg2 = 0 ;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 void *argp2 = 0 ;
7343 int res2 = 0 ;
7344 PyObject * obj0 = 0 ;
7345 PyObject * obj1 = 0 ;
7346 char * kwnames[] = {
7347 (char *) "self",(char *) "icon", NULL
7348 };
7349
7350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
7351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIcon" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7354 }
7355 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
7357 if (!SWIG_IsOK(res2)) {
7358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
7359 }
7360 if (!argp2) {
7361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
7362 }
7363 arg2 = reinterpret_cast< wxIcon * >(argp2);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 (arg1)->AddIcon((wxIcon const &)*arg2);
7367 wxPyEndAllowThreads(__tstate);
7368 if (PyErr_Occurred()) SWIG_fail;
7369 }
7370 resultobj = SWIG_Py_Void();
7371 return resultobj;
7372 fail:
7373 return NULL;
7374 }
7375
7376
7377 SWIGINTERN PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7378 PyObject *resultobj = 0;
7379 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7380 wxString *arg2 = 0 ;
7381 long arg3 ;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 bool temp2 = false ;
7385 long val3 ;
7386 int ecode3 = 0 ;
7387 PyObject * obj0 = 0 ;
7388 PyObject * obj1 = 0 ;
7389 PyObject * obj2 = 0 ;
7390 char * kwnames[] = {
7391 (char *) "self",(char *) "file",(char *) "type", NULL
7392 };
7393
7394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7396 if (!SWIG_IsOK(res1)) {
7397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7398 }
7399 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7400 {
7401 arg2 = wxString_in_helper(obj1);
7402 if (arg2 == NULL) SWIG_fail;
7403 temp2 = true;
7404 }
7405 ecode3 = SWIG_AsVal_long(obj2, &val3);
7406 if (!SWIG_IsOK(ecode3)) {
7407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "3"" of type '" "long""'");
7408 }
7409 arg3 = static_cast< long >(val3);
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->AddIcon((wxString const &)*arg2,arg3);
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 resultobj = SWIG_Py_Void();
7417 {
7418 if (temp2)
7419 delete arg2;
7420 }
7421 return resultobj;
7422 fail:
7423 {
7424 if (temp2)
7425 delete arg2;
7426 }
7427 return NULL;
7428 }
7429
7430
7431 SWIGINTERN PyObject *_wrap_IconBundle_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7432 PyObject *resultobj = 0;
7433 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7434 wxSize *arg2 = 0 ;
7435 wxIcon *result = 0 ;
7436 void *argp1 = 0 ;
7437 int res1 = 0 ;
7438 wxSize temp2 ;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 char * kwnames[] = {
7442 (char *) "self",(char *) "size", NULL
7443 };
7444
7445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
7446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_GetIcon" "', expected argument " "1"" of type '" "wxIconBundle const *""'");
7449 }
7450 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7451 {
7452 arg2 = &temp2;
7453 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7454 }
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 {
7458 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
7459 result = (wxIcon *) &_result_ref;
7460 }
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 wxIcon* resultptr = new wxIcon(*result);
7466 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
7467 }
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 SWIGINTERN PyObject *IconBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7475 PyObject *obj;
7476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7477 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconBundle, SWIG_NewClientData(obj));
7478 return SWIG_Py_Void();
7479 }
7480
7481 SWIGINTERN PyObject *IconBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7482 return SWIG_Python_InitShadowInstance(args);
7483 }
7484
7485 SWIGINTERN PyObject *_wrap_new_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxString *arg1 = 0 ;
7488 long arg2 ;
7489 int arg3 = (int) 0 ;
7490 int arg4 = (int) 0 ;
7491 wxCursor *result = 0 ;
7492 bool temp1 = false ;
7493 long val2 ;
7494 int ecode2 = 0 ;
7495 int val3 ;
7496 int ecode3 = 0 ;
7497 int val4 ;
7498 int ecode4 = 0 ;
7499 PyObject * obj0 = 0 ;
7500 PyObject * obj1 = 0 ;
7501 PyObject * obj2 = 0 ;
7502 PyObject * obj3 = 0 ;
7503 char * kwnames[] = {
7504 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
7505 };
7506
7507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7508 {
7509 arg1 = wxString_in_helper(obj0);
7510 if (arg1 == NULL) SWIG_fail;
7511 temp1 = true;
7512 }
7513 ecode2 = SWIG_AsVal_long(obj1, &val2);
7514 if (!SWIG_IsOK(ecode2)) {
7515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cursor" "', expected argument " "2"" of type '" "long""'");
7516 }
7517 arg2 = static_cast< long >(val2);
7518 if (obj2) {
7519 ecode3 = SWIG_AsVal_int(obj2, &val3);
7520 if (!SWIG_IsOK(ecode3)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cursor" "', expected argument " "3"" of type '" "int""'");
7522 }
7523 arg3 = static_cast< int >(val3);
7524 }
7525 if (obj3) {
7526 ecode4 = SWIG_AsVal_int(obj3, &val4);
7527 if (!SWIG_IsOK(ecode4)) {
7528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cursor" "', expected argument " "4"" of type '" "int""'");
7529 }
7530 arg4 = static_cast< int >(val4);
7531 }
7532 {
7533 if (!wxPyCheckForApp()) SWIG_fail;
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_NEW | 0 );
7540 {
7541 if (temp1)
7542 delete arg1;
7543 }
7544 return resultobj;
7545 fail:
7546 {
7547 if (temp1)
7548 delete arg1;
7549 }
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_delete_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxCursor *arg1 = (wxCursor *) 0 ;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 PyObject *swig_obj[1] ;
7560
7561 if (!args) SWIG_fail;
7562 swig_obj[0] = args;
7563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, SWIG_POINTER_DISOWN | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7566 }
7567 arg1 = reinterpret_cast< wxCursor * >(argp1);
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 delete arg1;
7571
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 resultobj = SWIG_Py_Void();
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_new_StockCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 int arg1 ;
7585 wxCursor *result = 0 ;
7586 int val1 ;
7587 int ecode1 = 0 ;
7588 PyObject * obj0 = 0 ;
7589 char * kwnames[] = {
7590 (char *) "id", NULL
7591 };
7592
7593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) SWIG_fail;
7594 ecode1 = SWIG_AsVal_int(obj0, &val1);
7595 if (!SWIG_IsOK(ecode1)) {
7596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StockCursor" "', expected argument " "1"" of type '" "int""'");
7597 }
7598 arg1 = static_cast< int >(val1);
7599 {
7600 if (!wxPyCheckForApp()) SWIG_fail;
7601 PyThreadState* __tstate = wxPyBeginAllowThreads();
7602 result = (wxCursor *)new wxCursor(arg1);
7603 wxPyEndAllowThreads(__tstate);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_new_CursorFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj = 0;
7615 wxImage *arg1 = 0 ;
7616 wxCursor *result = 0 ;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 PyObject * obj0 = 0 ;
7620 char * kwnames[] = {
7621 (char *) "image", NULL
7622 };
7623
7624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) SWIG_fail;
7625 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
7626 if (!SWIG_IsOK(res1)) {
7627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
7628 }
7629 if (!argp1) {
7630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
7631 }
7632 arg1 = reinterpret_cast< wxImage * >(argp1);
7633 {
7634 if (!wxPyCheckForApp()) SWIG_fail;
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
7637 wxPyEndAllowThreads(__tstate);
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Cursor_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxCursor *arg1 = (wxCursor *) 0 ;
7650 bool result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 PyObject *swig_obj[1] ;
7654
7655 if (!args) SWIG_fail;
7656 swig_obj[0] = args;
7657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_Ok" "', expected argument " "1"" of type '" "wxCursor *""'");
7660 }
7661 arg1 = reinterpret_cast< wxCursor * >(argp1);
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (bool)(arg1)->Ok();
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 {
7669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7670 }
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 SWIGINTERN PyObject *Cursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7678 PyObject *obj;
7679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7680 SWIG_TypeNewClientData(SWIGTYPE_p_wxCursor, SWIG_NewClientData(obj));
7681 return SWIG_Py_Void();
7682 }
7683
7684 SWIGINTERN PyObject *Cursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685 return SWIG_Python_InitShadowInstance(args);
7686 }
7687
7688 SWIGINTERN PyObject *_wrap_new_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj = 0;
7690 int arg1 = (int) 0 ;
7691 int arg2 = (int) 0 ;
7692 int arg3 = (int) 0 ;
7693 int arg4 = (int) 0 ;
7694 wxRegion *result = 0 ;
7695 int val1 ;
7696 int ecode1 = 0 ;
7697 int val2 ;
7698 int ecode2 = 0 ;
7699 int val3 ;
7700 int ecode3 = 0 ;
7701 int val4 ;
7702 int ecode4 = 0 ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 PyObject * obj2 = 0 ;
7706 PyObject * obj3 = 0 ;
7707 char * kwnames[] = {
7708 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7709 };
7710
7711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7712 if (obj0) {
7713 ecode1 = SWIG_AsVal_int(obj0, &val1);
7714 if (!SWIG_IsOK(ecode1)) {
7715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Region" "', expected argument " "1"" of type '" "int""'");
7716 }
7717 arg1 = static_cast< int >(val1);
7718 }
7719 if (obj1) {
7720 ecode2 = SWIG_AsVal_int(obj1, &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Region" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 }
7726 if (obj2) {
7727 ecode3 = SWIG_AsVal_int(obj2, &val3);
7728 if (!SWIG_IsOK(ecode3)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Region" "', expected argument " "3"" of type '" "int""'");
7730 }
7731 arg3 = static_cast< int >(val3);
7732 }
7733 if (obj3) {
7734 ecode4 = SWIG_AsVal_int(obj3, &val4);
7735 if (!SWIG_IsOK(ecode4)) {
7736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Region" "', expected argument " "4"" of type '" "int""'");
7737 }
7738 arg4 = static_cast< int >(val4);
7739 }
7740 {
7741 if (!wxPyCheckForApp()) SWIG_fail;
7742 PyThreadState* __tstate = wxPyBeginAllowThreads();
7743 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
7744 wxPyEndAllowThreads(__tstate);
7745 if (PyErr_Occurred()) SWIG_fail;
7746 }
7747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_NEW | 0 );
7748 return resultobj;
7749 fail:
7750 return NULL;
7751 }
7752
7753
7754 SWIGINTERN PyObject *_wrap_new_RegionFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7755 PyObject *resultobj = 0;
7756 wxBitmap *arg1 = 0 ;
7757 wxRegion *result = 0 ;
7758 void *argp1 = 0 ;
7759 int res1 = 0 ;
7760 PyObject * obj0 = 0 ;
7761 char * kwnames[] = {
7762 (char *) "bmp", NULL
7763 };
7764
7765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) SWIG_fail;
7766 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
7767 if (!SWIG_IsOK(res1)) {
7768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7769 }
7770 if (!argp1) {
7771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7772 }
7773 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7774 {
7775 if (!wxPyCheckForApp()) SWIG_fail;
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_new_RegionFromBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxBitmap *arg1 = 0 ;
7791 wxColour *arg2 = 0 ;
7792 int arg3 = (int) 0 ;
7793 wxRegion *result = 0 ;
7794 void *argp1 = 0 ;
7795 int res1 = 0 ;
7796 wxColour temp2 ;
7797 int val3 ;
7798 int ecode3 = 0 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 PyObject * obj2 = 0 ;
7802 char * kwnames[] = {
7803 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7804 };
7805
7806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7807 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
7808 if (!SWIG_IsOK(res1)) {
7809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7810 }
7811 if (!argp1) {
7812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7813 }
7814 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7815 {
7816 arg2 = &temp2;
7817 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
7818 }
7819 if (obj2) {
7820 ecode3 = SWIG_AsVal_int(obj2, &val3);
7821 if (!SWIG_IsOK(ecode3)) {
7822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromBitmapColour" "', expected argument " "3"" of type '" "int""'");
7823 }
7824 arg3 = static_cast< int >(val3);
7825 }
7826 {
7827 if (!wxPyCheckForApp()) SWIG_fail;
7828 PyThreadState* __tstate = wxPyBeginAllowThreads();
7829 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
7830 wxPyEndAllowThreads(__tstate);
7831 if (PyErr_Occurred()) SWIG_fail;
7832 }
7833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 SWIGINTERN PyObject *_wrap_new_RegionFromPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7841 PyObject *resultobj = 0;
7842 int arg1 ;
7843 wxPoint *arg2 = (wxPoint *) 0 ;
7844 int arg3 = (int) wxWINDING_RULE ;
7845 wxRegion *result = 0 ;
7846 int val3 ;
7847 int ecode3 = 0 ;
7848 PyObject * obj0 = 0 ;
7849 PyObject * obj1 = 0 ;
7850 char * kwnames[] = {
7851 (char *) "points",(char *) "fillStyle", NULL
7852 };
7853
7854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) SWIG_fail;
7855 {
7856 arg2 = wxPoint_LIST_helper(obj0, &arg1);
7857 if (arg2 == NULL) SWIG_fail;
7858 }
7859 if (obj1) {
7860 ecode3 = SWIG_AsVal_int(obj1, &val3);
7861 if (!SWIG_IsOK(ecode3)) {
7862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromPoints" "', expected argument " "3"" of type '" "int""'");
7863 }
7864 arg3 = static_cast< int >(val3);
7865 }
7866 {
7867 if (!wxPyCheckForApp()) SWIG_fail;
7868 PyThreadState* __tstate = wxPyBeginAllowThreads();
7869 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7874 {
7875 if (arg2) delete [] arg2;
7876 }
7877 return resultobj;
7878 fail:
7879 {
7880 if (arg2) delete [] arg2;
7881 }
7882 return NULL;
7883 }
7884
7885
7886 SWIGINTERN PyObject *_wrap_delete_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7887 PyObject *resultobj = 0;
7888 wxRegion *arg1 = (wxRegion *) 0 ;
7889 void *argp1 = 0 ;
7890 int res1 = 0 ;
7891 PyObject *swig_obj[1] ;
7892
7893 if (!args) SWIG_fail;
7894 swig_obj[0] = args;
7895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, SWIG_POINTER_DISOWN | 0 );
7896 if (!SWIG_IsOK(res1)) {
7897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', expected argument " "1"" of type '" "wxRegion *""'");
7898 }
7899 arg1 = reinterpret_cast< wxRegion * >(argp1);
7900 {
7901 PyThreadState* __tstate = wxPyBeginAllowThreads();
7902 delete arg1;
7903
7904 wxPyEndAllowThreads(__tstate);
7905 if (PyErr_Occurred()) SWIG_fail;
7906 }
7907 resultobj = SWIG_Py_Void();
7908 return resultobj;
7909 fail:
7910 return NULL;
7911 }
7912
7913
7914 SWIGINTERN PyObject *_wrap_Region_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7915 PyObject *resultobj = 0;
7916 wxRegion *arg1 = (wxRegion *) 0 ;
7917 void *argp1 = 0 ;
7918 int res1 = 0 ;
7919 PyObject *swig_obj[1] ;
7920
7921 if (!args) SWIG_fail;
7922 swig_obj[0] = args;
7923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
7924 if (!SWIG_IsOK(res1)) {
7925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Clear" "', expected argument " "1"" of type '" "wxRegion *""'");
7926 }
7927 arg1 = reinterpret_cast< wxRegion * >(argp1);
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 (arg1)->Clear();
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_Py_Void();
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_Region_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 wxRegion *arg1 = (wxRegion *) 0 ;
7944 int arg2 ;
7945 int arg3 ;
7946 bool result;
7947 void *argp1 = 0 ;
7948 int res1 = 0 ;
7949 int val2 ;
7950 int ecode2 = 0 ;
7951 int val3 ;
7952 int ecode3 = 0 ;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 PyObject * obj2 = 0 ;
7956 char * kwnames[] = {
7957 (char *) "self",(char *) "x",(char *) "y", NULL
7958 };
7959
7960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
7962 if (!SWIG_IsOK(res1)) {
7963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Offset" "', expected argument " "1"" of type '" "wxRegion *""'");
7964 }
7965 arg1 = reinterpret_cast< wxRegion * >(argp1);
7966 ecode2 = SWIG_AsVal_int(obj1, &val2);
7967 if (!SWIG_IsOK(ecode2)) {
7968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Offset" "', expected argument " "2"" of type '" "int""'");
7969 }
7970 arg2 = static_cast< int >(val2);
7971 ecode3 = SWIG_AsVal_int(obj2, &val3);
7972 if (!SWIG_IsOK(ecode3)) {
7973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Offset" "', expected argument " "3"" of type '" "int""'");
7974 }
7975 arg3 = static_cast< int >(val3);
7976 {
7977 PyThreadState* __tstate = wxPyBeginAllowThreads();
7978 result = (bool)(arg1)->Offset(arg2,arg3);
7979 wxPyEndAllowThreads(__tstate);
7980 if (PyErr_Occurred()) SWIG_fail;
7981 }
7982 {
7983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7984 }
7985 return resultobj;
7986 fail:
7987 return NULL;
7988 }
7989
7990
7991 SWIGINTERN PyObject *_wrap_Region_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7992 PyObject *resultobj = 0;
7993 wxRegion *arg1 = (wxRegion *) 0 ;
7994 int arg2 ;
7995 int arg3 ;
7996 wxRegionContain result;
7997 void *argp1 = 0 ;
7998 int res1 = 0 ;
7999 int val2 ;
8000 int ecode2 = 0 ;
8001 int val3 ;
8002 int ecode3 = 0 ;
8003 PyObject * obj0 = 0 ;
8004 PyObject * obj1 = 0 ;
8005 PyObject * obj2 = 0 ;
8006 char * kwnames[] = {
8007 (char *) "self",(char *) "x",(char *) "y", NULL
8008 };
8009
8010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8012 if (!SWIG_IsOK(res1)) {
8013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Contains" "', expected argument " "1"" of type '" "wxRegion *""'");
8014 }
8015 arg1 = reinterpret_cast< wxRegion * >(argp1);
8016 ecode2 = SWIG_AsVal_int(obj1, &val2);
8017 if (!SWIG_IsOK(ecode2)) {
8018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Contains" "', expected argument " "2"" of type '" "int""'");
8019 }
8020 arg2 = static_cast< int >(val2);
8021 ecode3 = SWIG_AsVal_int(obj2, &val3);
8022 if (!SWIG_IsOK(ecode3)) {
8023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Contains" "', expected argument " "3"" of type '" "int""'");
8024 }
8025 arg3 = static_cast< int >(val3);
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Region_ContainsPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8040 PyObject *resultobj = 0;
8041 wxRegion *arg1 = (wxRegion *) 0 ;
8042 wxPoint *arg2 = 0 ;
8043 wxRegionContain result;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 wxPoint temp2 ;
8047 PyObject * obj0 = 0 ;
8048 PyObject * obj1 = 0 ;
8049 char * kwnames[] = {
8050 (char *) "self",(char *) "pt", NULL
8051 };
8052
8053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) SWIG_fail;
8054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsPoint" "', expected argument " "1"" of type '" "wxRegion *""'");
8057 }
8058 arg1 = reinterpret_cast< wxRegion * >(argp1);
8059 {
8060 arg2 = &temp2;
8061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8062 }
8063 {
8064 PyThreadState* __tstate = wxPyBeginAllowThreads();
8065 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 resultobj = SWIG_From_int(static_cast< int >(result));
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 SWIGINTERN PyObject *_wrap_Region_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj = 0;
8078 wxRegion *arg1 = (wxRegion *) 0 ;
8079 wxRect *arg2 = 0 ;
8080 wxRegionContain result;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 wxRect temp2 ;
8084 PyObject * obj0 = 0 ;
8085 PyObject * obj1 = 0 ;
8086 char * kwnames[] = {
8087 (char *) "self",(char *) "rect", NULL
8088 };
8089
8090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
8091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8094 }
8095 arg1 = reinterpret_cast< wxRegion * >(argp1);
8096 {
8097 arg2 = &temp2;
8098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 resultobj = SWIG_From_int(static_cast< int >(result));
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 SWIGINTERN PyObject *_wrap_Region_ContainsRectDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8114 PyObject *resultobj = 0;
8115 wxRegion *arg1 = (wxRegion *) 0 ;
8116 int arg2 ;
8117 int arg3 ;
8118 int arg4 ;
8119 int arg5 ;
8120 wxRegionContain result;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 int val2 ;
8124 int ecode2 = 0 ;
8125 int val3 ;
8126 int ecode3 = 0 ;
8127 int val4 ;
8128 int ecode4 = 0 ;
8129 int val5 ;
8130 int ecode5 = 0 ;
8131 PyObject * obj0 = 0 ;
8132 PyObject * obj1 = 0 ;
8133 PyObject * obj2 = 0 ;
8134 PyObject * obj3 = 0 ;
8135 PyObject * obj4 = 0 ;
8136 char * kwnames[] = {
8137 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
8138 };
8139
8140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRectDim" "', expected argument " "1"" of type '" "wxRegion *""'");
8144 }
8145 arg1 = reinterpret_cast< wxRegion * >(argp1);
8146 ecode2 = SWIG_AsVal_int(obj1, &val2);
8147 if (!SWIG_IsOK(ecode2)) {
8148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_ContainsRectDim" "', expected argument " "2"" of type '" "int""'");
8149 }
8150 arg2 = static_cast< int >(val2);
8151 ecode3 = SWIG_AsVal_int(obj2, &val3);
8152 if (!SWIG_IsOK(ecode3)) {
8153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_ContainsRectDim" "', expected argument " "3"" of type '" "int""'");
8154 }
8155 arg3 = static_cast< int >(val3);
8156 ecode4 = SWIG_AsVal_int(obj3, &val4);
8157 if (!SWIG_IsOK(ecode4)) {
8158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_ContainsRectDim" "', expected argument " "4"" of type '" "int""'");
8159 }
8160 arg4 = static_cast< int >(val4);
8161 ecode5 = SWIG_AsVal_int(obj4, &val5);
8162 if (!SWIG_IsOK(ecode5)) {
8163 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_ContainsRectDim" "', expected argument " "5"" of type '" "int""'");
8164 }
8165 arg5 = static_cast< int >(val5);
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 resultobj = SWIG_From_int(static_cast< int >(result));
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 SWIGINTERN PyObject *_wrap_Region_GetBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8180 PyObject *resultobj = 0;
8181 wxRegion *arg1 = (wxRegion *) 0 ;
8182 wxRect result;
8183 void *argp1 = 0 ;
8184 int res1 = 0 ;
8185 PyObject *swig_obj[1] ;
8186
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_GetBox" "', expected argument " "1"" of type '" "wxRegion *""'");
8192 }
8193 arg1 = reinterpret_cast< wxRegion * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (arg1)->GetBox();
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_Region_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = 0;
8209 wxRegion *arg1 = (wxRegion *) 0 ;
8210 int arg2 ;
8211 int arg3 ;
8212 int arg4 ;
8213 int arg5 ;
8214 bool result;
8215 void *argp1 = 0 ;
8216 int res1 = 0 ;
8217 int val2 ;
8218 int ecode2 = 0 ;
8219 int val3 ;
8220 int ecode3 = 0 ;
8221 int val4 ;
8222 int ecode4 = 0 ;
8223 int val5 ;
8224 int ecode5 = 0 ;
8225 PyObject * obj0 = 0 ;
8226 PyObject * obj1 = 0 ;
8227 PyObject * obj2 = 0 ;
8228 PyObject * obj3 = 0 ;
8229 PyObject * obj4 = 0 ;
8230 char * kwnames[] = {
8231 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8232 };
8233
8234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Intersect" "', expected argument " "1"" of type '" "wxRegion *""'");
8238 }
8239 arg1 = reinterpret_cast< wxRegion * >(argp1);
8240 ecode2 = SWIG_AsVal_int(obj1, &val2);
8241 if (!SWIG_IsOK(ecode2)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Intersect" "', expected argument " "2"" of type '" "int""'");
8243 }
8244 arg2 = static_cast< int >(val2);
8245 ecode3 = SWIG_AsVal_int(obj2, &val3);
8246 if (!SWIG_IsOK(ecode3)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Intersect" "', expected argument " "3"" of type '" "int""'");
8248 }
8249 arg3 = static_cast< int >(val3);
8250 ecode4 = SWIG_AsVal_int(obj3, &val4);
8251 if (!SWIG_IsOK(ecode4)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Intersect" "', expected argument " "4"" of type '" "int""'");
8253 }
8254 arg4 = static_cast< int >(val4);
8255 ecode5 = SWIG_AsVal_int(obj4, &val5);
8256 if (!SWIG_IsOK(ecode5)) {
8257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Intersect" "', expected argument " "5"" of type '" "int""'");
8258 }
8259 arg5 = static_cast< int >(val5);
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 {
8267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8268 }
8269 return resultobj;
8270 fail:
8271 return NULL;
8272 }
8273
8274
8275 SWIGINTERN PyObject *_wrap_Region_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8276 PyObject *resultobj = 0;
8277 wxRegion *arg1 = (wxRegion *) 0 ;
8278 wxRect *arg2 = 0 ;
8279 bool result;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 wxRect temp2 ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char * kwnames[] = {
8286 (char *) "self",(char *) "rect", NULL
8287 };
8288
8289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8291 if (!SWIG_IsOK(res1)) {
8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8293 }
8294 arg1 = reinterpret_cast< wxRegion * >(argp1);
8295 {
8296 arg2 = &temp2;
8297 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8298 }
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8307 }
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *_wrap_Region_IntersectRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj = 0;
8316 wxRegion *arg1 = (wxRegion *) 0 ;
8317 wxRegion *arg2 = 0 ;
8318 bool result;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 void *argp2 = 0 ;
8322 int res2 = 0 ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char * kwnames[] = {
8326 (char *) "self",(char *) "region", NULL
8327 };
8328
8329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8331 if (!SWIG_IsOK(res1)) {
8332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8333 }
8334 arg1 = reinterpret_cast< wxRegion * >(argp1);
8335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8336 if (!SWIG_IsOK(res2)) {
8337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8338 }
8339 if (!argp2) {
8340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8341 }
8342 arg2 = reinterpret_cast< wxRegion * >(argp2);
8343 {
8344 PyThreadState* __tstate = wxPyBeginAllowThreads();
8345 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
8346 wxPyEndAllowThreads(__tstate);
8347 if (PyErr_Occurred()) SWIG_fail;
8348 }
8349 {
8350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8351 }
8352 return resultobj;
8353 fail:
8354 return NULL;
8355 }
8356
8357
8358 SWIGINTERN PyObject *_wrap_Region_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8359 PyObject *resultobj = 0;
8360 wxRegion *arg1 = (wxRegion *) 0 ;
8361 bool result;
8362 void *argp1 = 0 ;
8363 int res1 = 0 ;
8364 PyObject *swig_obj[1] ;
8365
8366 if (!args) SWIG_fail;
8367 swig_obj[0] = args;
8368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8369 if (!SWIG_IsOK(res1)) {
8370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IsEmpty" "', expected argument " "1"" of type '" "wxRegion *""'");
8371 }
8372 arg1 = reinterpret_cast< wxRegion * >(argp1);
8373 {
8374 PyThreadState* __tstate = wxPyBeginAllowThreads();
8375 result = (bool)(arg1)->IsEmpty();
8376 wxPyEndAllowThreads(__tstate);
8377 if (PyErr_Occurred()) SWIG_fail;
8378 }
8379 {
8380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8381 }
8382 return resultobj;
8383 fail:
8384 return NULL;
8385 }
8386
8387
8388 SWIGINTERN PyObject *_wrap_Region_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8389 PyObject *resultobj = 0;
8390 wxRegion *arg1 = (wxRegion *) 0 ;
8391 int arg2 ;
8392 int arg3 ;
8393 int arg4 ;
8394 int arg5 ;
8395 bool result;
8396 void *argp1 = 0 ;
8397 int res1 = 0 ;
8398 int val2 ;
8399 int ecode2 = 0 ;
8400 int val3 ;
8401 int ecode3 = 0 ;
8402 int val4 ;
8403 int ecode4 = 0 ;
8404 int val5 ;
8405 int ecode5 = 0 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 PyObject * obj2 = 0 ;
8409 PyObject * obj3 = 0 ;
8410 PyObject * obj4 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Union" "', expected argument " "1"" of type '" "wxRegion *""'");
8419 }
8420 arg1 = reinterpret_cast< wxRegion * >(argp1);
8421 ecode2 = SWIG_AsVal_int(obj1, &val2);
8422 if (!SWIG_IsOK(ecode2)) {
8423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Union" "', expected argument " "2"" of type '" "int""'");
8424 }
8425 arg2 = static_cast< int >(val2);
8426 ecode3 = SWIG_AsVal_int(obj2, &val3);
8427 if (!SWIG_IsOK(ecode3)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Union" "', expected argument " "3"" of type '" "int""'");
8429 }
8430 arg3 = static_cast< int >(val3);
8431 ecode4 = SWIG_AsVal_int(obj3, &val4);
8432 if (!SWIG_IsOK(ecode4)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Union" "', expected argument " "4"" of type '" "int""'");
8434 }
8435 arg4 = static_cast< int >(val4);
8436 ecode5 = SWIG_AsVal_int(obj4, &val5);
8437 if (!SWIG_IsOK(ecode5)) {
8438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Union" "', expected argument " "5"" of type '" "int""'");
8439 }
8440 arg5 = static_cast< int >(val5);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8449 }
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Region_UnionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxRegion *arg1 = (wxRegion *) 0 ;
8459 wxRect *arg2 = 0 ;
8460 bool result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxRect temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "rect", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8474 }
8475 arg1 = reinterpret_cast< wxRegion * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (bool)(arg1)->Union((wxRect const &)*arg2);
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 {
8487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8488 }
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Region_UnionRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8496 PyObject *resultobj = 0;
8497 wxRegion *arg1 = (wxRegion *) 0 ;
8498 wxRegion *arg2 = 0 ;
8499 bool result;
8500 void *argp1 = 0 ;
8501 int res1 = 0 ;
8502 void *argp2 = 0 ;
8503 int res2 = 0 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "region", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8514 }
8515 arg1 = reinterpret_cast< wxRegion * >(argp1);
8516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8517 if (!SWIG_IsOK(res2)) {
8518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8519 }
8520 if (!argp2) {
8521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8522 }
8523 arg2 = reinterpret_cast< wxRegion * >(argp2);
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 {
8531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8532 }
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 SWIGINTERN PyObject *_wrap_Region_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj = 0;
8541 wxRegion *arg1 = (wxRegion *) 0 ;
8542 int arg2 ;
8543 int arg3 ;
8544 int arg4 ;
8545 int arg5 ;
8546 bool result;
8547 void *argp1 = 0 ;
8548 int res1 = 0 ;
8549 int val2 ;
8550 int ecode2 = 0 ;
8551 int val3 ;
8552 int ecode3 = 0 ;
8553 int val4 ;
8554 int ecode4 = 0 ;
8555 int val5 ;
8556 int ecode5 = 0 ;
8557 PyObject * obj0 = 0 ;
8558 PyObject * obj1 = 0 ;
8559 PyObject * obj2 = 0 ;
8560 PyObject * obj3 = 0 ;
8561 PyObject * obj4 = 0 ;
8562 char * kwnames[] = {
8563 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8564 };
8565
8566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8568 if (!SWIG_IsOK(res1)) {
8569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Subtract" "', expected argument " "1"" of type '" "wxRegion *""'");
8570 }
8571 arg1 = reinterpret_cast< wxRegion * >(argp1);
8572 ecode2 = SWIG_AsVal_int(obj1, &val2);
8573 if (!SWIG_IsOK(ecode2)) {
8574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Subtract" "', expected argument " "2"" of type '" "int""'");
8575 }
8576 arg2 = static_cast< int >(val2);
8577 ecode3 = SWIG_AsVal_int(obj2, &val3);
8578 if (!SWIG_IsOK(ecode3)) {
8579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Subtract" "', expected argument " "3"" of type '" "int""'");
8580 }
8581 arg3 = static_cast< int >(val3);
8582 ecode4 = SWIG_AsVal_int(obj3, &val4);
8583 if (!SWIG_IsOK(ecode4)) {
8584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Subtract" "', expected argument " "4"" of type '" "int""'");
8585 }
8586 arg4 = static_cast< int >(val4);
8587 ecode5 = SWIG_AsVal_int(obj4, &val5);
8588 if (!SWIG_IsOK(ecode5)) {
8589 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Subtract" "', expected argument " "5"" of type '" "int""'");
8590 }
8591 arg5 = static_cast< int >(val5);
8592 {
8593 PyThreadState* __tstate = wxPyBeginAllowThreads();
8594 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 {
8599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8600 }
8601 return resultobj;
8602 fail:
8603 return NULL;
8604 }
8605
8606
8607 SWIGINTERN PyObject *_wrap_Region_SubtractRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj = 0;
8609 wxRegion *arg1 = (wxRegion *) 0 ;
8610 wxRect *arg2 = 0 ;
8611 bool result;
8612 void *argp1 = 0 ;
8613 int res1 = 0 ;
8614 wxRect temp2 ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 char * kwnames[] = {
8618 (char *) "self",(char *) "rect", NULL
8619 };
8620
8621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) SWIG_fail;
8622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8623 if (!SWIG_IsOK(res1)) {
8624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8625 }
8626 arg1 = reinterpret_cast< wxRegion * >(argp1);
8627 {
8628 arg2 = &temp2;
8629 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8630 }
8631 {
8632 PyThreadState* __tstate = wxPyBeginAllowThreads();
8633 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
8634 wxPyEndAllowThreads(__tstate);
8635 if (PyErr_Occurred()) SWIG_fail;
8636 }
8637 {
8638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8639 }
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Region_SubtractRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj = 0;
8648 wxRegion *arg1 = (wxRegion *) 0 ;
8649 wxRegion *arg2 = 0 ;
8650 bool result;
8651 void *argp1 = 0 ;
8652 int res1 = 0 ;
8653 void *argp2 = 0 ;
8654 int res2 = 0 ;
8655 PyObject * obj0 = 0 ;
8656 PyObject * obj1 = 0 ;
8657 char * kwnames[] = {
8658 (char *) "self",(char *) "region", NULL
8659 };
8660
8661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8663 if (!SWIG_IsOK(res1)) {
8664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8665 }
8666 arg1 = reinterpret_cast< wxRegion * >(argp1);
8667 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8668 if (!SWIG_IsOK(res2)) {
8669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8670 }
8671 if (!argp2) {
8672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8673 }
8674 arg2 = reinterpret_cast< wxRegion * >(argp2);
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 SWIGINTERN PyObject *_wrap_Region_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj = 0;
8692 wxRegion *arg1 = (wxRegion *) 0 ;
8693 int arg2 ;
8694 int arg3 ;
8695 int arg4 ;
8696 int arg5 ;
8697 bool result;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 int val2 ;
8701 int ecode2 = 0 ;
8702 int val3 ;
8703 int ecode3 = 0 ;
8704 int val4 ;
8705 int ecode4 = 0 ;
8706 int val5 ;
8707 int ecode5 = 0 ;
8708 PyObject * obj0 = 0 ;
8709 PyObject * obj1 = 0 ;
8710 PyObject * obj2 = 0 ;
8711 PyObject * obj3 = 0 ;
8712 PyObject * obj4 = 0 ;
8713 char * kwnames[] = {
8714 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8715 };
8716
8717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8719 if (!SWIG_IsOK(res1)) {
8720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Xor" "', expected argument " "1"" of type '" "wxRegion *""'");
8721 }
8722 arg1 = reinterpret_cast< wxRegion * >(argp1);
8723 ecode2 = SWIG_AsVal_int(obj1, &val2);
8724 if (!SWIG_IsOK(ecode2)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Xor" "', expected argument " "2"" of type '" "int""'");
8726 }
8727 arg2 = static_cast< int >(val2);
8728 ecode3 = SWIG_AsVal_int(obj2, &val3);
8729 if (!SWIG_IsOK(ecode3)) {
8730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Xor" "', expected argument " "3"" of type '" "int""'");
8731 }
8732 arg3 = static_cast< int >(val3);
8733 ecode4 = SWIG_AsVal_int(obj3, &val4);
8734 if (!SWIG_IsOK(ecode4)) {
8735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Xor" "', expected argument " "4"" of type '" "int""'");
8736 }
8737 arg4 = static_cast< int >(val4);
8738 ecode5 = SWIG_AsVal_int(obj4, &val5);
8739 if (!SWIG_IsOK(ecode5)) {
8740 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Xor" "', expected argument " "5"" of type '" "int""'");
8741 }
8742 arg5 = static_cast< int >(val5);
8743 {
8744 PyThreadState* __tstate = wxPyBeginAllowThreads();
8745 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 {
8750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8751 }
8752 return resultobj;
8753 fail:
8754 return NULL;
8755 }
8756
8757
8758 SWIGINTERN PyObject *_wrap_Region_XorRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj = 0;
8760 wxRegion *arg1 = (wxRegion *) 0 ;
8761 wxRect *arg2 = 0 ;
8762 bool result;
8763 void *argp1 = 0 ;
8764 int res1 = 0 ;
8765 wxRect temp2 ;
8766 PyObject * obj0 = 0 ;
8767 PyObject * obj1 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "rect", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8776 }
8777 arg1 = reinterpret_cast< wxRegion * >(argp1);
8778 {
8779 arg2 = &temp2;
8780 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8781 }
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 {
8789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8790 }
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Region_XorRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxRegion *arg1 = (wxRegion *) 0 ;
8800 wxRegion *arg2 = 0 ;
8801 bool result;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 void *argp2 = 0 ;
8805 int res2 = 0 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "self",(char *) "region", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8814 if (!SWIG_IsOK(res1)) {
8815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8816 }
8817 arg1 = reinterpret_cast< wxRegion * >(argp1);
8818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8819 if (!SWIG_IsOK(res2)) {
8820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8821 }
8822 if (!argp2) {
8823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8824 }
8825 arg2 = reinterpret_cast< wxRegion * >(argp2);
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 {
8833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8834 }
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_Region_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8842 PyObject *resultobj = 0;
8843 wxRegion *arg1 = (wxRegion *) 0 ;
8844 SwigValueWrapper<wxBitmap > result;
8845 void *argp1 = 0 ;
8846 int res1 = 0 ;
8847 PyObject *swig_obj[1] ;
8848
8849 if (!args) SWIG_fail;
8850 swig_obj[0] = args;
8851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ConvertToBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
8854 }
8855 arg1 = reinterpret_cast< wxRegion * >(argp1);
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (arg1)->ConvertToBitmap();
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Region_UnionBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj = 0;
8871 wxRegion *arg1 = (wxRegion *) 0 ;
8872 wxBitmap *arg2 = 0 ;
8873 bool result;
8874 void *argp1 = 0 ;
8875 int res1 = 0 ;
8876 void *argp2 = 0 ;
8877 int res2 = 0 ;
8878 PyObject * obj0 = 0 ;
8879 PyObject * obj1 = 0 ;
8880 char * kwnames[] = {
8881 (char *) "self",(char *) "bmp", NULL
8882 };
8883
8884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
8885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8886 if (!SWIG_IsOK(res1)) {
8887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
8888 }
8889 arg1 = reinterpret_cast< wxRegion * >(argp1);
8890 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
8891 if (!SWIG_IsOK(res2)) {
8892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8893 }
8894 if (!argp2) {
8895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8896 }
8897 arg2 = reinterpret_cast< wxBitmap * >(argp2);
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 {
8905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8906 }
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_Region_UnionBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj = 0;
8915 wxRegion *arg1 = (wxRegion *) 0 ;
8916 wxBitmap *arg2 = 0 ;
8917 wxColour *arg3 = 0 ;
8918 int arg4 = (int) 0 ;
8919 bool result;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 void *argp2 = 0 ;
8923 int res2 = 0 ;
8924 wxColour temp3 ;
8925 int val4 ;
8926 int ecode4 = 0 ;
8927 PyObject * obj0 = 0 ;
8928 PyObject * obj1 = 0 ;
8929 PyObject * obj2 = 0 ;
8930 PyObject * obj3 = 0 ;
8931 char * kwnames[] = {
8932 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
8933 };
8934
8935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8937 if (!SWIG_IsOK(res1)) {
8938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmapColour" "', expected argument " "1"" of type '" "wxRegion *""'");
8939 }
8940 arg1 = reinterpret_cast< wxRegion * >(argp1);
8941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
8942 if (!SWIG_IsOK(res2)) {
8943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8944 }
8945 if (!argp2) {
8946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8947 }
8948 arg2 = reinterpret_cast< wxBitmap * >(argp2);
8949 {
8950 arg3 = &temp3;
8951 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8952 }
8953 if (obj3) {
8954 ecode4 = SWIG_AsVal_int(obj3, &val4);
8955 if (!SWIG_IsOK(ecode4)) {
8956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_UnionBitmapColour" "', expected argument " "4"" of type '" "int""'");
8957 }
8958 arg4 = static_cast< int >(val4);
8959 }
8960 {
8961 PyThreadState* __tstate = wxPyBeginAllowThreads();
8962 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
8963 wxPyEndAllowThreads(__tstate);
8964 if (PyErr_Occurred()) SWIG_fail;
8965 }
8966 {
8967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8968 }
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *obj;
8977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8978 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegion, SWIG_NewClientData(obj));
8979 return SWIG_Py_Void();
8980 }
8981
8982 SWIGINTERN PyObject *Region_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8983 return SWIG_Python_InitShadowInstance(args);
8984 }
8985
8986 SWIGINTERN PyObject *_wrap_new_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = 0;
8988 wxRegion *arg1 = 0 ;
8989 wxRegionIterator *result = 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject * obj0 = 0 ;
8993 char * kwnames[] = {
8994 (char *) "region", NULL
8995 };
8996
8997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) SWIG_fail;
8998 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRegion, 0 | 0);
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
9001 }
9002 if (!argp1) {
9003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
9004 }
9005 arg1 = reinterpret_cast< wxRegion * >(argp1);
9006 {
9007 if (!wxPyCheckForApp()) SWIG_fail;
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_NEW | 0 );
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *_wrap_delete_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 PyObject *resultobj = 0;
9022 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject *swig_obj[1] ;
9026
9027 if (!args) SWIG_fail;
9028 swig_obj[0] = args;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_DISOWN | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegionIterator" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9032 }
9033 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 delete arg1;
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_Py_Void();
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_RegionIterator_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9051 int result;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 PyObject *swig_obj[1] ;
9055
9056 if (!args) SWIG_fail;
9057 swig_obj[0] = args;
9058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetX" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9061 }
9062 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 result = (int)(arg1)->GetX();
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_From_int(static_cast< int >(result));
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_RegionIterator_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9079 int result;
9080 void *argp1 = 0 ;
9081 int res1 = 0 ;
9082 PyObject *swig_obj[1] ;
9083
9084 if (!args) SWIG_fail;
9085 swig_obj[0] = args;
9086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9087 if (!SWIG_IsOK(res1)) {
9088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetY" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9089 }
9090 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 result = (int)(arg1)->GetY();
9094 wxPyEndAllowThreads(__tstate);
9095 if (PyErr_Occurred()) SWIG_fail;
9096 }
9097 resultobj = SWIG_From_int(static_cast< int >(result));
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 SWIGINTERN PyObject *_wrap_RegionIterator_GetW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 PyObject *resultobj = 0;
9106 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9107 int result;
9108 void *argp1 = 0 ;
9109 int res1 = 0 ;
9110 PyObject *swig_obj[1] ;
9111
9112 if (!args) SWIG_fail;
9113 swig_obj[0] = args;
9114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9115 if (!SWIG_IsOK(res1)) {
9116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetW" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9117 }
9118 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 result = (int)(arg1)->GetW();
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 resultobj = SWIG_From_int(static_cast< int >(result));
9126 return resultobj;
9127 fail:
9128 return NULL;
9129 }
9130
9131
9132 SWIGINTERN PyObject *_wrap_RegionIterator_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9133 PyObject *resultobj = 0;
9134 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9135 int result;
9136 void *argp1 = 0 ;
9137 int res1 = 0 ;
9138 PyObject *swig_obj[1] ;
9139
9140 if (!args) SWIG_fail;
9141 swig_obj[0] = args;
9142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetWidth" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9145 }
9146 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9147 {
9148 PyThreadState* __tstate = wxPyBeginAllowThreads();
9149 result = (int)(arg1)->GetWidth();
9150 wxPyEndAllowThreads(__tstate);
9151 if (PyErr_Occurred()) SWIG_fail;
9152 }
9153 resultobj = SWIG_From_int(static_cast< int >(result));
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_RegionIterator_GetH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9161 PyObject *resultobj = 0;
9162 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9163 int result;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 PyObject *swig_obj[1] ;
9167
9168 if (!args) SWIG_fail;
9169 swig_obj[0] = args;
9170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9171 if (!SWIG_IsOK(res1)) {
9172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetH" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9173 }
9174 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9175 {
9176 PyThreadState* __tstate = wxPyBeginAllowThreads();
9177 result = (int)(arg1)->GetH();
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 resultobj = SWIG_From_int(static_cast< int >(result));
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_RegionIterator_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9189 PyObject *resultobj = 0;
9190 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9191 int result;
9192 void *argp1 = 0 ;
9193 int res1 = 0 ;
9194 PyObject *swig_obj[1] ;
9195
9196 if (!args) SWIG_fail;
9197 swig_obj[0] = args;
9198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9199 if (!SWIG_IsOK(res1)) {
9200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetHeight" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9201 }
9202 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 result = (int)(arg1)->GetHeight();
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_From_int(static_cast< int >(result));
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_RegionIterator_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9217 PyObject *resultobj = 0;
9218 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9219 wxRect result;
9220 void *argp1 = 0 ;
9221 int res1 = 0 ;
9222 PyObject *swig_obj[1] ;
9223
9224 if (!args) SWIG_fail;
9225 swig_obj[0] = args;
9226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9227 if (!SWIG_IsOK(res1)) {
9228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetRect" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9229 }
9230 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (arg1)->GetRect();
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_RegionIterator_HaveRects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 PyObject *resultobj = 0;
9246 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9247 bool result;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 PyObject *swig_obj[1] ;
9251
9252 if (!args) SWIG_fail;
9253 swig_obj[0] = args;
9254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9255 if (!SWIG_IsOK(res1)) {
9256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_HaveRects" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9257 }
9258 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = (bool)(arg1)->HaveRects();
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 {
9266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9267 }
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_RegionIterator_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *resultobj = 0;
9276 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Reset" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9286 }
9287 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 (arg1)->Reset();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_Py_Void();
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 SWIGINTERN PyObject *_wrap_RegionIterator_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9302 PyObject *resultobj = 0;
9303 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 PyObject *swig_obj[1] ;
9307
9308 if (!args) SWIG_fail;
9309 swig_obj[0] = args;
9310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Next" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9313 }
9314 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 wxRegionIterator_Next(arg1);
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_Py_Void();
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_RegionIterator___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9331 bool result;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 PyObject *swig_obj[1] ;
9335
9336 if (!args) SWIG_fail;
9337 swig_obj[0] = args;
9338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator___nonzero__" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9341 }
9342 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (bool)wxRegionIterator___nonzero__(arg1);
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 {
9350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9351 }
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *RegionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *obj;
9360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9361 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegionIterator, SWIG_NewClientData(obj));
9362 return SWIG_Py_Void();
9363 }
9364
9365 SWIGINTERN PyObject *RegionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9366 return SWIG_Python_InitShadowInstance(args);
9367 }
9368
9369 SWIGINTERN PyObject *_wrap_new_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxNativeFontInfo *result = 0 ;
9372
9373 if (!SWIG_Python_UnpackTuple(args,"new_NativeFontInfo",0,0,0)) SWIG_fail;
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (wxNativeFontInfo *)new wxNativeFontInfo();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_NEW | 0 );
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_delete_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 PyObject *swig_obj[1] ;
9393
9394 if (!args) SWIG_fail;
9395 swig_obj[0] = args;
9396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_DISOWN | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeFontInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9399 }
9400 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 delete arg1;
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_Py_Void();
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_NativeFontInfo_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9418 void *argp1 = 0 ;
9419 int res1 = 0 ;
9420 PyObject *swig_obj[1] ;
9421
9422 if (!args) SWIG_fail;
9423 swig_obj[0] = args;
9424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_Init" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9427 }
9428 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 (arg1)->Init();
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_Py_Void();
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = 0;
9444 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9445 wxFont *arg2 = 0 ;
9446 void *argp1 = 0 ;
9447 int res1 = 0 ;
9448 void *argp2 = 0 ;
9449 int res2 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "font", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9460 }
9461 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
9463 if (!SWIG_IsOK(res2)) {
9464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
9465 }
9466 if (!argp2) {
9467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
9468 }
9469 arg2 = reinterpret_cast< wxFont * >(argp2);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 (arg1)->InitFromFont((wxFont const &)*arg2);
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 resultobj = SWIG_Py_Void();
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9484 PyObject *resultobj = 0;
9485 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9486 int result;
9487 void *argp1 = 0 ;
9488 int res1 = 0 ;
9489 PyObject *swig_obj[1] ;
9490
9491 if (!args) SWIG_fail;
9492 swig_obj[0] = args;
9493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9494 if (!SWIG_IsOK(res1)) {
9495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9496 }
9497 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
9501 wxPyEndAllowThreads(__tstate);
9502 if (PyErr_Occurred()) SWIG_fail;
9503 }
9504 resultobj = SWIG_From_int(static_cast< int >(result));
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9512 PyObject *resultobj = 0;
9513 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9514 wxFontStyle result;
9515 void *argp1 = 0 ;
9516 int res1 = 0 ;
9517 PyObject *swig_obj[1] ;
9518
9519 if (!args) SWIG_fail;
9520 swig_obj[0] = args;
9521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9524 }
9525 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_From_int(static_cast< int >(result));
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9540 PyObject *resultobj = 0;
9541 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9542 wxFontWeight result;
9543 void *argp1 = 0 ;
9544 int res1 = 0 ;
9545 PyObject *swig_obj[1] ;
9546
9547 if (!args) SWIG_fail;
9548 swig_obj[0] = args;
9549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9552 }
9553 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
9557 wxPyEndAllowThreads(__tstate);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_From_int(static_cast< int >(result));
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9568 PyObject *resultobj = 0;
9569 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9570 bool result;
9571 void *argp1 = 0 ;
9572 int res1 = 0 ;
9573 PyObject *swig_obj[1] ;
9574
9575 if (!args) SWIG_fail;
9576 swig_obj[0] = args;
9577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9580 }
9581 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 {
9589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9590 }
9591 return resultobj;
9592 fail:
9593 return NULL;
9594 }
9595
9596
9597 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9598 PyObject *resultobj = 0;
9599 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9600 wxString result;
9601 void *argp1 = 0 ;
9602 int res1 = 0 ;
9603 PyObject *swig_obj[1] ;
9604
9605 if (!args) SWIG_fail;
9606 swig_obj[0] = args;
9607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9608 if (!SWIG_IsOK(res1)) {
9609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9610 }
9611 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 {
9619 #if wxUSE_UNICODE
9620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9621 #else
9622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9623 #endif
9624 }
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9634 wxFontFamily result;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9644 }
9645 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 resultobj = SWIG_From_int(static_cast< int >(result));
9653 return resultobj;
9654 fail:
9655 return NULL;
9656 }
9657
9658
9659 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9660 PyObject *resultobj = 0;
9661 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9662 wxFontEncoding result;
9663 void *argp1 = 0 ;
9664 int res1 = 0 ;
9665 PyObject *swig_obj[1] ;
9666
9667 if (!args) SWIG_fail;
9668 swig_obj[0] = args;
9669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9670 if (!SWIG_IsOK(res1)) {
9671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9672 }
9673 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9674 {
9675 PyThreadState* __tstate = wxPyBeginAllowThreads();
9676 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
9677 wxPyEndAllowThreads(__tstate);
9678 if (PyErr_Occurred()) SWIG_fail;
9679 }
9680 resultobj = SWIG_From_int(static_cast< int >(result));
9681 return resultobj;
9682 fail:
9683 return NULL;
9684 }
9685
9686
9687 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj = 0;
9689 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9690 int arg2 ;
9691 void *argp1 = 0 ;
9692 int res1 = 0 ;
9693 int val2 ;
9694 int ecode2 = 0 ;
9695 PyObject * obj0 = 0 ;
9696 PyObject * obj1 = 0 ;
9697 char * kwnames[] = {
9698 (char *) "self",(char *) "pointsize", NULL
9699 };
9700
9701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
9702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9703 if (!SWIG_IsOK(res1)) {
9704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9705 }
9706 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9707 ecode2 = SWIG_AsVal_int(obj1, &val2);
9708 if (!SWIG_IsOK(ecode2)) {
9709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "2"" of type '" "int""'");
9710 }
9711 arg2 = static_cast< int >(val2);
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 (arg1)->SetPointSize(arg2);
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 resultobj = SWIG_Py_Void();
9719 return resultobj;
9720 fail:
9721 return NULL;
9722 }
9723
9724
9725 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9726 PyObject *resultobj = 0;
9727 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9728 wxFontStyle arg2 ;
9729 void *argp1 = 0 ;
9730 int res1 = 0 ;
9731 int val2 ;
9732 int ecode2 = 0 ;
9733 PyObject * obj0 = 0 ;
9734 PyObject * obj1 = 0 ;
9735 char * kwnames[] = {
9736 (char *) "self",(char *) "style", NULL
9737 };
9738
9739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
9740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9741 if (!SWIG_IsOK(res1)) {
9742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9743 }
9744 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9745 ecode2 = SWIG_AsVal_int(obj1, &val2);
9746 if (!SWIG_IsOK(ecode2)) {
9747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
9748 }
9749 arg2 = static_cast< wxFontStyle >(val2);
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 (arg1)->SetStyle(arg2);
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 resultobj = SWIG_Py_Void();
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj = 0;
9765 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9766 wxFontWeight arg2 ;
9767 void *argp1 = 0 ;
9768 int res1 = 0 ;
9769 int val2 ;
9770 int ecode2 = 0 ;
9771 PyObject * obj0 = 0 ;
9772 PyObject * obj1 = 0 ;
9773 char * kwnames[] = {
9774 (char *) "self",(char *) "weight", NULL
9775 };
9776
9777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
9778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9779 if (!SWIG_IsOK(res1)) {
9780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9781 }
9782 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9783 ecode2 = SWIG_AsVal_int(obj1, &val2);
9784 if (!SWIG_IsOK(ecode2)) {
9785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
9786 }
9787 arg2 = static_cast< wxFontWeight >(val2);
9788 {
9789 PyThreadState* __tstate = wxPyBeginAllowThreads();
9790 (arg1)->SetWeight(arg2);
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 resultobj = SWIG_Py_Void();
9795 return resultobj;
9796 fail:
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9802 PyObject *resultobj = 0;
9803 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9804 bool arg2 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 bool val2 ;
9808 int ecode2 = 0 ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 char * kwnames[] = {
9812 (char *) "self",(char *) "underlined", NULL
9813 };
9814
9815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
9816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9819 }
9820 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
9822 if (!SWIG_IsOK(ecode2)) {
9823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
9824 }
9825 arg2 = static_cast< bool >(val2);
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 (arg1)->SetUnderlined(arg2);
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_Py_Void();
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9840 PyObject *resultobj = 0;
9841 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9842 wxString arg2 ;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject * obj0 = 0 ;
9846 PyObject * obj1 = 0 ;
9847 char * kwnames[] = {
9848 (char *) "self",(char *) "facename", NULL
9849 };
9850
9851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
9852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9853 if (!SWIG_IsOK(res1)) {
9854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9855 }
9856 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9857 {
9858 wxString* sptr = wxString_in_helper(obj1);
9859 if (sptr == NULL) SWIG_fail;
9860 arg2 = *sptr;
9861 delete sptr;
9862 }
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 (arg1)->SetFaceName(arg2);
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9879 wxFontFamily arg2 ;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 int val2 ;
9883 int ecode2 = 0 ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 char * kwnames[] = {
9887 (char *) "self",(char *) "family", NULL
9888 };
9889
9890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
9891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9894 }
9895 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9896 ecode2 = SWIG_AsVal_int(obj1, &val2);
9897 if (!SWIG_IsOK(ecode2)) {
9898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
9899 }
9900 arg2 = static_cast< wxFontFamily >(val2);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 (arg1)->SetFamily(arg2);
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_Py_Void();
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9917 wxFontEncoding arg2 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 int val2 ;
9921 int ecode2 = 0 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "encoding", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9932 }
9933 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9934 ecode2 = SWIG_AsVal_int(obj1, &val2);
9935 if (!SWIG_IsOK(ecode2)) {
9936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
9937 }
9938 arg2 = static_cast< wxFontEncoding >(val2);
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 (arg1)->SetEncoding(arg2);
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_Py_Void();
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9955 wxString *arg2 = 0 ;
9956 bool result;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 bool temp2 = false ;
9960 PyObject * obj0 = 0 ;
9961 PyObject * obj1 = 0 ;
9962 char * kwnames[] = {
9963 (char *) "self",(char *) "s", NULL
9964 };
9965
9966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
9967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9968 if (!SWIG_IsOK(res1)) {
9969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9970 }
9971 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9972 {
9973 arg2 = wxString_in_helper(obj1);
9974 if (arg2 == NULL) SWIG_fail;
9975 temp2 = true;
9976 }
9977 {
9978 PyThreadState* __tstate = wxPyBeginAllowThreads();
9979 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9980 wxPyEndAllowThreads(__tstate);
9981 if (PyErr_Occurred()) SWIG_fail;
9982 }
9983 {
9984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9985 }
9986 {
9987 if (temp2)
9988 delete arg2;
9989 }
9990 return resultobj;
9991 fail:
9992 {
9993 if (temp2)
9994 delete arg2;
9995 }
9996 return NULL;
9997 }
9998
9999
10000 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10001 PyObject *resultobj = 0;
10002 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10003 wxString result;
10004 void *argp1 = 0 ;
10005 int res1 = 0 ;
10006 PyObject *swig_obj[1] ;
10007
10008 if (!args) SWIG_fail;
10009 swig_obj[0] = args;
10010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10011 if (!SWIG_IsOK(res1)) {
10012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
10013 }
10014 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = ((wxNativeFontInfo const *)arg1)->ToString();
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 {
10022 #if wxUSE_UNICODE
10023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10024 #else
10025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10026 #endif
10027 }
10028 return resultobj;
10029 fail:
10030 return NULL;
10031 }
10032
10033
10034 SWIGINTERN PyObject *_wrap_NativeFontInfo___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10035 PyObject *resultobj = 0;
10036 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10037 wxString result;
10038 void *argp1 = 0 ;
10039 int res1 = 0 ;
10040 PyObject *swig_obj[1] ;
10041
10042 if (!args) SWIG_fail;
10043 swig_obj[0] = args;
10044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo___str__" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
10047 }
10048 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10049 {
10050 PyThreadState* __tstate = wxPyBeginAllowThreads();
10051 result = wxNativeFontInfo___str__(arg1);
10052 wxPyEndAllowThreads(__tstate);
10053 if (PyErr_Occurred()) SWIG_fail;
10054 }
10055 {
10056 #if wxUSE_UNICODE
10057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10058 #else
10059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10060 #endif
10061 }
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10071 wxString *arg2 = 0 ;
10072 bool result;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 bool temp2 = false ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "s", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
10086 }
10087 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10088 {
10089 arg2 = wxString_in_helper(obj1);
10090 if (arg2 == NULL) SWIG_fail;
10091 temp2 = true;
10092 }
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 {
10100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10101 }
10102 {
10103 if (temp2)
10104 delete arg2;
10105 }
10106 return resultobj;
10107 fail:
10108 {
10109 if (temp2)
10110 delete arg2;
10111 }
10112 return NULL;
10113 }
10114
10115
10116 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117 PyObject *resultobj = 0;
10118 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10119 wxString result;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 PyObject *swig_obj[1] ;
10123
10124 if (!args) SWIG_fail;
10125 swig_obj[0] = args;
10126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10127 if (!SWIG_IsOK(res1)) {
10128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
10129 }
10130 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 {
10138 #if wxUSE_UNICODE
10139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10140 #else
10141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10142 #endif
10143 }
10144 return resultobj;
10145 fail:
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *NativeFontInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10151 PyObject *obj;
10152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10153 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeFontInfo, SWIG_NewClientData(obj));
10154 return SWIG_Py_Void();
10155 }
10156
10157 SWIGINTERN PyObject *NativeFontInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10158 return SWIG_Python_InitShadowInstance(args);
10159 }
10160
10161 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10162 PyObject *resultobj = 0;
10163 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10164 wxString *arg2 = (wxString *) 0 ;
10165 void *argp1 = 0 ;
10166 int res1 = 0 ;
10167 bool temp2 = false ;
10168 PyObject *swig_obj[2] ;
10169
10170 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_facename_set",2,2,swig_obj)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10174 }
10175 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10176 {
10177 arg2 = wxString_in_helper(swig_obj[1]);
10178 if (arg2 == NULL) SWIG_fail;
10179 temp2 = true;
10180 }
10181 if (arg1) (arg1)->facename = *arg2;
10182
10183 resultobj = SWIG_Py_Void();
10184 {
10185 if (temp2)
10186 delete arg2;
10187 }
10188 return resultobj;
10189 fail:
10190 {
10191 if (temp2)
10192 delete arg2;
10193 }
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10199 PyObject *resultobj = 0;
10200 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10201 wxString *result = 0 ;
10202 void *argp1 = 0 ;
10203 int res1 = 0 ;
10204 PyObject *swig_obj[1] ;
10205
10206 if (!args) SWIG_fail;
10207 swig_obj[0] = args;
10208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10209 if (!SWIG_IsOK(res1)) {
10210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10211 }
10212 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10213 result = (wxString *)& ((arg1)->facename);
10214 {
10215 #if wxUSE_UNICODE
10216 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10217 #else
10218 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10219 #endif
10220 }
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10228 PyObject *resultobj = 0;
10229 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10230 wxFontEncoding arg2 ;
10231 void *argp1 = 0 ;
10232 int res1 = 0 ;
10233 int val2 ;
10234 int ecode2 = 0 ;
10235 PyObject *swig_obj[2] ;
10236
10237 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_encoding_set",2,2,swig_obj)) SWIG_fail;
10238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10239 if (!SWIG_IsOK(res1)) {
10240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10241 }
10242 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10243 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10244 if (!SWIG_IsOK(ecode2)) {
10245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10246 }
10247 arg2 = static_cast< wxFontEncoding >(val2);
10248 if (arg1) (arg1)->encoding = arg2;
10249
10250 resultobj = SWIG_Py_Void();
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10258 PyObject *resultobj = 0;
10259 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10260 wxFontEncoding result;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 PyObject *swig_obj[1] ;
10264
10265 if (!args) SWIG_fail;
10266 swig_obj[0] = args;
10267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10270 }
10271 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10272 result = (wxFontEncoding) ((arg1)->encoding);
10273 resultobj = SWIG_From_int(static_cast< int >(result));
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 SWIGINTERN PyObject *_wrap_new_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10281 PyObject *resultobj = 0;
10282 wxNativeEncodingInfo *result = 0 ;
10283
10284 if (!SWIG_Python_UnpackTuple(args,"new_NativeEncodingInfo",0,0,0)) SWIG_fail;
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_NEW | 0 );
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_delete_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10299 PyObject *resultobj = 0;
10300 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 PyObject *swig_obj[1] ;
10304
10305 if (!args) SWIG_fail;
10306 swig_obj[0] = args;
10307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_DISOWN | 0 );
10308 if (!SWIG_IsOK(res1)) {
10309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeEncodingInfo" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10310 }
10311 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 delete arg1;
10315
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 resultobj = SWIG_Py_Void();
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10327 PyObject *resultobj = 0;
10328 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10329 wxString *arg2 = 0 ;
10330 bool result;
10331 void *argp1 = 0 ;
10332 int res1 = 0 ;
10333 bool temp2 = false ;
10334 PyObject * obj0 = 0 ;
10335 PyObject * obj1 = 0 ;
10336 char * kwnames[] = {
10337 (char *) "self",(char *) "s", NULL
10338 };
10339
10340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
10341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10342 if (!SWIG_IsOK(res1)) {
10343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_FromString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10344 }
10345 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10346 {
10347 arg2 = wxString_in_helper(obj1);
10348 if (arg2 == NULL) SWIG_fail;
10349 temp2 = true;
10350 }
10351 {
10352 PyThreadState* __tstate = wxPyBeginAllowThreads();
10353 result = (bool)(arg1)->FromString((wxString const &)*arg2);
10354 wxPyEndAllowThreads(__tstate);
10355 if (PyErr_Occurred()) SWIG_fail;
10356 }
10357 {
10358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10359 }
10360 {
10361 if (temp2)
10362 delete arg2;
10363 }
10364 return resultobj;
10365 fail:
10366 {
10367 if (temp2)
10368 delete arg2;
10369 }
10370 return NULL;
10371 }
10372
10373
10374 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10375 PyObject *resultobj = 0;
10376 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10377 wxString result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 PyObject *swig_obj[1] ;
10381
10382 if (!args) SWIG_fail;
10383 swig_obj[0] = args;
10384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10385 if (!SWIG_IsOK(res1)) {
10386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_ToString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const *""'");
10387 }
10388 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10389 {
10390 PyThreadState* __tstate = wxPyBeginAllowThreads();
10391 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
10392 wxPyEndAllowThreads(__tstate);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 {
10396 #if wxUSE_UNICODE
10397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10398 #else
10399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10400 #endif
10401 }
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 SWIGINTERN PyObject *NativeEncodingInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10409 PyObject *obj;
10410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10411 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeEncodingInfo, SWIG_NewClientData(obj));
10412 return SWIG_Py_Void();
10413 }
10414
10415 SWIGINTERN PyObject *NativeEncodingInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10416 return SWIG_Python_InitShadowInstance(args);
10417 }
10418
10419 SWIGINTERN PyObject *_wrap_GetNativeFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10420 PyObject *resultobj = 0;
10421 wxFontEncoding arg1 ;
10422 wxNativeEncodingInfo *result = 0 ;
10423 int val1 ;
10424 int ecode1 = 0 ;
10425 PyObject * obj0 = 0 ;
10426 char * kwnames[] = {
10427 (char *) "encoding", NULL
10428 };
10429
10430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) SWIG_fail;
10431 ecode1 = SWIG_AsVal_int(obj0, &val1);
10432 if (!SWIG_IsOK(ecode1)) {
10433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetNativeFontEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10434 }
10435 arg1 = static_cast< wxFontEncoding >(val1);
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding(arg1);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 SWIGINTERN PyObject *_wrap_TestFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10450 PyObject *resultobj = 0;
10451 wxNativeEncodingInfo *arg1 = 0 ;
10452 bool result;
10453 void *argp1 = 0 ;
10454 int res1 = 0 ;
10455 PyObject * obj0 = 0 ;
10456 char * kwnames[] = {
10457 (char *) "info", NULL
10458 };
10459
10460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0);
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
10464 }
10465 if (!argp1) {
10466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
10467 }
10468 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_new_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxFontMapper *result = 0 ;
10487
10488 if (!SWIG_Python_UnpackTuple(args,"new_FontMapper",0,0,0)) SWIG_fail;
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (wxFontMapper *)new wxFontMapper();
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, SWIG_POINTER_NEW | 0 );
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 SWIGINTERN PyObject *_wrap_delete_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10503 PyObject *resultobj = 0;
10504 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10505 void *argp1 = 0 ;
10506 int res1 = 0 ;
10507 PyObject *swig_obj[1] ;
10508
10509 if (!args) SWIG_fail;
10510 swig_obj[0] = args;
10511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontMapper, SWIG_POINTER_DISOWN | 0 );
10512 if (!SWIG_IsOK(res1)) {
10513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontMapper" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10514 }
10515 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 delete arg1;
10519
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 resultobj = SWIG_Py_Void();
10524 return resultobj;
10525 fail:
10526 return NULL;
10527 }
10528
10529
10530 SWIGINTERN PyObject *_wrap_FontMapper_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10531 PyObject *resultobj = 0;
10532 wxFontMapper *result = 0 ;
10533
10534 if (!SWIG_Python_UnpackTuple(args,"FontMapper_Get",0,0,0)) SWIG_fail;
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 result = (wxFontMapper *)wxFontMapper::Get();
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_FontMapper_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10549 PyObject *resultobj = 0;
10550 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10551 wxFontMapper *result = 0 ;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject * obj0 = 0 ;
10555 char * kwnames[] = {
10556 (char *) "mapper", NULL
10557 };
10558
10559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) SWIG_fail;
10560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_Set" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10563 }
10564 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (wxFontMapper *)wxFontMapper::Set(arg1);
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 SWIGINTERN PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10579 PyObject *resultobj = 0;
10580 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10581 wxString *arg2 = 0 ;
10582 bool arg3 = (bool) true ;
10583 wxFontEncoding result;
10584 void *argp1 = 0 ;
10585 int res1 = 0 ;
10586 bool temp2 = false ;
10587 bool val3 ;
10588 int ecode3 = 0 ;
10589 PyObject * obj0 = 0 ;
10590 PyObject * obj1 = 0 ;
10591 PyObject * obj2 = 0 ;
10592 char * kwnames[] = {
10593 (char *) "self",(char *) "charset",(char *) "interactive", NULL
10594 };
10595
10596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10598 if (!SWIG_IsOK(res1)) {
10599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10600 }
10601 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10602 {
10603 arg2 = wxString_in_helper(obj1);
10604 if (arg2 == NULL) SWIG_fail;
10605 temp2 = true;
10606 }
10607 if (obj2) {
10608 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10609 if (!SWIG_IsOK(ecode3)) {
10610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "3"" of type '" "bool""'");
10611 }
10612 arg3 = static_cast< bool >(val3);
10613 }
10614 {
10615 PyThreadState* __tstate = wxPyBeginAllowThreads();
10616 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 resultobj = SWIG_From_int(static_cast< int >(result));
10621 {
10622 if (temp2)
10623 delete arg2;
10624 }
10625 return resultobj;
10626 fail:
10627 {
10628 if (temp2)
10629 delete arg2;
10630 }
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10636 PyObject *resultobj = 0;
10637 size_t result;
10638
10639 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetSupportedEncodingsCount",0,0,0)) SWIG_fail;
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 SWIGINTERN PyObject *_wrap_FontMapper_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj = 0;
10655 size_t arg1 ;
10656 wxFontEncoding result;
10657 size_t val1 ;
10658 int ecode1 = 0 ;
10659 PyObject * obj0 = 0 ;
10660 char * kwnames[] = {
10661 (char *) "n", NULL
10662 };
10663
10664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) SWIG_fail;
10665 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10666 if (!SWIG_IsOK(ecode1)) {
10667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncoding" "', expected argument " "1"" of type '" "size_t""'");
10668 }
10669 arg1 = static_cast< size_t >(val1);
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 resultobj = SWIG_From_int(static_cast< int >(result));
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10684 PyObject *resultobj = 0;
10685 wxFontEncoding arg1 ;
10686 wxString result;
10687 int val1 ;
10688 int ecode1 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 char * kwnames[] = {
10691 (char *) "encoding", NULL
10692 };
10693
10694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) SWIG_fail;
10695 ecode1 = SWIG_AsVal_int(obj0, &val1);
10696 if (!SWIG_IsOK(ecode1)) {
10697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingName" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10698 }
10699 arg1 = static_cast< wxFontEncoding >(val1);
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = wxFontMapper::GetEncodingName(arg1);
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 #if wxUSE_UNICODE
10708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10709 #else
10710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10711 #endif
10712 }
10713 return resultobj;
10714 fail:
10715 return NULL;
10716 }
10717
10718
10719 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10720 PyObject *resultobj = 0;
10721 wxFontEncoding arg1 ;
10722 wxString result;
10723 int val1 ;
10724 int ecode1 = 0 ;
10725 PyObject * obj0 = 0 ;
10726 char * kwnames[] = {
10727 (char *) "encoding", NULL
10728 };
10729
10730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) SWIG_fail;
10731 ecode1 = SWIG_AsVal_int(obj0, &val1);
10732 if (!SWIG_IsOK(ecode1)) {
10733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingDescription" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10734 }
10735 arg1 = static_cast< wxFontEncoding >(val1);
10736 {
10737 PyThreadState* __tstate = wxPyBeginAllowThreads();
10738 result = wxFontMapper::GetEncodingDescription(arg1);
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 {
10743 #if wxUSE_UNICODE
10744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10745 #else
10746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10747 #endif
10748 }
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj = 0;
10757 wxString *arg1 = 0 ;
10758 wxFontEncoding result;
10759 bool temp1 = false ;
10760 PyObject * obj0 = 0 ;
10761 char * kwnames[] = {
10762 (char *) "name", NULL
10763 };
10764
10765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) SWIG_fail;
10766 {
10767 arg1 = wxString_in_helper(obj0);
10768 if (arg1 == NULL) SWIG_fail;
10769 temp1 = true;
10770 }
10771 {
10772 PyThreadState* __tstate = wxPyBeginAllowThreads();
10773 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_From_int(static_cast< int >(result));
10778 {
10779 if (temp1)
10780 delete arg1;
10781 }
10782 return resultobj;
10783 fail:
10784 {
10785 if (temp1)
10786 delete arg1;
10787 }
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FontMapper_SetConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10795 wxString *arg2 = 0 ;
10796 void *argp1 = 0 ;
10797 int res1 = 0 ;
10798 bool temp2 = false ;
10799 PyObject * obj0 = 0 ;
10800 PyObject * obj1 = 0 ;
10801 char * kwnames[] = {
10802 (char *) "self",(char *) "prefix", NULL
10803 };
10804
10805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) SWIG_fail;
10806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10807 if (!SWIG_IsOK(res1)) {
10808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetConfigPath" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10809 }
10810 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10811 {
10812 arg2 = wxString_in_helper(obj1);
10813 if (arg2 == NULL) SWIG_fail;
10814 temp2 = true;
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 (arg1)->SetConfigPath((wxString const &)*arg2);
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 resultobj = SWIG_Py_Void();
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return resultobj;
10828 fail:
10829 {
10830 if (temp2)
10831 delete arg2;
10832 }
10833 return NULL;
10834 }
10835
10836
10837 SWIGINTERN PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10838 PyObject *resultobj = 0;
10839 wxString result;
10840
10841 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetDefaultConfigPath",0,0,0)) SWIG_fail;
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = wxFontMapper::GetDefaultConfigPath();
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 #if wxUSE_UNICODE
10850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10851 #else
10852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10853 #endif
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10864 wxFontEncoding arg2 ;
10865 wxString const &arg3_defvalue = wxPyEmptyString ;
10866 wxString *arg3 = (wxString *) &arg3_defvalue ;
10867 bool arg4 = (bool) true ;
10868 PyObject *result = 0 ;
10869 void *argp1 = 0 ;
10870 int res1 = 0 ;
10871 int val2 ;
10872 int ecode2 = 0 ;
10873 bool temp3 = false ;
10874 bool val4 ;
10875 int ecode4 = 0 ;
10876 PyObject * obj0 = 0 ;
10877 PyObject * obj1 = 0 ;
10878 PyObject * obj2 = 0 ;
10879 PyObject * obj3 = 0 ;
10880 char * kwnames[] = {
10881 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
10882 };
10883
10884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10888 }
10889 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10890 ecode2 = SWIG_AsVal_int(obj1, &val2);
10891 if (!SWIG_IsOK(ecode2)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10893 }
10894 arg2 = static_cast< wxFontEncoding >(val2);
10895 if (obj2) {
10896 {
10897 arg3 = wxString_in_helper(obj2);
10898 if (arg3 == NULL) SWIG_fail;
10899 temp3 = true;
10900 }
10901 }
10902 if (obj3) {
10903 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10904 if (!SWIG_IsOK(ecode4)) {
10905 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "4"" of type '" "bool""'");
10906 }
10907 arg4 = static_cast< bool >(val4);
10908 }
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,arg2,(wxString const &)*arg3,arg4);
10912 wxPyEndAllowThreads(__tstate);
10913 if (PyErr_Occurred()) SWIG_fail;
10914 }
10915 resultobj = result;
10916 {
10917 if (temp3)
10918 delete arg3;
10919 }
10920 return resultobj;
10921 fail:
10922 {
10923 if (temp3)
10924 delete arg3;
10925 }
10926 return NULL;
10927 }
10928
10929
10930 SWIGINTERN PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10931 PyObject *resultobj = 0;
10932 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10933 wxFontEncoding arg2 ;
10934 wxString const &arg3_defvalue = wxPyEmptyString ;
10935 wxString *arg3 = (wxString *) &arg3_defvalue ;
10936 bool result;
10937 void *argp1 = 0 ;
10938 int res1 = 0 ;
10939 int val2 ;
10940 int ecode2 = 0 ;
10941 bool temp3 = false ;
10942 PyObject * obj0 = 0 ;
10943 PyObject * obj1 = 0 ;
10944 PyObject * obj2 = 0 ;
10945 char * kwnames[] = {
10946 (char *) "self",(char *) "encoding",(char *) "facename", NULL
10947 };
10948
10949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10951 if (!SWIG_IsOK(res1)) {
10952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10953 }
10954 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10955 ecode2 = SWIG_AsVal_int(obj1, &val2);
10956 if (!SWIG_IsOK(ecode2)) {
10957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10958 }
10959 arg2 = static_cast< wxFontEncoding >(val2);
10960 if (obj2) {
10961 {
10962 arg3 = wxString_in_helper(obj2);
10963 if (arg3 == NULL) SWIG_fail;
10964 temp3 = true;
10965 }
10966 }
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 result = (bool)(arg1)->IsEncodingAvailable(arg2,(wxString const &)*arg3);
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 {
10974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10975 }
10976 {
10977 if (temp3)
10978 delete arg3;
10979 }
10980 return resultobj;
10981 fail:
10982 {
10983 if (temp3)
10984 delete arg3;
10985 }
10986 return NULL;
10987 }
10988
10989
10990 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj = 0;
10992 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10993 wxWindow *arg2 = (wxWindow *) 0 ;
10994 void *argp1 = 0 ;
10995 int res1 = 0 ;
10996 void *argp2 = 0 ;
10997 int res2 = 0 ;
10998 PyObject * obj0 = 0 ;
10999 PyObject * obj1 = 0 ;
11000 char * kwnames[] = {
11001 (char *) "self",(char *) "parent", NULL
11002 };
11003
11004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) SWIG_fail;
11005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
11006 if (!SWIG_IsOK(res1)) {
11007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogParent" "', expected argument " "1"" of type '" "wxFontMapper *""'");
11008 }
11009 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
11010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
11011 if (!SWIG_IsOK(res2)) {
11012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontMapper_SetDialogParent" "', expected argument " "2"" of type '" "wxWindow *""'");
11013 }
11014 arg2 = reinterpret_cast< wxWindow * >(argp2);
11015 {
11016 PyThreadState* __tstate = wxPyBeginAllowThreads();
11017 (arg1)->SetDialogParent(arg2);
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 resultobj = SWIG_Py_Void();
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
11031 wxString *arg2 = 0 ;
11032 void *argp1 = 0 ;
11033 int res1 = 0 ;
11034 bool temp2 = false ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 char * kwnames[] = {
11038 (char *) "self",(char *) "title", NULL
11039 };
11040
11041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) SWIG_fail;
11042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogTitle" "', expected argument " "1"" of type '" "wxFontMapper *""'");
11045 }
11046 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
11047 {
11048 arg2 = wxString_in_helper(obj1);
11049 if (arg2 == NULL) SWIG_fail;
11050 temp2 = true;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetDialogTitle((wxString const &)*arg2);
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 resultobj = SWIG_Py_Void();
11059 {
11060 if (temp2)
11061 delete arg2;
11062 }
11063 return resultobj;
11064 fail:
11065 {
11066 if (temp2)
11067 delete arg2;
11068 }
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *FontMapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *obj;
11075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11076 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontMapper, SWIG_NewClientData(obj));
11077 return SWIG_Py_Void();
11078 }
11079
11080 SWIGINTERN PyObject *FontMapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11081 return SWIG_Python_InitShadowInstance(args);
11082 }
11083
11084 SWIGINTERN PyObject *_wrap_new_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 int arg1 ;
11087 int arg2 ;
11088 int arg3 ;
11089 int arg4 ;
11090 bool arg5 = (bool) false ;
11091 wxString const &arg6_defvalue = wxPyEmptyString ;
11092 wxString *arg6 = (wxString *) &arg6_defvalue ;
11093 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11094 wxFont *result = 0 ;
11095 int val1 ;
11096 int ecode1 = 0 ;
11097 int val2 ;
11098 int ecode2 = 0 ;
11099 int val3 ;
11100 int ecode3 = 0 ;
11101 int val4 ;
11102 int ecode4 = 0 ;
11103 bool val5 ;
11104 int ecode5 = 0 ;
11105 bool temp6 = false ;
11106 int val7 ;
11107 int ecode7 = 0 ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 PyObject * obj2 = 0 ;
11111 PyObject * obj3 = 0 ;
11112 PyObject * obj4 = 0 ;
11113 PyObject * obj5 = 0 ;
11114 PyObject * obj6 = 0 ;
11115 char * kwnames[] = {
11116 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
11117 };
11118
11119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11120 ecode1 = SWIG_AsVal_int(obj0, &val1);
11121 if (!SWIG_IsOK(ecode1)) {
11122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Font" "', expected argument " "1"" of type '" "int""'");
11123 }
11124 arg1 = static_cast< int >(val1);
11125 ecode2 = SWIG_AsVal_int(obj1, &val2);
11126 if (!SWIG_IsOK(ecode2)) {
11127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Font" "', expected argument " "2"" of type '" "int""'");
11128 }
11129 arg2 = static_cast< int >(val2);
11130 ecode3 = SWIG_AsVal_int(obj2, &val3);
11131 if (!SWIG_IsOK(ecode3)) {
11132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Font" "', expected argument " "3"" of type '" "int""'");
11133 }
11134 arg3 = static_cast< int >(val3);
11135 ecode4 = SWIG_AsVal_int(obj3, &val4);
11136 if (!SWIG_IsOK(ecode4)) {
11137 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Font" "', expected argument " "4"" of type '" "int""'");
11138 }
11139 arg4 = static_cast< int >(val4);
11140 if (obj4) {
11141 ecode5 = SWIG_AsVal_bool(obj4, &val5);
11142 if (!SWIG_IsOK(ecode5)) {
11143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Font" "', expected argument " "5"" of type '" "bool""'");
11144 }
11145 arg5 = static_cast< bool >(val5);
11146 }
11147 if (obj5) {
11148 {
11149 arg6 = wxString_in_helper(obj5);
11150 if (arg6 == NULL) SWIG_fail;
11151 temp6 = true;
11152 }
11153 }
11154 if (obj6) {
11155 ecode7 = SWIG_AsVal_int(obj6, &val7);
11156 if (!SWIG_IsOK(ecode7)) {
11157 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Font" "', expected argument " "7"" of type '" "wxFontEncoding""'");
11158 }
11159 arg7 = static_cast< wxFontEncoding >(val7);
11160 }
11161 {
11162 if (!wxPyCheckForApp()) SWIG_fail;
11163 PyThreadState* __tstate = wxPyBeginAllowThreads();
11164 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_NEW | 0 );
11169 {
11170 if (temp6)
11171 delete arg6;
11172 }
11173 return resultobj;
11174 fail:
11175 {
11176 if (temp6)
11177 delete arg6;
11178 }
11179 return NULL;
11180 }
11181
11182
11183 SWIGINTERN PyObject *_wrap_delete_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 PyObject *resultobj = 0;
11185 wxFont *arg1 = (wxFont *) 0 ;
11186 void *argp1 = 0 ;
11187 int res1 = 0 ;
11188 PyObject *swig_obj[1] ;
11189
11190 if (!args) SWIG_fail;
11191 swig_obj[0] = args;
11192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, SWIG_POINTER_DISOWN | 0 );
11193 if (!SWIG_IsOK(res1)) {
11194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Font" "', expected argument " "1"" of type '" "wxFont *""'");
11195 }
11196 arg1 = reinterpret_cast< wxFont * >(argp1);
11197 {
11198 PyThreadState* __tstate = wxPyBeginAllowThreads();
11199 delete arg1;
11200
11201 wxPyEndAllowThreads(__tstate);
11202 if (PyErr_Occurred()) SWIG_fail;
11203 }
11204 resultobj = SWIG_Py_Void();
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11212 PyObject *resultobj = 0;
11213 wxNativeFontInfo *arg1 = 0 ;
11214 wxFont *result = 0 ;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 PyObject * obj0 = 0 ;
11218 char * kwnames[] = {
11219 (char *) "info", NULL
11220 };
11221
11222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) SWIG_fail;
11223 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
11224 if (!SWIG_IsOK(res1)) {
11225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
11226 }
11227 if (!argp1) {
11228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
11229 }
11230 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11231 {
11232 if (!wxPyCheckForApp()) SWIG_fail;
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
11235 wxPyEndAllowThreads(__tstate);
11236 if (PyErr_Occurred()) SWIG_fail;
11237 }
11238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfoString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11246 PyObject *resultobj = 0;
11247 wxString *arg1 = 0 ;
11248 wxFont *result = 0 ;
11249 bool temp1 = false ;
11250 PyObject * obj0 = 0 ;
11251 char * kwnames[] = {
11252 (char *) "info", NULL
11253 };
11254
11255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) SWIG_fail;
11256 {
11257 arg1 = wxString_in_helper(obj0);
11258 if (arg1 == NULL) SWIG_fail;
11259 temp1 = true;
11260 }
11261 {
11262 if (!wxPyCheckForApp()) SWIG_fail;
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 result = (wxFont *)new_wxFont((wxString const &)*arg1);
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11269 {
11270 if (temp1)
11271 delete arg1;
11272 }
11273 return resultobj;
11274 fail:
11275 {
11276 if (temp1)
11277 delete arg1;
11278 }
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *_wrap_new_FFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj = 0;
11285 int arg1 ;
11286 wxFontFamily arg2 ;
11287 int arg3 = (int) wxFONTFLAG_DEFAULT ;
11288 wxString const &arg4_defvalue = wxPyEmptyString ;
11289 wxString *arg4 = (wxString *) &arg4_defvalue ;
11290 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11291 wxFont *result = 0 ;
11292 int val1 ;
11293 int ecode1 = 0 ;
11294 int val2 ;
11295 int ecode2 = 0 ;
11296 int val3 ;
11297 int ecode3 = 0 ;
11298 bool temp4 = false ;
11299 int val5 ;
11300 int ecode5 = 0 ;
11301 PyObject * obj0 = 0 ;
11302 PyObject * obj1 = 0 ;
11303 PyObject * obj2 = 0 ;
11304 PyObject * obj3 = 0 ;
11305 PyObject * obj4 = 0 ;
11306 char * kwnames[] = {
11307 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
11308 };
11309
11310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11311 ecode1 = SWIG_AsVal_int(obj0, &val1);
11312 if (!SWIG_IsOK(ecode1)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FFont" "', expected argument " "1"" of type '" "int""'");
11314 }
11315 arg1 = static_cast< int >(val1);
11316 ecode2 = SWIG_AsVal_int(obj1, &val2);
11317 if (!SWIG_IsOK(ecode2)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFont" "', expected argument " "2"" of type '" "wxFontFamily""'");
11319 }
11320 arg2 = static_cast< wxFontFamily >(val2);
11321 if (obj2) {
11322 ecode3 = SWIG_AsVal_int(obj2, &val3);
11323 if (!SWIG_IsOK(ecode3)) {
11324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFont" "', expected argument " "3"" of type '" "int""'");
11325 }
11326 arg3 = static_cast< int >(val3);
11327 }
11328 if (obj3) {
11329 {
11330 arg4 = wxString_in_helper(obj3);
11331 if (arg4 == NULL) SWIG_fail;
11332 temp4 = true;
11333 }
11334 }
11335 if (obj4) {
11336 ecode5 = SWIG_AsVal_int(obj4, &val5);
11337 if (!SWIG_IsOK(ecode5)) {
11338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFont" "', expected argument " "5"" of type '" "wxFontEncoding""'");
11339 }
11340 arg5 = static_cast< wxFontEncoding >(val5);
11341 }
11342 {
11343 if (!wxPyCheckForApp()) SWIG_fail;
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (wxFont *)new_wxFont(arg1,arg2,arg3,(wxString const &)*arg4,arg5);
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11350 {
11351 if (temp4)
11352 delete arg4;
11353 }
11354 return resultobj;
11355 fail:
11356 {
11357 if (temp4)
11358 delete arg4;
11359 }
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_new_FontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 wxSize *arg1 = 0 ;
11367 int arg2 ;
11368 int arg3 ;
11369 int arg4 ;
11370 bool arg5 = (bool) false ;
11371 wxString const &arg6_defvalue = wxEmptyString ;
11372 wxString *arg6 = (wxString *) &arg6_defvalue ;
11373 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11374 wxFont *result = 0 ;
11375 wxSize temp1 ;
11376 int val2 ;
11377 int ecode2 = 0 ;
11378 int val3 ;
11379 int ecode3 = 0 ;
11380 int val4 ;
11381 int ecode4 = 0 ;
11382 bool val5 ;
11383 int ecode5 = 0 ;
11384 bool temp6 = false ;
11385 int val7 ;
11386 int ecode7 = 0 ;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 PyObject * obj2 = 0 ;
11390 PyObject * obj3 = 0 ;
11391 PyObject * obj4 = 0 ;
11392 PyObject * obj5 = 0 ;
11393 PyObject * obj6 = 0 ;
11394 char * kwnames[] = {
11395 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
11396 };
11397
11398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11399 {
11400 arg1 = &temp1;
11401 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
11402 }
11403 ecode2 = SWIG_AsVal_int(obj1, &val2);
11404 if (!SWIG_IsOK(ecode2)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontFromPixelSize" "', expected argument " "2"" of type '" "int""'");
11406 }
11407 arg2 = static_cast< int >(val2);
11408 ecode3 = SWIG_AsVal_int(obj2, &val3);
11409 if (!SWIG_IsOK(ecode3)) {
11410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
11411 }
11412 arg3 = static_cast< int >(val3);
11413 ecode4 = SWIG_AsVal_int(obj3, &val4);
11414 if (!SWIG_IsOK(ecode4)) {
11415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FontFromPixelSize" "', expected argument " "4"" of type '" "int""'");
11416 }
11417 arg4 = static_cast< int >(val4);
11418 if (obj4) {
11419 ecode5 = SWIG_AsVal_bool(obj4, &val5);
11420 if (!SWIG_IsOK(ecode5)) {
11421 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FontFromPixelSize" "', expected argument " "5"" of type '" "bool""'");
11422 }
11423 arg5 = static_cast< bool >(val5);
11424 }
11425 if (obj5) {
11426 {
11427 arg6 = wxString_in_helper(obj5);
11428 if (arg6 == NULL) SWIG_fail;
11429 temp6 = true;
11430 }
11431 }
11432 if (obj6) {
11433 ecode7 = SWIG_AsVal_int(obj6, &val7);
11434 if (!SWIG_IsOK(ecode7)) {
11435 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FontFromPixelSize" "', expected argument " "7"" of type '" "wxFontEncoding""'");
11436 }
11437 arg7 = static_cast< wxFontEncoding >(val7);
11438 }
11439 {
11440 if (!wxPyCheckForApp()) SWIG_fail;
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11447 {
11448 if (temp6)
11449 delete arg6;
11450 }
11451 return resultobj;
11452 fail:
11453 {
11454 if (temp6)
11455 delete arg6;
11456 }
11457 return NULL;
11458 }
11459
11460
11461 SWIGINTERN PyObject *_wrap_new_FFontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11462 PyObject *resultobj = 0;
11463 wxSize *arg1 = 0 ;
11464 wxFontFamily arg2 ;
11465 int arg3 = (int) wxFONTFLAG_DEFAULT ;
11466 wxString const &arg4_defvalue = wxEmptyString ;
11467 wxString *arg4 = (wxString *) &arg4_defvalue ;
11468 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11469 wxFont *result = 0 ;
11470 wxSize temp1 ;
11471 int val2 ;
11472 int ecode2 = 0 ;
11473 int val3 ;
11474 int ecode3 = 0 ;
11475 bool temp4 = false ;
11476 int val5 ;
11477 int ecode5 = 0 ;
11478 PyObject * obj0 = 0 ;
11479 PyObject * obj1 = 0 ;
11480 PyObject * obj2 = 0 ;
11481 PyObject * obj3 = 0 ;
11482 PyObject * obj4 = 0 ;
11483 char * kwnames[] = {
11484 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
11485 };
11486
11487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11488 {
11489 arg1 = &temp1;
11490 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
11491 }
11492 ecode2 = SWIG_AsVal_int(obj1, &val2);
11493 if (!SWIG_IsOK(ecode2)) {
11494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFontFromPixelSize" "', expected argument " "2"" of type '" "wxFontFamily""'");
11495 }
11496 arg2 = static_cast< wxFontFamily >(val2);
11497 if (obj2) {
11498 ecode3 = SWIG_AsVal_int(obj2, &val3);
11499 if (!SWIG_IsOK(ecode3)) {
11500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
11501 }
11502 arg3 = static_cast< int >(val3);
11503 }
11504 if (obj3) {
11505 {
11506 arg4 = wxString_in_helper(obj3);
11507 if (arg4 == NULL) SWIG_fail;
11508 temp4 = true;
11509 }
11510 }
11511 if (obj4) {
11512 ecode5 = SWIG_AsVal_int(obj4, &val5);
11513 if (!SWIG_IsOK(ecode5)) {
11514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFontFromPixelSize" "', expected argument " "5"" of type '" "wxFontEncoding""'");
11515 }
11516 arg5 = static_cast< wxFontEncoding >(val5);
11517 }
11518 {
11519 if (!wxPyCheckForApp()) SWIG_fail;
11520 PyThreadState* __tstate = wxPyBeginAllowThreads();
11521 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,(wxString const &)*arg4,arg5);
11522 wxPyEndAllowThreads(__tstate);
11523 if (PyErr_Occurred()) SWIG_fail;
11524 }
11525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11526 {
11527 if (temp4)
11528 delete arg4;
11529 }
11530 return resultobj;
11531 fail:
11532 {
11533 if (temp4)
11534 delete arg4;
11535 }
11536 return NULL;
11537 }
11538
11539
11540 SWIGINTERN PyObject *_wrap_Font_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11541 PyObject *resultobj = 0;
11542 wxFont *arg1 = (wxFont *) 0 ;
11543 bool result;
11544 void *argp1 = 0 ;
11545 int res1 = 0 ;
11546 PyObject *swig_obj[1] ;
11547
11548 if (!args) SWIG_fail;
11549 swig_obj[0] = args;
11550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11551 if (!SWIG_IsOK(res1)) {
11552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_Ok" "', expected argument " "1"" of type '" "wxFont const *""'");
11553 }
11554 arg1 = reinterpret_cast< wxFont * >(argp1);
11555 {
11556 PyThreadState* __tstate = wxPyBeginAllowThreads();
11557 result = (bool)((wxFont const *)arg1)->Ok();
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 {
11562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11563 }
11564 return resultobj;
11565 fail:
11566 return NULL;
11567 }
11568
11569
11570 SWIGINTERN PyObject *_wrap_Font___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11571 PyObject *resultobj = 0;
11572 wxFont *arg1 = (wxFont *) 0 ;
11573 wxFont *arg2 = (wxFont *) 0 ;
11574 bool result;
11575 void *argp1 = 0 ;
11576 int res1 = 0 ;
11577 void *argp2 = 0 ;
11578 int res2 = 0 ;
11579 PyObject * obj0 = 0 ;
11580 PyObject * obj1 = 0 ;
11581 char * kwnames[] = {
11582 (char *) "self",(char *) "other", NULL
11583 };
11584
11585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11587 if (!SWIG_IsOK(res1)) {
11588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___eq__" "', expected argument " "1"" of type '" "wxFont *""'");
11589 }
11590 arg1 = reinterpret_cast< wxFont * >(argp1);
11591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
11592 if (!SWIG_IsOK(res2)) {
11593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___eq__" "', expected argument " "2"" of type '" "wxFont const *""'");
11594 }
11595 arg2 = reinterpret_cast< wxFont * >(argp2);
11596 {
11597 PyThreadState* __tstate = wxPyBeginAllowThreads();
11598 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11604 }
11605 return resultobj;
11606 fail:
11607 return NULL;
11608 }
11609
11610
11611 SWIGINTERN PyObject *_wrap_Font___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11612 PyObject *resultobj = 0;
11613 wxFont *arg1 = (wxFont *) 0 ;
11614 wxFont *arg2 = (wxFont *) 0 ;
11615 bool result;
11616 void *argp1 = 0 ;
11617 int res1 = 0 ;
11618 void *argp2 = 0 ;
11619 int res2 = 0 ;
11620 PyObject * obj0 = 0 ;
11621 PyObject * obj1 = 0 ;
11622 char * kwnames[] = {
11623 (char *) "self",(char *) "other", NULL
11624 };
11625
11626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11628 if (!SWIG_IsOK(res1)) {
11629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___ne__" "', expected argument " "1"" of type '" "wxFont *""'");
11630 }
11631 arg1 = reinterpret_cast< wxFont * >(argp1);
11632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
11633 if (!SWIG_IsOK(res2)) {
11634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___ne__" "', expected argument " "2"" of type '" "wxFont const *""'");
11635 }
11636 arg2 = reinterpret_cast< wxFont * >(argp2);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 {
11644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11645 }
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 SWIGINTERN PyObject *_wrap_Font_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11653 PyObject *resultobj = 0;
11654 wxFont *arg1 = (wxFont *) 0 ;
11655 int result;
11656 void *argp1 = 0 ;
11657 int res1 = 0 ;
11658 PyObject *swig_obj[1] ;
11659
11660 if (!args) SWIG_fail;
11661 swig_obj[0] = args;
11662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11663 if (!SWIG_IsOK(res1)) {
11664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPointSize" "', expected argument " "1"" of type '" "wxFont const *""'");
11665 }
11666 arg1 = reinterpret_cast< wxFont * >(argp1);
11667 {
11668 PyThreadState* __tstate = wxPyBeginAllowThreads();
11669 result = (int)((wxFont const *)arg1)->GetPointSize();
11670 wxPyEndAllowThreads(__tstate);
11671 if (PyErr_Occurred()) SWIG_fail;
11672 }
11673 resultobj = SWIG_From_int(static_cast< int >(result));
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 SWIGINTERN PyObject *_wrap_Font_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11681 PyObject *resultobj = 0;
11682 wxFont *arg1 = (wxFont *) 0 ;
11683 wxSize result;
11684 void *argp1 = 0 ;
11685 int res1 = 0 ;
11686 PyObject *swig_obj[1] ;
11687
11688 if (!args) SWIG_fail;
11689 swig_obj[0] = args;
11690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11691 if (!SWIG_IsOK(res1)) {
11692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPixelSize" "', expected argument " "1"" of type '" "wxFont const *""'");
11693 }
11694 arg1 = reinterpret_cast< wxFont * >(argp1);
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 result = ((wxFont const *)arg1)->GetPixelSize();
11698 wxPyEndAllowThreads(__tstate);
11699 if (PyErr_Occurred()) SWIG_fail;
11700 }
11701 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 SWIGINTERN PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11709 PyObject *resultobj = 0;
11710 wxFont *arg1 = (wxFont *) 0 ;
11711 bool result;
11712 void *argp1 = 0 ;
11713 int res1 = 0 ;
11714 PyObject *swig_obj[1] ;
11715
11716 if (!args) SWIG_fail;
11717 swig_obj[0] = args;
11718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11719 if (!SWIG_IsOK(res1)) {
11720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsUsingSizeInPixels" "', expected argument " "1"" of type '" "wxFont const *""'");
11721 }
11722 arg1 = reinterpret_cast< wxFont * >(argp1);
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 {
11730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11731 }
11732 return resultobj;
11733 fail:
11734 return NULL;
11735 }
11736
11737
11738 SWIGINTERN PyObject *_wrap_Font_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxFont *arg1 = (wxFont *) 0 ;
11741 int result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamily" "', expected argument " "1"" of type '" "wxFont const *""'");
11751 }
11752 arg1 = reinterpret_cast< wxFont * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (int)((wxFont const *)arg1)->GetFamily();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 resultobj = SWIG_From_int(static_cast< int >(result));
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_Font_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767 PyObject *resultobj = 0;
11768 wxFont *arg1 = (wxFont *) 0 ;
11769 int result;
11770 void *argp1 = 0 ;
11771 int res1 = 0 ;
11772 PyObject *swig_obj[1] ;
11773
11774 if (!args) SWIG_fail;
11775 swig_obj[0] = args;
11776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11777 if (!SWIG_IsOK(res1)) {
11778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyle" "', expected argument " "1"" of type '" "wxFont const *""'");
11779 }
11780 arg1 = reinterpret_cast< wxFont * >(argp1);
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (int)((wxFont const *)arg1)->GetStyle();
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_From_int(static_cast< int >(result));
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_Font_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxFont *arg1 = (wxFont *) 0 ;
11797 int result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeight" "', expected argument " "1"" of type '" "wxFont const *""'");
11807 }
11808 arg1 = reinterpret_cast< wxFont * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (int)((wxFont const *)arg1)->GetWeight();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 resultobj = SWIG_From_int(static_cast< int >(result));
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 SWIGINTERN PyObject *_wrap_Font_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11823 PyObject *resultobj = 0;
11824 wxFont *arg1 = (wxFont *) 0 ;
11825 bool result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 PyObject *swig_obj[1] ;
11829
11830 if (!args) SWIG_fail;
11831 swig_obj[0] = args;
11832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetUnderlined" "', expected argument " "1"" of type '" "wxFont const *""'");
11835 }
11836 arg1 = reinterpret_cast< wxFont * >(argp1);
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)((wxFont const *)arg1)->GetUnderlined();
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11845 }
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 SWIGINTERN PyObject *_wrap_Font_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11853 PyObject *resultobj = 0;
11854 wxFont *arg1 = (wxFont *) 0 ;
11855 wxString result;
11856 void *argp1 = 0 ;
11857 int res1 = 0 ;
11858 PyObject *swig_obj[1] ;
11859
11860 if (!args) SWIG_fail;
11861 swig_obj[0] = args;
11862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11863 if (!SWIG_IsOK(res1)) {
11864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFaceName" "', expected argument " "1"" of type '" "wxFont const *""'");
11865 }
11866 arg1 = reinterpret_cast< wxFont * >(argp1);
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 result = ((wxFont const *)arg1)->GetFaceName();
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 {
11874 #if wxUSE_UNICODE
11875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11876 #else
11877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11878 #endif
11879 }
11880 return resultobj;
11881 fail:
11882 return NULL;
11883 }
11884
11885
11886 SWIGINTERN PyObject *_wrap_Font_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11887 PyObject *resultobj = 0;
11888 wxFont *arg1 = (wxFont *) 0 ;
11889 wxFontEncoding result;
11890 void *argp1 = 0 ;
11891 int res1 = 0 ;
11892 PyObject *swig_obj[1] ;
11893
11894 if (!args) SWIG_fail;
11895 swig_obj[0] = args;
11896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11897 if (!SWIG_IsOK(res1)) {
11898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetEncoding" "', expected argument " "1"" of type '" "wxFont const *""'");
11899 }
11900 arg1 = reinterpret_cast< wxFont * >(argp1);
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 resultobj = SWIG_From_int(static_cast< int >(result));
11908 return resultobj;
11909 fail:
11910 return NULL;
11911 }
11912
11913
11914 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11915 PyObject *resultobj = 0;
11916 wxFont *arg1 = (wxFont *) 0 ;
11917 wxNativeFontInfo *result = 0 ;
11918 void *argp1 = 0 ;
11919 int res1 = 0 ;
11920 PyObject *swig_obj[1] ;
11921
11922 if (!args) SWIG_fail;
11923 swig_obj[0] = args;
11924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11925 if (!SWIG_IsOK(res1)) {
11926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont const *""'");
11927 }
11928 arg1 = reinterpret_cast< wxFont * >(argp1);
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11936 return resultobj;
11937 fail:
11938 return NULL;
11939 }
11940
11941
11942 SWIGINTERN PyObject *_wrap_Font_IsFixedWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11943 PyObject *resultobj = 0;
11944 wxFont *arg1 = (wxFont *) 0 ;
11945 bool result;
11946 void *argp1 = 0 ;
11947 int res1 = 0 ;
11948 PyObject *swig_obj[1] ;
11949
11950 if (!args) SWIG_fail;
11951 swig_obj[0] = args;
11952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsFixedWidth" "', expected argument " "1"" of type '" "wxFont const *""'");
11955 }
11956 arg1 = reinterpret_cast< wxFont * >(argp1);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 {
11964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11965 }
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11973 PyObject *resultobj = 0;
11974 wxFont *arg1 = (wxFont *) 0 ;
11975 wxString result;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 PyObject *swig_obj[1] ;
11979
11980 if (!args) SWIG_fail;
11981 swig_obj[0] = args;
11982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11983 if (!SWIG_IsOK(res1)) {
11984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
11985 }
11986 arg1 = reinterpret_cast< wxFont * >(argp1);
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 {
11994 #if wxUSE_UNICODE
11995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11996 #else
11997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11998 #endif
11999 }
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 PyObject *resultobj = 0;
12008 wxFont *arg1 = (wxFont *) 0 ;
12009 wxString result;
12010 void *argp1 = 0 ;
12011 int res1 = 0 ;
12012 PyObject *swig_obj[1] ;
12013
12014 if (!args) SWIG_fail;
12015 swig_obj[0] = args;
12016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
12019 }
12020 arg1 = reinterpret_cast< wxFont * >(argp1);
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
12024 wxPyEndAllowThreads(__tstate);
12025 if (PyErr_Occurred()) SWIG_fail;
12026 }
12027 {
12028 #if wxUSE_UNICODE
12029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12030 #else
12031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12032 #endif
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_Font_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxFont *arg1 = (wxFont *) 0 ;
12043 int arg2 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 int val2 ;
12047 int ecode2 = 0 ;
12048 PyObject * obj0 = 0 ;
12049 PyObject * obj1 = 0 ;
12050 char * kwnames[] = {
12051 (char *) "self",(char *) "pointSize", NULL
12052 };
12053
12054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
12055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPointSize" "', expected argument " "1"" of type '" "wxFont *""'");
12058 }
12059 arg1 = reinterpret_cast< wxFont * >(argp1);
12060 ecode2 = SWIG_AsVal_int(obj1, &val2);
12061 if (!SWIG_IsOK(ecode2)) {
12062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetPointSize" "', expected argument " "2"" of type '" "int""'");
12063 }
12064 arg2 = static_cast< int >(val2);
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 (arg1)->SetPointSize(arg2);
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 resultobj = SWIG_Py_Void();
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 SWIGINTERN PyObject *_wrap_Font_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12079 PyObject *resultobj = 0;
12080 wxFont *arg1 = (wxFont *) 0 ;
12081 wxSize *arg2 = 0 ;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 wxSize temp2 ;
12085 PyObject * obj0 = 0 ;
12086 PyObject * obj1 = 0 ;
12087 char * kwnames[] = {
12088 (char *) "self",(char *) "pixelSize", NULL
12089 };
12090
12091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
12092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12093 if (!SWIG_IsOK(res1)) {
12094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPixelSize" "', expected argument " "1"" of type '" "wxFont *""'");
12095 }
12096 arg1 = reinterpret_cast< wxFont * >(argp1);
12097 {
12098 arg2 = &temp2;
12099 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12100 }
12101 {
12102 PyThreadState* __tstate = wxPyBeginAllowThreads();
12103 (arg1)->SetPixelSize((wxSize const &)*arg2);
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 resultobj = SWIG_Py_Void();
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 SWIGINTERN PyObject *_wrap_Font_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj = 0;
12116 wxFont *arg1 = (wxFont *) 0 ;
12117 int arg2 ;
12118 void *argp1 = 0 ;
12119 int res1 = 0 ;
12120 int val2 ;
12121 int ecode2 = 0 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 char * kwnames[] = {
12125 (char *) "self",(char *) "family", NULL
12126 };
12127
12128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
12129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12130 if (!SWIG_IsOK(res1)) {
12131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFamily" "', expected argument " "1"" of type '" "wxFont *""'");
12132 }
12133 arg1 = reinterpret_cast< wxFont * >(argp1);
12134 ecode2 = SWIG_AsVal_int(obj1, &val2);
12135 if (!SWIG_IsOK(ecode2)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetFamily" "', expected argument " "2"" of type '" "int""'");
12137 }
12138 arg2 = static_cast< int >(val2);
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 (arg1)->SetFamily(arg2);
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 resultobj = SWIG_Py_Void();
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *_wrap_Font_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj = 0;
12154 wxFont *arg1 = (wxFont *) 0 ;
12155 int arg2 ;
12156 void *argp1 = 0 ;
12157 int res1 = 0 ;
12158 int val2 ;
12159 int ecode2 = 0 ;
12160 PyObject * obj0 = 0 ;
12161 PyObject * obj1 = 0 ;
12162 char * kwnames[] = {
12163 (char *) "self",(char *) "style", NULL
12164 };
12165
12166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
12167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12168 if (!SWIG_IsOK(res1)) {
12169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetStyle" "', expected argument " "1"" of type '" "wxFont *""'");
12170 }
12171 arg1 = reinterpret_cast< wxFont * >(argp1);
12172 ecode2 = SWIG_AsVal_int(obj1, &val2);
12173 if (!SWIG_IsOK(ecode2)) {
12174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetStyle" "', expected argument " "2"" of type '" "int""'");
12175 }
12176 arg2 = static_cast< int >(val2);
12177 {
12178 PyThreadState* __tstate = wxPyBeginAllowThreads();
12179 (arg1)->SetStyle(arg2);
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 resultobj = SWIG_Py_Void();
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 SWIGINTERN PyObject *_wrap_Font_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj = 0;
12192 wxFont *arg1 = (wxFont *) 0 ;
12193 int arg2 ;
12194 void *argp1 = 0 ;
12195 int res1 = 0 ;
12196 int val2 ;
12197 int ecode2 = 0 ;
12198 PyObject * obj0 = 0 ;
12199 PyObject * obj1 = 0 ;
12200 char * kwnames[] = {
12201 (char *) "self",(char *) "weight", NULL
12202 };
12203
12204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
12205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12206 if (!SWIG_IsOK(res1)) {
12207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetWeight" "', expected argument " "1"" of type '" "wxFont *""'");
12208 }
12209 arg1 = reinterpret_cast< wxFont * >(argp1);
12210 ecode2 = SWIG_AsVal_int(obj1, &val2);
12211 if (!SWIG_IsOK(ecode2)) {
12212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetWeight" "', expected argument " "2"" of type '" "int""'");
12213 }
12214 arg2 = static_cast< int >(val2);
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 (arg1)->SetWeight(arg2);
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_Py_Void();
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_Font_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 wxFont *arg1 = (wxFont *) 0 ;
12231 wxString *arg2 = 0 ;
12232 void *argp1 = 0 ;
12233 int res1 = 0 ;
12234 bool temp2 = false ;
12235 PyObject * obj0 = 0 ;
12236 PyObject * obj1 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "self",(char *) "faceName", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
12242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFaceName" "', expected argument " "1"" of type '" "wxFont *""'");
12245 }
12246 arg1 = reinterpret_cast< wxFont * >(argp1);
12247 {
12248 arg2 = wxString_in_helper(obj1);
12249 if (arg2 == NULL) SWIG_fail;
12250 temp2 = true;
12251 }
12252 {
12253 PyThreadState* __tstate = wxPyBeginAllowThreads();
12254 (arg1)->SetFaceName((wxString const &)*arg2);
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 resultobj = SWIG_Py_Void();
12259 {
12260 if (temp2)
12261 delete arg2;
12262 }
12263 return resultobj;
12264 fail:
12265 {
12266 if (temp2)
12267 delete arg2;
12268 }
12269 return NULL;
12270 }
12271
12272
12273 SWIGINTERN PyObject *_wrap_Font_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj = 0;
12275 wxFont *arg1 = (wxFont *) 0 ;
12276 bool arg2 ;
12277 void *argp1 = 0 ;
12278 int res1 = 0 ;
12279 bool val2 ;
12280 int ecode2 = 0 ;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 char * kwnames[] = {
12284 (char *) "self",(char *) "underlined", NULL
12285 };
12286
12287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
12288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12289 if (!SWIG_IsOK(res1)) {
12290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetUnderlined" "', expected argument " "1"" of type '" "wxFont *""'");
12291 }
12292 arg1 = reinterpret_cast< wxFont * >(argp1);
12293 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12294 if (!SWIG_IsOK(ecode2)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
12296 }
12297 arg2 = static_cast< bool >(val2);
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 (arg1)->SetUnderlined(arg2);
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 resultobj = SWIG_Py_Void();
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *_wrap_Font_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj = 0;
12313 wxFont *arg1 = (wxFont *) 0 ;
12314 wxFontEncoding arg2 ;
12315 void *argp1 = 0 ;
12316 int res1 = 0 ;
12317 int val2 ;
12318 int ecode2 = 0 ;
12319 PyObject * obj0 = 0 ;
12320 PyObject * obj1 = 0 ;
12321 char * kwnames[] = {
12322 (char *) "self",(char *) "encoding", NULL
12323 };
12324
12325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
12326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12327 if (!SWIG_IsOK(res1)) {
12328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetEncoding" "', expected argument " "1"" of type '" "wxFont *""'");
12329 }
12330 arg1 = reinterpret_cast< wxFont * >(argp1);
12331 ecode2 = SWIG_AsVal_int(obj1, &val2);
12332 if (!SWIG_IsOK(ecode2)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12334 }
12335 arg2 = static_cast< wxFontEncoding >(val2);
12336 {
12337 PyThreadState* __tstate = wxPyBeginAllowThreads();
12338 (arg1)->SetEncoding(arg2);
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = SWIG_Py_Void();
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj = 0;
12351 wxFont *arg1 = (wxFont *) 0 ;
12352 wxNativeFontInfo *arg2 = 0 ;
12353 void *argp1 = 0 ;
12354 int res1 = 0 ;
12355 void *argp2 = 0 ;
12356 int res2 = 0 ;
12357 PyObject * obj0 = 0 ;
12358 PyObject * obj1 = 0 ;
12359 char * kwnames[] = {
12360 (char *) "self",(char *) "info", NULL
12361 };
12362
12363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) SWIG_fail;
12364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12365 if (!SWIG_IsOK(res1)) {
12366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont *""'");
12367 }
12368 arg1 = reinterpret_cast< wxFont * >(argp1);
12369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
12370 if (!SWIG_IsOK(res2)) {
12371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
12372 }
12373 if (!argp2) {
12374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
12375 }
12376 arg2 = reinterpret_cast< wxNativeFontInfo * >(argp2);
12377 {
12378 PyThreadState* __tstate = wxPyBeginAllowThreads();
12379 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
12380 wxPyEndAllowThreads(__tstate);
12381 if (PyErr_Occurred()) SWIG_fail;
12382 }
12383 resultobj = SWIG_Py_Void();
12384 return resultobj;
12385 fail:
12386 return NULL;
12387 }
12388
12389
12390 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12391 PyObject *resultobj = 0;
12392 wxFont *arg1 = (wxFont *) 0 ;
12393 wxString *arg2 = 0 ;
12394 void *argp1 = 0 ;
12395 int res1 = 0 ;
12396 bool temp2 = false ;
12397 PyObject * obj0 = 0 ;
12398 PyObject * obj1 = 0 ;
12399 char * kwnames[] = {
12400 (char *) "self",(char *) "info", NULL
12401 };
12402
12403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) SWIG_fail;
12404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12405 if (!SWIG_IsOK(res1)) {
12406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoFromString" "', expected argument " "1"" of type '" "wxFont *""'");
12407 }
12408 arg1 = reinterpret_cast< wxFont * >(argp1);
12409 {
12410 arg2 = wxString_in_helper(obj1);
12411 if (arg2 == NULL) SWIG_fail;
12412 temp2 = true;
12413 }
12414 {
12415 PyThreadState* __tstate = wxPyBeginAllowThreads();
12416 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 resultobj = SWIG_Py_Void();
12421 {
12422 if (temp2)
12423 delete arg2;
12424 }
12425 return resultobj;
12426 fail:
12427 {
12428 if (temp2)
12429 delete arg2;
12430 }
12431 return NULL;
12432 }
12433
12434
12435 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12436 PyObject *resultobj = 0;
12437 wxFont *arg1 = (wxFont *) 0 ;
12438 wxString *arg2 = 0 ;
12439 void *argp1 = 0 ;
12440 int res1 = 0 ;
12441 bool temp2 = false ;
12442 PyObject * obj0 = 0 ;
12443 PyObject * obj1 = 0 ;
12444 char * kwnames[] = {
12445 (char *) "self",(char *) "info", NULL
12446 };
12447
12448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) SWIG_fail;
12449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12450 if (!SWIG_IsOK(res1)) {
12451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont *""'");
12452 }
12453 arg1 = reinterpret_cast< wxFont * >(argp1);
12454 {
12455 arg2 = wxString_in_helper(obj1);
12456 if (arg2 == NULL) SWIG_fail;
12457 temp2 = true;
12458 }
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_Py_Void();
12466 {
12467 if (temp2)
12468 delete arg2;
12469 }
12470 return resultobj;
12471 fail:
12472 {
12473 if (temp2)
12474 delete arg2;
12475 }
12476 return NULL;
12477 }
12478
12479
12480 SWIGINTERN PyObject *_wrap_Font_GetFamilyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12481 PyObject *resultobj = 0;
12482 wxFont *arg1 = (wxFont *) 0 ;
12483 wxString result;
12484 void *argp1 = 0 ;
12485 int res1 = 0 ;
12486 PyObject *swig_obj[1] ;
12487
12488 if (!args) SWIG_fail;
12489 swig_obj[0] = args;
12490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12491 if (!SWIG_IsOK(res1)) {
12492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamilyString" "', expected argument " "1"" of type '" "wxFont const *""'");
12493 }
12494 arg1 = reinterpret_cast< wxFont * >(argp1);
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = ((wxFont const *)arg1)->GetFamilyString();
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 {
12502 #if wxUSE_UNICODE
12503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12504 #else
12505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12506 #endif
12507 }
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Font_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 PyObject *resultobj = 0;
12516 wxFont *arg1 = (wxFont *) 0 ;
12517 wxString result;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 PyObject *swig_obj[1] ;
12521
12522 if (!args) SWIG_fail;
12523 swig_obj[0] = args;
12524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12525 if (!SWIG_IsOK(res1)) {
12526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyleString" "', expected argument " "1"" of type '" "wxFont const *""'");
12527 }
12528 arg1 = reinterpret_cast< wxFont * >(argp1);
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 result = ((wxFont const *)arg1)->GetStyleString();
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 #if wxUSE_UNICODE
12537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12538 #else
12539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12540 #endif
12541 }
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 SWIGINTERN PyObject *_wrap_Font_GetWeightString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12549 PyObject *resultobj = 0;
12550 wxFont *arg1 = (wxFont *) 0 ;
12551 wxString result;
12552 void *argp1 = 0 ;
12553 int res1 = 0 ;
12554 PyObject *swig_obj[1] ;
12555
12556 if (!args) SWIG_fail;
12557 swig_obj[0] = args;
12558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12559 if (!SWIG_IsOK(res1)) {
12560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeightString" "', expected argument " "1"" of type '" "wxFont const *""'");
12561 }
12562 arg1 = reinterpret_cast< wxFont * >(argp1);
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = ((wxFont const *)arg1)->GetWeightString();
12566 wxPyEndAllowThreads(__tstate);
12567 if (PyErr_Occurred()) SWIG_fail;
12568 }
12569 {
12570 #if wxUSE_UNICODE
12571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12572 #else
12573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12574 #endif
12575 }
12576 return resultobj;
12577 fail:
12578 return NULL;
12579 }
12580
12581
12582 SWIGINTERN PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12583 PyObject *resultobj = 0;
12584 wxFont *arg1 = (wxFont *) 0 ;
12585 bool arg2 = (bool) true ;
12586 void *argp1 = 0 ;
12587 int res1 = 0 ;
12588 bool val2 ;
12589 int ecode2 = 0 ;
12590 PyObject * obj0 = 0 ;
12591 PyObject * obj1 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "self",(char *) "no", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;
12597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12598 if (!SWIG_IsOK(res1)) {
12599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont *""'");
12600 }
12601 arg1 = reinterpret_cast< wxFont * >(argp1);
12602 if (obj1) {
12603 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12604 if (!SWIG_IsOK(ecode2)) {
12605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "2"" of type '" "bool""'");
12606 }
12607 arg2 = static_cast< bool >(val2);
12608 }
12609 {
12610 PyThreadState* __tstate = wxPyBeginAllowThreads();
12611 (arg1)->SetNoAntiAliasing(arg2);
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 resultobj = SWIG_Py_Void();
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 SWIGINTERN PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12623 PyObject *resultobj = 0;
12624 wxFont *arg1 = (wxFont *) 0 ;
12625 bool result;
12626 void *argp1 = 0 ;
12627 int res1 = 0 ;
12628 PyObject *swig_obj[1] ;
12629
12630 if (!args) SWIG_fail;
12631 swig_obj[0] = args;
12632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12633 if (!SWIG_IsOK(res1)) {
12634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont const *""'");
12635 }
12636 arg1 = reinterpret_cast< wxFont * >(argp1);
12637 {
12638 PyThreadState* __tstate = wxPyBeginAllowThreads();
12639 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
12640 wxPyEndAllowThreads(__tstate);
12641 if (PyErr_Occurred()) SWIG_fail;
12642 }
12643 {
12644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12645 }
12646 return resultobj;
12647 fail:
12648 return NULL;
12649 }
12650
12651
12652 SWIGINTERN PyObject *_wrap_Font_GetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12653 PyObject *resultobj = 0;
12654 wxFontEncoding result;
12655
12656 if (!SWIG_Python_UnpackTuple(args,"Font_GetDefaultEncoding",0,0,0)) SWIG_fail;
12657 {
12658 if (!wxPyCheckForApp()) SWIG_fail;
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 resultobj = SWIG_From_int(static_cast< int >(result));
12665 return resultobj;
12666 fail:
12667 return NULL;
12668 }
12669
12670
12671 SWIGINTERN PyObject *_wrap_Font_SetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12672 PyObject *resultobj = 0;
12673 wxFontEncoding arg1 ;
12674 int val1 ;
12675 int ecode1 = 0 ;
12676 PyObject * obj0 = 0 ;
12677 char * kwnames[] = {
12678 (char *) "encoding", NULL
12679 };
12680
12681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) SWIG_fail;
12682 ecode1 = SWIG_AsVal_int(obj0, &val1);
12683 if (!SWIG_IsOK(ecode1)) {
12684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Font_SetDefaultEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12685 }
12686 arg1 = static_cast< wxFontEncoding >(val1);
12687 {
12688 if (!wxPyCheckForApp()) SWIG_fail;
12689 PyThreadState* __tstate = wxPyBeginAllowThreads();
12690 wxFont::SetDefaultEncoding(arg1);
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 resultobj = SWIG_Py_Void();
12695 return resultobj;
12696 fail:
12697 return NULL;
12698 }
12699
12700
12701 SWIGINTERN PyObject *Font_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12702 PyObject *obj;
12703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12704 SWIG_TypeNewClientData(SWIGTYPE_p_wxFont, SWIG_NewClientData(obj));
12705 return SWIG_Py_Void();
12706 }
12707
12708 SWIGINTERN PyObject *Font_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 return SWIG_Python_InitShadowInstance(args);
12710 }
12711
12712 SWIGINTERN PyObject *_wrap_new_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *resultobj = 0;
12714 wxPyFontEnumerator *result = 0 ;
12715
12716 if (!SWIG_Python_UnpackTuple(args,"new_FontEnumerator",0,0,0)) SWIG_fail;
12717 {
12718 if (!wxPyCheckForApp()) SWIG_fail;
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_NEW | 0 );
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *_wrap_delete_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *resultobj = 0;
12733 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12734 void *argp1 = 0 ;
12735 int res1 = 0 ;
12736 PyObject *swig_obj[1] ;
12737
12738 if (!args) SWIG_fail;
12739 swig_obj[0] = args;
12740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_DISOWN | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontEnumerator" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12743 }
12744 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12745 {
12746 PyThreadState* __tstate = wxPyBeginAllowThreads();
12747 delete arg1;
12748
12749 wxPyEndAllowThreads(__tstate);
12750 if (PyErr_Occurred()) SWIG_fail;
12751 }
12752 resultobj = SWIG_Py_Void();
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 SWIGINTERN PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj = 0;
12761 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12762 PyObject *arg2 = (PyObject *) 0 ;
12763 PyObject *arg3 = (PyObject *) 0 ;
12764 bool arg4 ;
12765 void *argp1 = 0 ;
12766 int res1 = 0 ;
12767 bool val4 ;
12768 int ecode4 = 0 ;
12769 PyObject * obj0 = 0 ;
12770 PyObject * obj1 = 0 ;
12771 PyObject * obj2 = 0 ;
12772 PyObject * obj3 = 0 ;
12773 char * kwnames[] = {
12774 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12775 };
12776
12777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12779 if (!SWIG_IsOK(res1)) {
12780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12781 }
12782 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12783 arg2 = obj1;
12784 arg3 = obj2;
12785 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12786 if (!SWIG_IsOK(ecode4)) {
12787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
12788 }
12789 arg4 = static_cast< bool >(val4);
12790 {
12791 PyThreadState* __tstate = wxPyBeginAllowThreads();
12792 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 resultobj = SWIG_Py_Void();
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12804 PyObject *resultobj = 0;
12805 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12806 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
12807 bool arg3 = (bool) false ;
12808 bool result;
12809 void *argp1 = 0 ;
12810 int res1 = 0 ;
12811 int val2 ;
12812 int ecode2 = 0 ;
12813 bool val3 ;
12814 int ecode3 = 0 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 PyObject * obj2 = 0 ;
12818 char * kwnames[] = {
12819 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
12820 };
12821
12822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12824 if (!SWIG_IsOK(res1)) {
12825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12826 }
12827 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12828 if (obj1) {
12829 ecode2 = SWIG_AsVal_int(obj1, &val2);
12830 if (!SWIG_IsOK(ecode2)) {
12831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12832 }
12833 arg2 = static_cast< wxFontEncoding >(val2);
12834 }
12835 if (obj2) {
12836 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12837 if (!SWIG_IsOK(ecode3)) {
12838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "3"" of type '" "bool""'");
12839 }
12840 arg3 = static_cast< bool >(val3);
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (bool)(arg1)->EnumerateFacenames(arg2,arg3);
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 {
12849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12850 }
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12858 PyObject *resultobj = 0;
12859 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12860 wxString const &arg2_defvalue = wxPyEmptyString ;
12861 wxString *arg2 = (wxString *) &arg2_defvalue ;
12862 bool result;
12863 void *argp1 = 0 ;
12864 int res1 = 0 ;
12865 bool temp2 = false ;
12866 PyObject * obj0 = 0 ;
12867 PyObject * obj1 = 0 ;
12868 char * kwnames[] = {
12869 (char *) "self",(char *) "facename", NULL
12870 };
12871
12872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) SWIG_fail;
12873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12874 if (!SWIG_IsOK(res1)) {
12875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12876 }
12877 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12878 if (obj1) {
12879 {
12880 arg2 = wxString_in_helper(obj1);
12881 if (arg2 == NULL) SWIG_fail;
12882 temp2 = true;
12883 }
12884 }
12885 {
12886 PyThreadState* __tstate = wxPyBeginAllowThreads();
12887 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
12888 wxPyEndAllowThreads(__tstate);
12889 if (PyErr_Occurred()) SWIG_fail;
12890 }
12891 {
12892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12893 }
12894 {
12895 if (temp2)
12896 delete arg2;
12897 }
12898 return resultobj;
12899 fail:
12900 {
12901 if (temp2)
12902 delete arg2;
12903 }
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12911 PyObject *result = 0 ;
12912 void *argp1 = 0 ;
12913 int res1 = 0 ;
12914 PyObject *swig_obj[1] ;
12915
12916 if (!args) SWIG_fail;
12917 swig_obj[0] = args;
12918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12919 if (!SWIG_IsOK(res1)) {
12920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_GetEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12921 }
12922 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12923 {
12924 PyThreadState* __tstate = wxPyBeginAllowThreads();
12925 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 resultobj = result;
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 SWIGINTERN PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12937 PyObject *resultobj = 0;
12938 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12939 PyObject *result = 0 ;
12940 void *argp1 = 0 ;
12941 int res1 = 0 ;
12942 PyObject *swig_obj[1] ;
12943
12944 if (!args) SWIG_fail;
12945 swig_obj[0] = args;
12946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12947 if (!SWIG_IsOK(res1)) {
12948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_GetFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12949 }
12950 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 resultobj = result;
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 SWIGINTERN PyObject *FontEnumerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *obj;
12966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12967 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFontEnumerator, SWIG_NewClientData(obj));
12968 return SWIG_Py_Void();
12969 }
12970
12971 SWIGINTERN PyObject *FontEnumerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12972 return SWIG_Python_InitShadowInstance(args);
12973 }
12974
12975 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
12978 int arg2 ;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 int val2 ;
12982 int ecode2 = 0 ;
12983 PyObject *swig_obj[2] ;
12984
12985 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Language_set",2,2,swig_obj)) SWIG_fail;
12986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
12989 }
12990 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
12991 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12992 if (!SWIG_IsOK(ecode2)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LanguageInfo_Language_set" "', expected argument " "2"" of type '" "int""'");
12994 }
12995 arg2 = static_cast< int >(val2);
12996 if (arg1) (arg1)->Language = arg2;
12997
12998 resultobj = SWIG_Py_Void();
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 PyObject *resultobj = 0;
13007 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13008 int result;
13009 void *argp1 = 0 ;
13010 int res1 = 0 ;
13011 PyObject *swig_obj[1] ;
13012
13013 if (!args) SWIG_fail;
13014 swig_obj[0] = args;
13015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13016 if (!SWIG_IsOK(res1)) {
13017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13018 }
13019 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13020 result = (int) ((arg1)->Language);
13021 resultobj = SWIG_From_int(static_cast< int >(result));
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13029 PyObject *resultobj = 0;
13030 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13031 wxString *arg2 = (wxString *) 0 ;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 bool temp2 = false ;
13035 PyObject *swig_obj[2] ;
13036
13037 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_CanonicalName_set",2,2,swig_obj)) SWIG_fail;
13038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13039 if (!SWIG_IsOK(res1)) {
13040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13041 }
13042 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13043 {
13044 arg2 = wxString_in_helper(swig_obj[1]);
13045 if (arg2 == NULL) SWIG_fail;
13046 temp2 = true;
13047 }
13048 if (arg1) (arg1)->CanonicalName = *arg2;
13049
13050 resultobj = SWIG_Py_Void();
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return resultobj;
13056 fail:
13057 {
13058 if (temp2)
13059 delete arg2;
13060 }
13061 return NULL;
13062 }
13063
13064
13065 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13066 PyObject *resultobj = 0;
13067 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13068 wxString *result = 0 ;
13069 void *argp1 = 0 ;
13070 int res1 = 0 ;
13071 PyObject *swig_obj[1] ;
13072
13073 if (!args) SWIG_fail;
13074 swig_obj[0] = args;
13075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13076 if (!SWIG_IsOK(res1)) {
13077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13078 }
13079 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13080 result = (wxString *)& ((arg1)->CanonicalName);
13081 {
13082 #if wxUSE_UNICODE
13083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13084 #else
13085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13086 #endif
13087 }
13088 return resultobj;
13089 fail:
13090 return NULL;
13091 }
13092
13093
13094 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13095 PyObject *resultobj = 0;
13096 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13097 wxString *arg2 = (wxString *) 0 ;
13098 void *argp1 = 0 ;
13099 int res1 = 0 ;
13100 bool temp2 = false ;
13101 PyObject *swig_obj[2] ;
13102
13103 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Description_set",2,2,swig_obj)) SWIG_fail;
13104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13105 if (!SWIG_IsOK(res1)) {
13106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13107 }
13108 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13109 {
13110 arg2 = wxString_in_helper(swig_obj[1]);
13111 if (arg2 == NULL) SWIG_fail;
13112 temp2 = true;
13113 }
13114 if (arg1) (arg1)->Description = *arg2;
13115
13116 resultobj = SWIG_Py_Void();
13117 {
13118 if (temp2)
13119 delete arg2;
13120 }
13121 return resultobj;
13122 fail:
13123 {
13124 if (temp2)
13125 delete arg2;
13126 }
13127 return NULL;
13128 }
13129
13130
13131 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13132 PyObject *resultobj = 0;
13133 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13134 wxString *result = 0 ;
13135 void *argp1 = 0 ;
13136 int res1 = 0 ;
13137 PyObject *swig_obj[1] ;
13138
13139 if (!args) SWIG_fail;
13140 swig_obj[0] = args;
13141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13142 if (!SWIG_IsOK(res1)) {
13143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13144 }
13145 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13146 result = (wxString *)& ((arg1)->Description);
13147 {
13148 #if wxUSE_UNICODE
13149 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13150 #else
13151 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13152 #endif
13153 }
13154 return resultobj;
13155 fail:
13156 return NULL;
13157 }
13158
13159
13160 SWIGINTERN PyObject *LanguageInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13161 PyObject *obj;
13162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13163 SWIG_TypeNewClientData(SWIGTYPE_p_wxLanguageInfo, SWIG_NewClientData(obj));
13164 return SWIG_Py_Void();
13165 }
13166
13167 SWIGINTERN PyObject *_wrap_new_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj = 0;
13169 int arg1 = (int) -1 ;
13170 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
13171 wxLocale *result = 0 ;
13172 int val1 ;
13173 int ecode1 = 0 ;
13174 int val2 ;
13175 int ecode2 = 0 ;
13176 PyObject * obj0 = 0 ;
13177 PyObject * obj1 = 0 ;
13178 char * kwnames[] = {
13179 (char *) "language",(char *) "flags", NULL
13180 };
13181
13182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) SWIG_fail;
13183 if (obj0) {
13184 ecode1 = SWIG_AsVal_int(obj0, &val1);
13185 if (!SWIG_IsOK(ecode1)) {
13186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Locale" "', expected argument " "1"" of type '" "int""'");
13187 }
13188 arg1 = static_cast< int >(val1);
13189 }
13190 if (obj1) {
13191 ecode2 = SWIG_AsVal_int(obj1, &val2);
13192 if (!SWIG_IsOK(ecode2)) {
13193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Locale" "', expected argument " "2"" of type '" "int""'");
13194 }
13195 arg2 = static_cast< int >(val2);
13196 }
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 result = (wxLocale *)new_wxLocale(arg1,arg2);
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, SWIG_POINTER_NEW | 0 );
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 SWIGINTERN PyObject *_wrap_delete_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13211 PyObject *resultobj = 0;
13212 wxLocale *arg1 = (wxLocale *) 0 ;
13213 void *argp1 = 0 ;
13214 int res1 = 0 ;
13215 PyObject *swig_obj[1] ;
13216
13217 if (!args) SWIG_fail;
13218 swig_obj[0] = args;
13219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, SWIG_POINTER_DISOWN | 0 );
13220 if (!SWIG_IsOK(res1)) {
13221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locale" "', expected argument " "1"" of type '" "wxLocale *""'");
13222 }
13223 arg1 = reinterpret_cast< wxLocale * >(argp1);
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 delete arg1;
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 resultobj = SWIG_Py_Void();
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 SWIGINTERN PyObject *_wrap_Locale_Init1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj = 0;
13240 wxLocale *arg1 = (wxLocale *) 0 ;
13241 wxString *arg2 = 0 ;
13242 wxString const &arg3_defvalue = wxPyEmptyString ;
13243 wxString *arg3 = (wxString *) &arg3_defvalue ;
13244 wxString const &arg4_defvalue = wxPyEmptyString ;
13245 wxString *arg4 = (wxString *) &arg4_defvalue ;
13246 bool arg5 = (bool) true ;
13247 bool arg6 = (bool) false ;
13248 bool result;
13249 void *argp1 = 0 ;
13250 int res1 = 0 ;
13251 bool temp2 = false ;
13252 bool temp3 = false ;
13253 bool temp4 = false ;
13254 bool val5 ;
13255 int ecode5 = 0 ;
13256 bool val6 ;
13257 int ecode6 = 0 ;
13258 PyObject * obj0 = 0 ;
13259 PyObject * obj1 = 0 ;
13260 PyObject * obj2 = 0 ;
13261 PyObject * obj3 = 0 ;
13262 PyObject * obj4 = 0 ;
13263 PyObject * obj5 = 0 ;
13264 char * kwnames[] = {
13265 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
13266 };
13267
13268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13270 if (!SWIG_IsOK(res1)) {
13271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init1" "', expected argument " "1"" of type '" "wxLocale *""'");
13272 }
13273 arg1 = reinterpret_cast< wxLocale * >(argp1);
13274 {
13275 arg2 = wxString_in_helper(obj1);
13276 if (arg2 == NULL) SWIG_fail;
13277 temp2 = true;
13278 }
13279 if (obj2) {
13280 {
13281 arg3 = wxString_in_helper(obj2);
13282 if (arg3 == NULL) SWIG_fail;
13283 temp3 = true;
13284 }
13285 }
13286 if (obj3) {
13287 {
13288 arg4 = wxString_in_helper(obj3);
13289 if (arg4 == NULL) SWIG_fail;
13290 temp4 = true;
13291 }
13292 }
13293 if (obj4) {
13294 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13295 if (!SWIG_IsOK(ecode5)) {
13296 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Locale_Init1" "', expected argument " "5"" of type '" "bool""'");
13297 }
13298 arg5 = static_cast< bool >(val5);
13299 }
13300 if (obj5) {
13301 ecode6 = SWIG_AsVal_bool(obj5, &val6);
13302 if (!SWIG_IsOK(ecode6)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Locale_Init1" "', expected argument " "6"" of type '" "bool""'");
13304 }
13305 arg6 = static_cast< bool >(val6);
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 {
13314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13315 }
13316 {
13317 if (temp2)
13318 delete arg2;
13319 }
13320 {
13321 if (temp3)
13322 delete arg3;
13323 }
13324 {
13325 if (temp4)
13326 delete arg4;
13327 }
13328 return resultobj;
13329 fail:
13330 {
13331 if (temp2)
13332 delete arg2;
13333 }
13334 {
13335 if (temp3)
13336 delete arg3;
13337 }
13338 {
13339 if (temp4)
13340 delete arg4;
13341 }
13342 return NULL;
13343 }
13344
13345
13346 SWIGINTERN PyObject *_wrap_Locale_Init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13347 PyObject *resultobj = 0;
13348 wxLocale *arg1 = (wxLocale *) 0 ;
13349 int arg2 = (int) wxLANGUAGE_DEFAULT ;
13350 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
13351 bool result;
13352 void *argp1 = 0 ;
13353 int res1 = 0 ;
13354 int val2 ;
13355 int ecode2 = 0 ;
13356 int val3 ;
13357 int ecode3 = 0 ;
13358 PyObject * obj0 = 0 ;
13359 PyObject * obj1 = 0 ;
13360 PyObject * obj2 = 0 ;
13361 char * kwnames[] = {
13362 (char *) "self",(char *) "language",(char *) "flags", NULL
13363 };
13364
13365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init2" "', expected argument " "1"" of type '" "wxLocale *""'");
13369 }
13370 arg1 = reinterpret_cast< wxLocale * >(argp1);
13371 if (obj1) {
13372 ecode2 = SWIG_AsVal_int(obj1, &val2);
13373 if (!SWIG_IsOK(ecode2)) {
13374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Locale_Init2" "', expected argument " "2"" of type '" "int""'");
13375 }
13376 arg2 = static_cast< int >(val2);
13377 }
13378 if (obj2) {
13379 ecode3 = SWIG_AsVal_int(obj2, &val3);
13380 if (!SWIG_IsOK(ecode3)) {
13381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Locale_Init2" "', expected argument " "3"" of type '" "int""'");
13382 }
13383 arg3 = static_cast< int >(val3);
13384 }
13385 {
13386 PyThreadState* __tstate = wxPyBeginAllowThreads();
13387 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 {
13392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13393 }
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_Locale_GetSystemLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *resultobj = 0;
13402 int result;
13403
13404 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemLanguage",0,0,0)) SWIG_fail;
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (int)wxLocale::GetSystemLanguage();
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_From_int(static_cast< int >(result));
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13419 PyObject *resultobj = 0;
13420 wxFontEncoding result;
13421
13422 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncoding",0,0,0)) SWIG_fail;
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 resultobj = SWIG_From_int(static_cast< int >(result));
13430 return resultobj;
13431 fail:
13432 return NULL;
13433 }
13434
13435
13436 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13437 PyObject *resultobj = 0;
13438 wxString result;
13439
13440 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncodingName",0,0,0)) SWIG_fail;
13441 {
13442 PyThreadState* __tstate = wxPyBeginAllowThreads();
13443 result = wxLocale::GetSystemEncodingName();
13444 wxPyEndAllowThreads(__tstate);
13445 if (PyErr_Occurred()) SWIG_fail;
13446 }
13447 {
13448 #if wxUSE_UNICODE
13449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13450 #else
13451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13452 #endif
13453 }
13454 return resultobj;
13455 fail:
13456 return NULL;
13457 }
13458
13459
13460 SWIGINTERN PyObject *_wrap_Locale_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13461 PyObject *resultobj = 0;
13462 wxLocale *arg1 = (wxLocale *) 0 ;
13463 bool result;
13464 void *argp1 = 0 ;
13465 int res1 = 0 ;
13466 PyObject *swig_obj[1] ;
13467
13468 if (!args) SWIG_fail;
13469 swig_obj[0] = args;
13470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13471 if (!SWIG_IsOK(res1)) {
13472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsOk" "', expected argument " "1"" of type '" "wxLocale const *""'");
13473 }
13474 arg1 = reinterpret_cast< wxLocale * >(argp1);
13475 {
13476 PyThreadState* __tstate = wxPyBeginAllowThreads();
13477 result = (bool)((wxLocale const *)arg1)->IsOk();
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13483 }
13484 return resultobj;
13485 fail:
13486 return NULL;
13487 }
13488
13489
13490 SWIGINTERN PyObject *_wrap_Locale_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13491 PyObject *resultobj = 0;
13492 wxLocale *arg1 = (wxLocale *) 0 ;
13493 wxString result;
13494 void *argp1 = 0 ;
13495 int res1 = 0 ;
13496 PyObject *swig_obj[1] ;
13497
13498 if (!args) SWIG_fail;
13499 swig_obj[0] = args;
13500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13501 if (!SWIG_IsOK(res1)) {
13502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLocale" "', expected argument " "1"" of type '" "wxLocale const *""'");
13503 }
13504 arg1 = reinterpret_cast< wxLocale * >(argp1);
13505 {
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 result = ((wxLocale const *)arg1)->GetLocale();
13508 wxPyEndAllowThreads(__tstate);
13509 if (PyErr_Occurred()) SWIG_fail;
13510 }
13511 {
13512 #if wxUSE_UNICODE
13513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13514 #else
13515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13516 #endif
13517 }
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 SWIGINTERN PyObject *_wrap_Locale_GetLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13525 PyObject *resultobj = 0;
13526 wxLocale *arg1 = (wxLocale *) 0 ;
13527 int result;
13528 void *argp1 = 0 ;
13529 int res1 = 0 ;
13530 PyObject *swig_obj[1] ;
13531
13532 if (!args) SWIG_fail;
13533 swig_obj[0] = args;
13534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13535 if (!SWIG_IsOK(res1)) {
13536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLanguage" "', expected argument " "1"" of type '" "wxLocale const *""'");
13537 }
13538 arg1 = reinterpret_cast< wxLocale * >(argp1);
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = (int)((wxLocale const *)arg1)->GetLanguage();
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 resultobj = SWIG_From_int(static_cast< int >(result));
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_Locale_GetSysName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13553 PyObject *resultobj = 0;
13554 wxLocale *arg1 = (wxLocale *) 0 ;
13555 wxString result;
13556 void *argp1 = 0 ;
13557 int res1 = 0 ;
13558 PyObject *swig_obj[1] ;
13559
13560 if (!args) SWIG_fail;
13561 swig_obj[0] = args;
13562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13563 if (!SWIG_IsOK(res1)) {
13564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetSysName" "', expected argument " "1"" of type '" "wxLocale const *""'");
13565 }
13566 arg1 = reinterpret_cast< wxLocale * >(argp1);
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = ((wxLocale const *)arg1)->GetSysName();
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 {
13574 #if wxUSE_UNICODE
13575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13576 #else
13577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13578 #endif
13579 }
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 SWIGINTERN PyObject *_wrap_Locale_GetCanonicalName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13587 PyObject *resultobj = 0;
13588 wxLocale *arg1 = (wxLocale *) 0 ;
13589 wxString result;
13590 void *argp1 = 0 ;
13591 int res1 = 0 ;
13592 PyObject *swig_obj[1] ;
13593
13594 if (!args) SWIG_fail;
13595 swig_obj[0] = args;
13596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13597 if (!SWIG_IsOK(res1)) {
13598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetCanonicalName" "', expected argument " "1"" of type '" "wxLocale const *""'");
13599 }
13600 arg1 = reinterpret_cast< wxLocale * >(argp1);
13601 {
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 result = ((wxLocale const *)arg1)->GetCanonicalName();
13604 wxPyEndAllowThreads(__tstate);
13605 if (PyErr_Occurred()) SWIG_fail;
13606 }
13607 {
13608 #if wxUSE_UNICODE
13609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13610 #else
13611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13612 #endif
13613 }
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj = 0;
13622 wxString *arg1 = 0 ;
13623 bool temp1 = false ;
13624 PyObject * obj0 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "prefix", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) SWIG_fail;
13630 {
13631 arg1 = wxString_in_helper(obj0);
13632 if (arg1 == NULL) SWIG_fail;
13633 temp1 = true;
13634 }
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 {
13643 if (temp1)
13644 delete arg1;
13645 }
13646 return resultobj;
13647 fail:
13648 {
13649 if (temp1)
13650 delete arg1;
13651 }
13652 return NULL;
13653 }
13654
13655
13656 SWIGINTERN PyObject *_wrap_Locale_AddCatalog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj = 0;
13658 wxLocale *arg1 = (wxLocale *) 0 ;
13659 wxString *arg2 = 0 ;
13660 bool result;
13661 void *argp1 = 0 ;
13662 int res1 = 0 ;
13663 bool temp2 = false ;
13664 PyObject * obj0 = 0 ;
13665 PyObject * obj1 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "self",(char *) "szDomain", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) SWIG_fail;
13671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13672 if (!SWIG_IsOK(res1)) {
13673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddCatalog" "', expected argument " "1"" of type '" "wxLocale *""'");
13674 }
13675 arg1 = reinterpret_cast< wxLocale * >(argp1);
13676 {
13677 arg2 = wxString_in_helper(obj1);
13678 if (arg2 == NULL) SWIG_fail;
13679 temp2 = true;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
13684 wxPyEndAllowThreads(__tstate);
13685 if (PyErr_Occurred()) SWIG_fail;
13686 }
13687 {
13688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13689 }
13690 {
13691 if (temp2)
13692 delete arg2;
13693 }
13694 return resultobj;
13695 fail:
13696 {
13697 if (temp2)
13698 delete arg2;
13699 }
13700 return NULL;
13701 }
13702
13703
13704 SWIGINTERN PyObject *_wrap_Locale_IsLoaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = 0;
13706 wxLocale *arg1 = (wxLocale *) 0 ;
13707 wxString *arg2 = 0 ;
13708 bool result;
13709 void *argp1 = 0 ;
13710 int res1 = 0 ;
13711 bool temp2 = false ;
13712 PyObject * obj0 = 0 ;
13713 PyObject * obj1 = 0 ;
13714 char * kwnames[] = {
13715 (char *) "self",(char *) "szDomain", NULL
13716 };
13717
13718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) SWIG_fail;
13719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13720 if (!SWIG_IsOK(res1)) {
13721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsLoaded" "', expected argument " "1"" of type '" "wxLocale const *""'");
13722 }
13723 arg1 = reinterpret_cast< wxLocale * >(argp1);
13724 {
13725 arg2 = wxString_in_helper(obj1);
13726 if (arg2 == NULL) SWIG_fail;
13727 temp2 = true;
13728 }
13729 {
13730 PyThreadState* __tstate = wxPyBeginAllowThreads();
13731 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
13732 wxPyEndAllowThreads(__tstate);
13733 if (PyErr_Occurred()) SWIG_fail;
13734 }
13735 {
13736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13737 }
13738 {
13739 if (temp2)
13740 delete arg2;
13741 }
13742 return resultobj;
13743 fail:
13744 {
13745 if (temp2)
13746 delete arg2;
13747 }
13748 return NULL;
13749 }
13750
13751
13752 SWIGINTERN PyObject *_wrap_Locale_GetLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13753 PyObject *resultobj = 0;
13754 int arg1 ;
13755 wxLanguageInfo *result = 0 ;
13756 int val1 ;
13757 int ecode1 = 0 ;
13758 PyObject * obj0 = 0 ;
13759 char * kwnames[] = {
13760 (char *) "lang", NULL
13761 };
13762
13763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) SWIG_fail;
13764 ecode1 = SWIG_AsVal_int(obj0, &val1);
13765 if (!SWIG_IsOK(ecode1)) {
13766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageInfo" "', expected argument " "1"" of type '" "int""'");
13767 }
13768 arg1 = static_cast< int >(val1);
13769 {
13770 PyThreadState* __tstate = wxPyBeginAllowThreads();
13771 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
13772 wxPyEndAllowThreads(__tstate);
13773 if (PyErr_Occurred()) SWIG_fail;
13774 }
13775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13776 return resultobj;
13777 fail:
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *_wrap_Locale_GetLanguageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj = 0;
13784 int arg1 ;
13785 wxString result;
13786 int val1 ;
13787 int ecode1 = 0 ;
13788 PyObject * obj0 = 0 ;
13789 char * kwnames[] = {
13790 (char *) "lang", NULL
13791 };
13792
13793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) SWIG_fail;
13794 ecode1 = SWIG_AsVal_int(obj0, &val1);
13795 if (!SWIG_IsOK(ecode1)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageName" "', expected argument " "1"" of type '" "int""'");
13797 }
13798 arg1 = static_cast< int >(val1);
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = wxLocale::GetLanguageName(arg1);
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 {
13806 #if wxUSE_UNICODE
13807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13808 #else
13809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13810 #endif
13811 }
13812 return resultobj;
13813 fail:
13814 return NULL;
13815 }
13816
13817
13818 SWIGINTERN PyObject *_wrap_Locale_FindLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13819 PyObject *resultobj = 0;
13820 wxString *arg1 = 0 ;
13821 wxLanguageInfo *result = 0 ;
13822 bool temp1 = false ;
13823 PyObject * obj0 = 0 ;
13824 char * kwnames[] = {
13825 (char *) "locale", NULL
13826 };
13827
13828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) SWIG_fail;
13829 {
13830 arg1 = wxString_in_helper(obj0);
13831 if (arg1 == NULL) SWIG_fail;
13832 temp1 = true;
13833 }
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13841 {
13842 if (temp1)
13843 delete arg1;
13844 }
13845 return resultobj;
13846 fail:
13847 {
13848 if (temp1)
13849 delete arg1;
13850 }
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Locale_AddLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxLanguageInfo *arg1 = 0 ;
13858 void *argp1 = 0 ;
13859 int res1 = 0 ;
13860 PyObject * obj0 = 0 ;
13861 char * kwnames[] = {
13862 (char *) "info", NULL
13863 };
13864
13865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) SWIG_fail;
13866 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxLanguageInfo, 0 | 0);
13867 if (!SWIG_IsOK(res1)) {
13868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
13869 }
13870 if (!argp1) {
13871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
13872 }
13873 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
13877 wxPyEndAllowThreads(__tstate);
13878 if (PyErr_Occurred()) SWIG_fail;
13879 }
13880 resultobj = SWIG_Py_Void();
13881 return resultobj;
13882 fail:
13883 return NULL;
13884 }
13885
13886
13887 SWIGINTERN PyObject *_wrap_Locale_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj = 0;
13889 wxLocale *arg1 = (wxLocale *) 0 ;
13890 wxString *arg2 = 0 ;
13891 wxString const &arg3_defvalue = wxPyEmptyString ;
13892 wxString *arg3 = (wxString *) &arg3_defvalue ;
13893 wxString result;
13894 void *argp1 = 0 ;
13895 int res1 = 0 ;
13896 bool temp2 = false ;
13897 bool temp3 = false ;
13898 PyObject * obj0 = 0 ;
13899 PyObject * obj1 = 0 ;
13900 PyObject * obj2 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13907 if (!SWIG_IsOK(res1)) {
13908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetString" "', expected argument " "1"" of type '" "wxLocale const *""'");
13909 }
13910 arg1 = reinterpret_cast< wxLocale * >(argp1);
13911 {
13912 arg2 = wxString_in_helper(obj1);
13913 if (arg2 == NULL) SWIG_fail;
13914 temp2 = true;
13915 }
13916 if (obj2) {
13917 {
13918 arg3 = wxString_in_helper(obj2);
13919 if (arg3 == NULL) SWIG_fail;
13920 temp3 = true;
13921 }
13922 }
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 {
13930 #if wxUSE_UNICODE
13931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13932 #else
13933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13934 #endif
13935 }
13936 {
13937 if (temp2)
13938 delete arg2;
13939 }
13940 {
13941 if (temp3)
13942 delete arg3;
13943 }
13944 return resultobj;
13945 fail:
13946 {
13947 if (temp2)
13948 delete arg2;
13949 }
13950 {
13951 if (temp3)
13952 delete arg3;
13953 }
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_Locale_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13959 PyObject *resultobj = 0;
13960 wxLocale *arg1 = (wxLocale *) 0 ;
13961 wxString *result = 0 ;
13962 void *argp1 = 0 ;
13963 int res1 = 0 ;
13964 PyObject *swig_obj[1] ;
13965
13966 if (!args) SWIG_fail;
13967 swig_obj[0] = args;
13968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13969 if (!SWIG_IsOK(res1)) {
13970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetName" "', expected argument " "1"" of type '" "wxLocale const *""'");
13971 }
13972 arg1 = reinterpret_cast< wxLocale * >(argp1);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 {
13976 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
13977 result = (wxString *) &_result_ref;
13978 }
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 {
13983 #if wxUSE_UNICODE
13984 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13985 #else
13986 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13987 #endif
13988 }
13989 return resultobj;
13990 fail:
13991 return NULL;
13992 }
13993
13994
13995 SWIGINTERN PyObject *Locale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13996 PyObject *obj;
13997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13998 SWIG_TypeNewClientData(SWIGTYPE_p_wxLocale, SWIG_NewClientData(obj));
13999 return SWIG_Py_Void();
14000 }
14001
14002 SWIGINTERN PyObject *Locale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14003 return SWIG_Python_InitShadowInstance(args);
14004 }
14005
14006 SWIGINTERN PyObject *_wrap_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14007 PyObject *resultobj = 0;
14008 wxLocale *result = 0 ;
14009
14010 if (!SWIG_Python_UnpackTuple(args,"GetLocale",0,0,0)) SWIG_fail;
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (wxLocale *)wxGetLocale();
14014 wxPyEndAllowThreads(__tstate);
14015 if (PyErr_Occurred()) SWIG_fail;
14016 }
14017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, 0 | 0 );
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14025 PyObject *resultobj = 0;
14026 wxString *arg1 = 0 ;
14027 wxString result;
14028 bool temp1 = false ;
14029
14030 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
14031 {
14032 arg1 = wxString_in_helper(swig_obj[0]);
14033 if (arg1 == NULL) SWIG_fail;
14034 temp1 = true;
14035 }
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 result = wxGetTranslation((wxString const &)*arg1);
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 {
14043 #if wxUSE_UNICODE
14044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14045 #else
14046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14047 #endif
14048 }
14049 {
14050 if (temp1)
14051 delete arg1;
14052 }
14053 return resultobj;
14054 fail:
14055 {
14056 if (temp1)
14057 delete arg1;
14058 }
14059 return NULL;
14060 }
14061
14062
14063 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14064 PyObject *resultobj = 0;
14065 wxString *arg1 = 0 ;
14066 wxString *arg2 = 0 ;
14067 size_t arg3 ;
14068 wxString result;
14069 bool temp1 = false ;
14070 bool temp2 = false ;
14071 size_t val3 ;
14072 int ecode3 = 0 ;
14073
14074 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14075 {
14076 arg1 = wxString_in_helper(swig_obj[0]);
14077 if (arg1 == NULL) SWIG_fail;
14078 temp1 = true;
14079 }
14080 {
14081 arg2 = wxString_in_helper(swig_obj[1]);
14082 if (arg2 == NULL) SWIG_fail;
14083 temp2 = true;
14084 }
14085 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
14086 if (!SWIG_IsOK(ecode3)) {
14087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
14088 }
14089 arg3 = static_cast< size_t >(val3);
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 {
14097 #if wxUSE_UNICODE
14098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14099 #else
14100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14101 #endif
14102 }
14103 {
14104 if (temp1)
14105 delete arg1;
14106 }
14107 {
14108 if (temp2)
14109 delete arg2;
14110 }
14111 return resultobj;
14112 fail:
14113 {
14114 if (temp1)
14115 delete arg1;
14116 }
14117 {
14118 if (temp2)
14119 delete arg2;
14120 }
14121 return NULL;
14122 }
14123
14124
14125 SWIGINTERN PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
14126 int argc;
14127 PyObject *argv[4];
14128
14129 if (!(argc = SWIG_Python_UnpackTuple(args,"GetTranslation",0,3,argv))) SWIG_fail;
14130 --argc;
14131 if (argc == 1) {
14132 return _wrap_GetTranslation__SWIG_0(self, argc, argv);
14133 }
14134 if (argc == 3) {
14135 return _wrap_GetTranslation__SWIG_1(self, argc, argv);
14136 }
14137
14138 fail:
14139 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
14140 return NULL;
14141 }
14142
14143
14144 SWIGINTERN PyObject *_wrap_new_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14145 PyObject *resultobj = 0;
14146 wxEncodingConverter *result = 0 ;
14147
14148 if (!SWIG_Python_UnpackTuple(args,"new_EncodingConverter",0,0,0)) SWIG_fail;
14149 {
14150 PyThreadState* __tstate = wxPyBeginAllowThreads();
14151 result = (wxEncodingConverter *)new wxEncodingConverter();
14152 wxPyEndAllowThreads(__tstate);
14153 if (PyErr_Occurred()) SWIG_fail;
14154 }
14155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_NEW | 0 );
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 SWIGINTERN PyObject *_wrap_delete_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14163 PyObject *resultobj = 0;
14164 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14165 void *argp1 = 0 ;
14166 int res1 = 0 ;
14167 PyObject *swig_obj[1] ;
14168
14169 if (!args) SWIG_fail;
14170 swig_obj[0] = args;
14171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_DISOWN | 0 );
14172 if (!SWIG_IsOK(res1)) {
14173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingConverter" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14174 }
14175 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 delete arg1;
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_Py_Void();
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_EncodingConverter_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj = 0;
14192 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14193 wxFontEncoding arg2 ;
14194 wxFontEncoding arg3 ;
14195 int arg4 = (int) wxCONVERT_STRICT ;
14196 bool result;
14197 void *argp1 = 0 ;
14198 int res1 = 0 ;
14199 int val2 ;
14200 int ecode2 = 0 ;
14201 int val3 ;
14202 int ecode3 = 0 ;
14203 int val4 ;
14204 int ecode4 = 0 ;
14205 PyObject * obj0 = 0 ;
14206 PyObject * obj1 = 0 ;
14207 PyObject * obj2 = 0 ;
14208 PyObject * obj3 = 0 ;
14209 char * kwnames[] = {
14210 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
14211 };
14212
14213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
14215 if (!SWIG_IsOK(res1)) {
14216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Init" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14217 }
14218 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14219 ecode2 = SWIG_AsVal_int(obj1, &val2);
14220 if (!SWIG_IsOK(ecode2)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_Init" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14222 }
14223 arg2 = static_cast< wxFontEncoding >(val2);
14224 ecode3 = SWIG_AsVal_int(obj2, &val3);
14225 if (!SWIG_IsOK(ecode3)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EncodingConverter_Init" "', expected argument " "3"" of type '" "wxFontEncoding""'");
14227 }
14228 arg3 = static_cast< wxFontEncoding >(val3);
14229 if (obj3) {
14230 ecode4 = SWIG_AsVal_int(obj3, &val4);
14231 if (!SWIG_IsOK(ecode4)) {
14232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EncodingConverter_Init" "', expected argument " "4"" of type '" "int""'");
14233 }
14234 arg4 = static_cast< int >(val4);
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (bool)(arg1)->Init(arg2,arg3,arg4);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 {
14243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14244 }
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 SWIGINTERN PyObject *_wrap_EncodingConverter_Convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14252 PyObject *resultobj = 0;
14253 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14254 wxString *arg2 = 0 ;
14255 wxString result;
14256 void *argp1 = 0 ;
14257 int res1 = 0 ;
14258 bool temp2 = false ;
14259 PyObject * obj0 = 0 ;
14260 PyObject * obj1 = 0 ;
14261 char * kwnames[] = {
14262 (char *) "self",(char *) "input", NULL
14263 };
14264
14265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) SWIG_fail;
14266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
14267 if (!SWIG_IsOK(res1)) {
14268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Convert" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14269 }
14270 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14271 {
14272 arg2 = wxString_in_helper(obj1);
14273 if (arg2 == NULL) SWIG_fail;
14274 temp2 = true;
14275 }
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (arg1)->Convert((wxString const &)*arg2);
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 {
14283 #if wxUSE_UNICODE
14284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14285 #else
14286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14287 #endif
14288 }
14289 {
14290 if (temp2)
14291 delete arg2;
14292 }
14293 return resultobj;
14294 fail:
14295 {
14296 if (temp2)
14297 delete arg2;
14298 }
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj = 0;
14305 wxFontEncoding arg1 ;
14306 int arg2 = (int) wxPLATFORM_CURRENT ;
14307 wxFontEncodingArray result;
14308 int val1 ;
14309 int ecode1 = 0 ;
14310 int val2 ;
14311 int ecode2 = 0 ;
14312 PyObject * obj0 = 0 ;
14313 PyObject * obj1 = 0 ;
14314 char * kwnames[] = {
14315 (char *) "enc",(char *) "platform", NULL
14316 };
14317
14318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) SWIG_fail;
14319 ecode1 = SWIG_AsVal_int(obj0, &val1);
14320 if (!SWIG_IsOK(ecode1)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14322 }
14323 arg1 = static_cast< wxFontEncoding >(val1);
14324 if (obj1) {
14325 ecode2 = SWIG_AsVal_int(obj1, &val2);
14326 if (!SWIG_IsOK(ecode2)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "2"" of type '" "int""'");
14328 }
14329 arg2 = static_cast< int >(val2);
14330 }
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = wxEncodingConverter::GetPlatformEquivalents(arg1,arg2);
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 {
14338 resultobj = PyList_New(0);
14339 for (size_t i=0; i < (&result)->GetCount(); i++) {
14340 PyObject* number = PyInt_FromLong((&result)->Item(i));
14341 PyList_Append(resultobj, number);
14342 Py_DECREF(number);
14343 }
14344 }
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14352 PyObject *resultobj = 0;
14353 wxFontEncoding arg1 ;
14354 wxFontEncodingArray result;
14355 int val1 ;
14356 int ecode1 = 0 ;
14357 PyObject * obj0 = 0 ;
14358 char * kwnames[] = {
14359 (char *) "enc", NULL
14360 };
14361
14362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) SWIG_fail;
14363 ecode1 = SWIG_AsVal_int(obj0, &val1);
14364 if (!SWIG_IsOK(ecode1)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetAllEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14366 }
14367 arg1 = static_cast< wxFontEncoding >(val1);
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = wxEncodingConverter::GetAllEquivalents(arg1);
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 {
14375 resultobj = PyList_New(0);
14376 for (size_t i=0; i < (&result)->GetCount(); i++) {
14377 PyObject* number = PyInt_FromLong((&result)->Item(i));
14378 PyList_Append(resultobj, number);
14379 Py_DECREF(number);
14380 }
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_EncodingConverter_CanConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxFontEncoding arg1 ;
14391 wxFontEncoding arg2 ;
14392 bool result;
14393 int val1 ;
14394 int ecode1 = 0 ;
14395 int val2 ;
14396 int ecode2 = 0 ;
14397 PyObject * obj0 = 0 ;
14398 PyObject * obj1 = 0 ;
14399 char * kwnames[] = {
14400 (char *) "encIn",(char *) "encOut", NULL
14401 };
14402
14403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) SWIG_fail;
14404 ecode1 = SWIG_AsVal_int(obj0, &val1);
14405 if (!SWIG_IsOK(ecode1)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_CanConvert" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14407 }
14408 arg1 = static_cast< wxFontEncoding >(val1);
14409 ecode2 = SWIG_AsVal_int(obj1, &val2);
14410 if (!SWIG_IsOK(ecode2)) {
14411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_CanConvert" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14412 }
14413 arg2 = static_cast< wxFontEncoding >(val2);
14414 {
14415 PyThreadState* __tstate = wxPyBeginAllowThreads();
14416 result = (bool)wxEncodingConverter::CanConvert(arg1,arg2);
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 {
14421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14422 }
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *EncodingConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14430 PyObject *obj;
14431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14432 SWIG_TypeNewClientData(SWIGTYPE_p_wxEncodingConverter, SWIG_NewClientData(obj));
14433 return SWIG_Py_Void();
14434 }
14435
14436 SWIGINTERN PyObject *EncodingConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14437 return SWIG_Python_InitShadowInstance(args);
14438 }
14439
14440 SWIGINTERN PyObject *_wrap_delete_DC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14441 PyObject *resultobj = 0;
14442 wxDC *arg1 = (wxDC *) 0 ;
14443 void *argp1 = 0 ;
14444 int res1 = 0 ;
14445 PyObject *swig_obj[1] ;
14446
14447 if (!args) SWIG_fail;
14448 swig_obj[0] = args;
14449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, SWIG_POINTER_DISOWN | 0 );
14450 if (!SWIG_IsOK(res1)) {
14451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DC" "', expected argument " "1"" of type '" "wxDC *""'");
14452 }
14453 arg1 = reinterpret_cast< wxDC * >(argp1);
14454 {
14455 PyThreadState* __tstate = wxPyBeginAllowThreads();
14456 delete arg1;
14457
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 resultobj = SWIG_Py_Void();
14462 return resultobj;
14463 fail:
14464 return NULL;
14465 }
14466
14467
14468 SWIGINTERN PyObject *_wrap_DC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14469 PyObject *resultobj = 0;
14470 wxDC *arg1 = (wxDC *) 0 ;
14471 int arg2 ;
14472 int arg3 ;
14473 wxColour *arg4 = 0 ;
14474 int arg5 = (int) wxFLOOD_SURFACE ;
14475 bool result;
14476 void *argp1 = 0 ;
14477 int res1 = 0 ;
14478 int val2 ;
14479 int ecode2 = 0 ;
14480 int val3 ;
14481 int ecode3 = 0 ;
14482 wxColour temp4 ;
14483 int val5 ;
14484 int ecode5 = 0 ;
14485 PyObject * obj0 = 0 ;
14486 PyObject * obj1 = 0 ;
14487 PyObject * obj2 = 0 ;
14488 PyObject * obj3 = 0 ;
14489 PyObject * obj4 = 0 ;
14490 char * kwnames[] = {
14491 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
14492 };
14493
14494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14496 if (!SWIG_IsOK(res1)) {
14497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFill" "', expected argument " "1"" of type '" "wxDC *""'");
14498 }
14499 arg1 = reinterpret_cast< wxDC * >(argp1);
14500 ecode2 = SWIG_AsVal_int(obj1, &val2);
14501 if (!SWIG_IsOK(ecode2)) {
14502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_FloodFill" "', expected argument " "2"" of type '" "int""'");
14503 }
14504 arg2 = static_cast< int >(val2);
14505 ecode3 = SWIG_AsVal_int(obj2, &val3);
14506 if (!SWIG_IsOK(ecode3)) {
14507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_FloodFill" "', expected argument " "3"" of type '" "int""'");
14508 }
14509 arg3 = static_cast< int >(val3);
14510 {
14511 arg4 = &temp4;
14512 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14513 }
14514 if (obj4) {
14515 ecode5 = SWIG_AsVal_int(obj4, &val5);
14516 if (!SWIG_IsOK(ecode5)) {
14517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_FloodFill" "', expected argument " "5"" of type '" "int""'");
14518 }
14519 arg5 = static_cast< int >(val5);
14520 }
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 {
14528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14529 }
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_DC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxDC *arg1 = (wxDC *) 0 ;
14539 wxPoint *arg2 = 0 ;
14540 wxColour *arg3 = 0 ;
14541 int arg4 = (int) wxFLOOD_SURFACE ;
14542 bool result;
14543 void *argp1 = 0 ;
14544 int res1 = 0 ;
14545 wxPoint temp2 ;
14546 wxColour temp3 ;
14547 int val4 ;
14548 int ecode4 = 0 ;
14549 PyObject * obj0 = 0 ;
14550 PyObject * obj1 = 0 ;
14551 PyObject * obj2 = 0 ;
14552 PyObject * obj3 = 0 ;
14553 char * kwnames[] = {
14554 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
14555 };
14556
14557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14559 if (!SWIG_IsOK(res1)) {
14560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFillPoint" "', expected argument " "1"" of type '" "wxDC *""'");
14561 }
14562 arg1 = reinterpret_cast< wxDC * >(argp1);
14563 {
14564 arg2 = &temp2;
14565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14566 }
14567 {
14568 arg3 = &temp3;
14569 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14570 }
14571 if (obj3) {
14572 ecode4 = SWIG_AsVal_int(obj3, &val4);
14573 if (!SWIG_IsOK(ecode4)) {
14574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
14575 }
14576 arg4 = static_cast< int >(val4);
14577 }
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 {
14585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14586 }
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 SWIGINTERN PyObject *_wrap_DC_GradientFillConcentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14594 PyObject *resultobj = 0;
14595 wxDC *arg1 = (wxDC *) 0 ;
14596 wxRect *arg2 = 0 ;
14597 wxColour *arg3 = 0 ;
14598 wxColour *arg4 = 0 ;
14599 wxPoint *arg5 = 0 ;
14600 void *argp1 = 0 ;
14601 int res1 = 0 ;
14602 wxRect temp2 ;
14603 wxColour temp3 ;
14604 wxColour temp4 ;
14605 wxPoint temp5 ;
14606 PyObject * obj0 = 0 ;
14607 PyObject * obj1 = 0 ;
14608 PyObject * obj2 = 0 ;
14609 PyObject * obj3 = 0 ;
14610 PyObject * obj4 = 0 ;
14611 char * kwnames[] = {
14612 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "circleCenter", NULL
14613 };
14614
14615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_GradientFillConcentric",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillConcentric" "', expected argument " "1"" of type '" "wxDC *""'");
14619 }
14620 arg1 = reinterpret_cast< wxDC * >(argp1);
14621 {
14622 arg2 = &temp2;
14623 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14624 }
14625 {
14626 arg3 = &temp3;
14627 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14628 }
14629 {
14630 arg4 = &temp4;
14631 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14632 }
14633 {
14634 arg5 = &temp5;
14635 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14636 }
14637 {
14638 PyThreadState* __tstate = wxPyBeginAllowThreads();
14639 (arg1)->GradientFillConcentric((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5);
14640 wxPyEndAllowThreads(__tstate);
14641 if (PyErr_Occurred()) SWIG_fail;
14642 }
14643 resultobj = SWIG_Py_Void();
14644 return resultobj;
14645 fail:
14646 return NULL;
14647 }
14648
14649
14650 SWIGINTERN PyObject *_wrap_DC_GradientFillLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14651 PyObject *resultobj = 0;
14652 wxDC *arg1 = (wxDC *) 0 ;
14653 wxRect *arg2 = 0 ;
14654 wxColour *arg3 = 0 ;
14655 wxColour *arg4 = 0 ;
14656 wxDirection arg5 = (wxDirection) wxEAST ;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 wxRect temp2 ;
14660 wxColour temp3 ;
14661 wxColour temp4 ;
14662 int val5 ;
14663 int ecode5 = 0 ;
14664 PyObject * obj0 = 0 ;
14665 PyObject * obj1 = 0 ;
14666 PyObject * obj2 = 0 ;
14667 PyObject * obj3 = 0 ;
14668 PyObject * obj4 = 0 ;
14669 char * kwnames[] = {
14670 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "nDirection", NULL
14671 };
14672
14673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_GradientFillLinear",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14675 if (!SWIG_IsOK(res1)) {
14676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillLinear" "', expected argument " "1"" of type '" "wxDC *""'");
14677 }
14678 arg1 = reinterpret_cast< wxDC * >(argp1);
14679 {
14680 arg2 = &temp2;
14681 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14682 }
14683 {
14684 arg3 = &temp3;
14685 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14686 }
14687 {
14688 arg4 = &temp4;
14689 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14690 }
14691 if (obj4) {
14692 ecode5 = SWIG_AsVal_int(obj4, &val5);
14693 if (!SWIG_IsOK(ecode5)) {
14694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_GradientFillLinear" "', expected argument " "5"" of type '" "wxDirection""'");
14695 }
14696 arg5 = static_cast< wxDirection >(val5);
14697 }
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 (arg1)->GradientFillLinear((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,arg5);
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 resultobj = SWIG_Py_Void();
14705 return resultobj;
14706 fail:
14707 return NULL;
14708 }
14709
14710
14711 SWIGINTERN PyObject *_wrap_DC_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14712 PyObject *resultobj = 0;
14713 wxDC *arg1 = (wxDC *) 0 ;
14714 int arg2 ;
14715 int arg3 ;
14716 wxColour result;
14717 void *argp1 = 0 ;
14718 int res1 = 0 ;
14719 int val2 ;
14720 int ecode2 = 0 ;
14721 int val3 ;
14722 int ecode3 = 0 ;
14723 PyObject * obj0 = 0 ;
14724 PyObject * obj1 = 0 ;
14725 PyObject * obj2 = 0 ;
14726 char * kwnames[] = {
14727 (char *) "self",(char *) "x",(char *) "y", NULL
14728 };
14729
14730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14732 if (!SWIG_IsOK(res1)) {
14733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixel" "', expected argument " "1"" of type '" "wxDC *""'");
14734 }
14735 arg1 = reinterpret_cast< wxDC * >(argp1);
14736 ecode2 = SWIG_AsVal_int(obj1, &val2);
14737 if (!SWIG_IsOK(ecode2)) {
14738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_GetPixel" "', expected argument " "2"" of type '" "int""'");
14739 }
14740 arg2 = static_cast< int >(val2);
14741 ecode3 = SWIG_AsVal_int(obj2, &val3);
14742 if (!SWIG_IsOK(ecode3)) {
14743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_GetPixel" "', expected argument " "3"" of type '" "int""'");
14744 }
14745 arg3 = static_cast< int >(val3);
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = wxDC_GetPixel(arg1,arg2,arg3);
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *_wrap_DC_GetPixelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj = 0;
14761 wxDC *arg1 = (wxDC *) 0 ;
14762 wxPoint *arg2 = 0 ;
14763 wxColour result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 wxPoint temp2 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "pt", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixelPoint" "', expected argument " "1"" of type '" "wxDC *""'");
14777 }
14778 arg1 = reinterpret_cast< wxDC * >(argp1);
14779 {
14780 arg2 = &temp2;
14781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_DC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxDC *arg1 = (wxDC *) 0 ;
14799 int arg2 ;
14800 int arg3 ;
14801 int arg4 ;
14802 int arg5 ;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 int val2 ;
14806 int ecode2 = 0 ;
14807 int val3 ;
14808 int ecode3 = 0 ;
14809 int val4 ;
14810 int ecode4 = 0 ;
14811 int val5 ;
14812 int ecode5 = 0 ;
14813 PyObject * obj0 = 0 ;
14814 PyObject * obj1 = 0 ;
14815 PyObject * obj2 = 0 ;
14816 PyObject * obj3 = 0 ;
14817 PyObject * obj4 = 0 ;
14818 char * kwnames[] = {
14819 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
14820 };
14821
14822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14824 if (!SWIG_IsOK(res1)) {
14825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLine" "', expected argument " "1"" of type '" "wxDC *""'");
14826 }
14827 arg1 = reinterpret_cast< wxDC * >(argp1);
14828 ecode2 = SWIG_AsVal_int(obj1, &val2);
14829 if (!SWIG_IsOK(ecode2)) {
14830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawLine" "', expected argument " "2"" of type '" "int""'");
14831 }
14832 arg2 = static_cast< int >(val2);
14833 ecode3 = SWIG_AsVal_int(obj2, &val3);
14834 if (!SWIG_IsOK(ecode3)) {
14835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawLine" "', expected argument " "3"" of type '" "int""'");
14836 }
14837 arg3 = static_cast< int >(val3);
14838 ecode4 = SWIG_AsVal_int(obj3, &val4);
14839 if (!SWIG_IsOK(ecode4)) {
14840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLine" "', expected argument " "4"" of type '" "int""'");
14841 }
14842 arg4 = static_cast< int >(val4);
14843 ecode5 = SWIG_AsVal_int(obj4, &val5);
14844 if (!SWIG_IsOK(ecode5)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLine" "', expected argument " "5"" of type '" "int""'");
14846 }
14847 arg5 = static_cast< int >(val5);
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 resultobj = SWIG_Py_Void();
14855 return resultobj;
14856 fail:
14857 return NULL;
14858 }
14859
14860
14861 SWIGINTERN PyObject *_wrap_DC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj = 0;
14863 wxDC *arg1 = (wxDC *) 0 ;
14864 wxPoint *arg2 = 0 ;
14865 wxPoint *arg3 = 0 ;
14866 void *argp1 = 0 ;
14867 int res1 = 0 ;
14868 wxPoint temp2 ;
14869 wxPoint temp3 ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 char * kwnames[] = {
14874 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
14875 };
14876
14877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14879 if (!SWIG_IsOK(res1)) {
14880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLinePoint" "', expected argument " "1"" of type '" "wxDC *""'");
14881 }
14882 arg1 = reinterpret_cast< wxDC * >(argp1);
14883 {
14884 arg2 = &temp2;
14885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14886 }
14887 {
14888 arg3 = &temp3;
14889 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14890 }
14891 {
14892 PyThreadState* __tstate = wxPyBeginAllowThreads();
14893 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
14894 wxPyEndAllowThreads(__tstate);
14895 if (PyErr_Occurred()) SWIG_fail;
14896 }
14897 resultobj = SWIG_Py_Void();
14898 return resultobj;
14899 fail:
14900 return NULL;
14901 }
14902
14903
14904 SWIGINTERN PyObject *_wrap_DC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14905 PyObject *resultobj = 0;
14906 wxDC *arg1 = (wxDC *) 0 ;
14907 int arg2 ;
14908 int arg3 ;
14909 void *argp1 = 0 ;
14910 int res1 = 0 ;
14911 int val2 ;
14912 int ecode2 = 0 ;
14913 int val3 ;
14914 int ecode3 = 0 ;
14915 PyObject * obj0 = 0 ;
14916 PyObject * obj1 = 0 ;
14917 PyObject * obj2 = 0 ;
14918 char * kwnames[] = {
14919 (char *) "self",(char *) "x",(char *) "y", NULL
14920 };
14921
14922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14924 if (!SWIG_IsOK(res1)) {
14925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHair" "', expected argument " "1"" of type '" "wxDC *""'");
14926 }
14927 arg1 = reinterpret_cast< wxDC * >(argp1);
14928 ecode2 = SWIG_AsVal_int(obj1, &val2);
14929 if (!SWIG_IsOK(ecode2)) {
14930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CrossHair" "', expected argument " "2"" of type '" "int""'");
14931 }
14932 arg2 = static_cast< int >(val2);
14933 ecode3 = SWIG_AsVal_int(obj2, &val3);
14934 if (!SWIG_IsOK(ecode3)) {
14935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CrossHair" "', expected argument " "3"" of type '" "int""'");
14936 }
14937 arg3 = static_cast< int >(val3);
14938 {
14939 PyThreadState* __tstate = wxPyBeginAllowThreads();
14940 (arg1)->CrossHair(arg2,arg3);
14941 wxPyEndAllowThreads(__tstate);
14942 if (PyErr_Occurred()) SWIG_fail;
14943 }
14944 resultobj = SWIG_Py_Void();
14945 return resultobj;
14946 fail:
14947 return NULL;
14948 }
14949
14950
14951 SWIGINTERN PyObject *_wrap_DC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14952 PyObject *resultobj = 0;
14953 wxDC *arg1 = (wxDC *) 0 ;
14954 wxPoint *arg2 = 0 ;
14955 void *argp1 = 0 ;
14956 int res1 = 0 ;
14957 wxPoint temp2 ;
14958 PyObject * obj0 = 0 ;
14959 PyObject * obj1 = 0 ;
14960 char * kwnames[] = {
14961 (char *) "self",(char *) "pt", NULL
14962 };
14963
14964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
14965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHairPoint" "', expected argument " "1"" of type '" "wxDC *""'");
14968 }
14969 arg1 = reinterpret_cast< wxDC * >(argp1);
14970 {
14971 arg2 = &temp2;
14972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14973 }
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 (arg1)->CrossHair((wxPoint const &)*arg2);
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 resultobj = SWIG_Py_Void();
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_DC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj = 0;
14989 wxDC *arg1 = (wxDC *) 0 ;
14990 int arg2 ;
14991 int arg3 ;
14992 int arg4 ;
14993 int arg5 ;
14994 int arg6 ;
14995 int arg7 ;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 int val2 ;
14999 int ecode2 = 0 ;
15000 int val3 ;
15001 int ecode3 = 0 ;
15002 int val4 ;
15003 int ecode4 = 0 ;
15004 int val5 ;
15005 int ecode5 = 0 ;
15006 int val6 ;
15007 int ecode6 = 0 ;
15008 int val7 ;
15009 int ecode7 = 0 ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 PyObject * obj2 = 0 ;
15013 PyObject * obj3 = 0 ;
15014 PyObject * obj4 = 0 ;
15015 PyObject * obj5 = 0 ;
15016 PyObject * obj6 = 0 ;
15017 char * kwnames[] = {
15018 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
15019 };
15020
15021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArc" "', expected argument " "1"" of type '" "wxDC *""'");
15025 }
15026 arg1 = reinterpret_cast< wxDC * >(argp1);
15027 ecode2 = SWIG_AsVal_int(obj1, &val2);
15028 if (!SWIG_IsOK(ecode2)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawArc" "', expected argument " "2"" of type '" "int""'");
15030 }
15031 arg2 = static_cast< int >(val2);
15032 ecode3 = SWIG_AsVal_int(obj2, &val3);
15033 if (!SWIG_IsOK(ecode3)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawArc" "', expected argument " "3"" of type '" "int""'");
15035 }
15036 arg3 = static_cast< int >(val3);
15037 ecode4 = SWIG_AsVal_int(obj3, &val4);
15038 if (!SWIG_IsOK(ecode4)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawArc" "', expected argument " "4"" of type '" "int""'");
15040 }
15041 arg4 = static_cast< int >(val4);
15042 ecode5 = SWIG_AsVal_int(obj4, &val5);
15043 if (!SWIG_IsOK(ecode5)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawArc" "', expected argument " "5"" of type '" "int""'");
15045 }
15046 arg5 = static_cast< int >(val5);
15047 ecode6 = SWIG_AsVal_int(obj5, &val6);
15048 if (!SWIG_IsOK(ecode6)) {
15049 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawArc" "', expected argument " "6"" of type '" "int""'");
15050 }
15051 arg6 = static_cast< int >(val6);
15052 ecode7 = SWIG_AsVal_int(obj6, &val7);
15053 if (!SWIG_IsOK(ecode7)) {
15054 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawArc" "', expected argument " "7"" of type '" "int""'");
15055 }
15056 arg7 = static_cast< int >(val7);
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 resultobj = SWIG_Py_Void();
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 SWIGINTERN PyObject *_wrap_DC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15071 PyObject *resultobj = 0;
15072 wxDC *arg1 = (wxDC *) 0 ;
15073 wxPoint *arg2 = 0 ;
15074 wxPoint *arg3 = 0 ;
15075 wxPoint *arg4 = 0 ;
15076 void *argp1 = 0 ;
15077 int res1 = 0 ;
15078 wxPoint temp2 ;
15079 wxPoint temp3 ;
15080 wxPoint temp4 ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 PyObject * obj2 = 0 ;
15084 PyObject * obj3 = 0 ;
15085 char * kwnames[] = {
15086 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
15087 };
15088
15089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15091 if (!SWIG_IsOK(res1)) {
15092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArcPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15093 }
15094 arg1 = reinterpret_cast< wxDC * >(argp1);
15095 {
15096 arg2 = &temp2;
15097 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15098 }
15099 {
15100 arg3 = &temp3;
15101 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15102 }
15103 {
15104 arg4 = &temp4;
15105 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
15106 }
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 resultobj = SWIG_Py_Void();
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_DC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj = 0;
15122 wxDC *arg1 = (wxDC *) 0 ;
15123 int arg2 ;
15124 int arg3 ;
15125 int arg4 ;
15126 int arg5 ;
15127 void *argp1 = 0 ;
15128 int res1 = 0 ;
15129 int val2 ;
15130 int ecode2 = 0 ;
15131 int val3 ;
15132 int ecode3 = 0 ;
15133 int val4 ;
15134 int ecode4 = 0 ;
15135 int val5 ;
15136 int ecode5 = 0 ;
15137 PyObject * obj0 = 0 ;
15138 PyObject * obj1 = 0 ;
15139 PyObject * obj2 = 0 ;
15140 PyObject * obj3 = 0 ;
15141 PyObject * obj4 = 0 ;
15142 char * kwnames[] = {
15143 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15144 };
15145
15146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15148 if (!SWIG_IsOK(res1)) {
15149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMark" "', expected argument " "1"" of type '" "wxDC *""'");
15150 }
15151 arg1 = reinterpret_cast< wxDC * >(argp1);
15152 ecode2 = SWIG_AsVal_int(obj1, &val2);
15153 if (!SWIG_IsOK(ecode2)) {
15154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
15155 }
15156 arg2 = static_cast< int >(val2);
15157 ecode3 = SWIG_AsVal_int(obj2, &val3);
15158 if (!SWIG_IsOK(ecode3)) {
15159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
15160 }
15161 arg3 = static_cast< int >(val3);
15162 ecode4 = SWIG_AsVal_int(obj3, &val4);
15163 if (!SWIG_IsOK(ecode4)) {
15164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
15165 }
15166 arg4 = static_cast< int >(val4);
15167 ecode5 = SWIG_AsVal_int(obj4, &val5);
15168 if (!SWIG_IsOK(ecode5)) {
15169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
15170 }
15171 arg5 = static_cast< int >(val5);
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 resultobj = SWIG_Py_Void();
15179 return resultobj;
15180 fail:
15181 return NULL;
15182 }
15183
15184
15185 SWIGINTERN PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15186 PyObject *resultobj = 0;
15187 wxDC *arg1 = (wxDC *) 0 ;
15188 wxRect *arg2 = 0 ;
15189 void *argp1 = 0 ;
15190 int res1 = 0 ;
15191 wxRect temp2 ;
15192 PyObject * obj0 = 0 ;
15193 PyObject * obj1 = 0 ;
15194 char * kwnames[] = {
15195 (char *) "self",(char *) "rect", NULL
15196 };
15197
15198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
15199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15200 if (!SWIG_IsOK(res1)) {
15201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxDC *""'");
15202 }
15203 arg1 = reinterpret_cast< wxDC * >(argp1);
15204 {
15205 arg2 = &temp2;
15206 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15207 }
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 (arg1)->DrawCheckMark((wxRect const &)*arg2);
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 resultobj = SWIG_Py_Void();
15215 return resultobj;
15216 fail:
15217 return NULL;
15218 }
15219
15220
15221 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = 0;
15223 wxDC *arg1 = (wxDC *) 0 ;
15224 int arg2 ;
15225 int arg3 ;
15226 int arg4 ;
15227 int arg5 ;
15228 double arg6 ;
15229 double arg7 ;
15230 void *argp1 = 0 ;
15231 int res1 = 0 ;
15232 int val2 ;
15233 int ecode2 = 0 ;
15234 int val3 ;
15235 int ecode3 = 0 ;
15236 int val4 ;
15237 int ecode4 = 0 ;
15238 int val5 ;
15239 int ecode5 = 0 ;
15240 double val6 ;
15241 int ecode6 = 0 ;
15242 double val7 ;
15243 int ecode7 = 0 ;
15244 PyObject * obj0 = 0 ;
15245 PyObject * obj1 = 0 ;
15246 PyObject * obj2 = 0 ;
15247 PyObject * obj3 = 0 ;
15248 PyObject * obj4 = 0 ;
15249 PyObject * obj5 = 0 ;
15250 PyObject * obj6 = 0 ;
15251 char * kwnames[] = {
15252 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
15253 };
15254
15255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15257 if (!SWIG_IsOK(res1)) {
15258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxDC *""'");
15259 }
15260 arg1 = reinterpret_cast< wxDC * >(argp1);
15261 ecode2 = SWIG_AsVal_int(obj1, &val2);
15262 if (!SWIG_IsOK(ecode2)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
15264 }
15265 arg2 = static_cast< int >(val2);
15266 ecode3 = SWIG_AsVal_int(obj2, &val3);
15267 if (!SWIG_IsOK(ecode3)) {
15268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
15269 }
15270 arg3 = static_cast< int >(val3);
15271 ecode4 = SWIG_AsVal_int(obj3, &val4);
15272 if (!SWIG_IsOK(ecode4)) {
15273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
15274 }
15275 arg4 = static_cast< int >(val4);
15276 ecode5 = SWIG_AsVal_int(obj4, &val5);
15277 if (!SWIG_IsOK(ecode5)) {
15278 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
15279 }
15280 arg5 = static_cast< int >(val5);
15281 ecode6 = SWIG_AsVal_double(obj5, &val6);
15282 if (!SWIG_IsOK(ecode6)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
15284 }
15285 arg6 = static_cast< double >(val6);
15286 ecode7 = SWIG_AsVal_double(obj6, &val7);
15287 if (!SWIG_IsOK(ecode7)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
15289 }
15290 arg7 = static_cast< double >(val7);
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 resultobj = SWIG_Py_Void();
15298 return resultobj;
15299 fail:
15300 return NULL;
15301 }
15302
15303
15304 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15305 PyObject *resultobj = 0;
15306 wxDC *arg1 = (wxDC *) 0 ;
15307 wxPoint *arg2 = 0 ;
15308 wxSize *arg3 = 0 ;
15309 double arg4 ;
15310 double arg5 ;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 wxPoint temp2 ;
15314 wxSize temp3 ;
15315 double val4 ;
15316 int ecode4 = 0 ;
15317 double val5 ;
15318 int ecode5 = 0 ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 PyObject * obj2 = 0 ;
15322 PyObject * obj3 = 0 ;
15323 PyObject * obj4 = 0 ;
15324 char * kwnames[] = {
15325 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
15326 };
15327
15328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15332 }
15333 arg1 = reinterpret_cast< wxDC * >(argp1);
15334 {
15335 arg2 = &temp2;
15336 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15337 }
15338 {
15339 arg3 = &temp3;
15340 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15341 }
15342 ecode4 = SWIG_AsVal_double(obj3, &val4);
15343 if (!SWIG_IsOK(ecode4)) {
15344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
15345 }
15346 arg4 = static_cast< double >(val4);
15347 ecode5 = SWIG_AsVal_double(obj4, &val5);
15348 if (!SWIG_IsOK(ecode5)) {
15349 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
15350 }
15351 arg5 = static_cast< double >(val5);
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 resultobj = SWIG_Py_Void();
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 SWIGINTERN PyObject *_wrap_DC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15366 PyObject *resultobj = 0;
15367 wxDC *arg1 = (wxDC *) 0 ;
15368 int arg2 ;
15369 int arg3 ;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 int val2 ;
15373 int ecode2 = 0 ;
15374 int val3 ;
15375 int ecode3 = 0 ;
15376 PyObject * obj0 = 0 ;
15377 PyObject * obj1 = 0 ;
15378 PyObject * obj2 = 0 ;
15379 char * kwnames[] = {
15380 (char *) "self",(char *) "x",(char *) "y", NULL
15381 };
15382
15383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15385 if (!SWIG_IsOK(res1)) {
15386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15387 }
15388 arg1 = reinterpret_cast< wxDC * >(argp1);
15389 ecode2 = SWIG_AsVal_int(obj1, &val2);
15390 if (!SWIG_IsOK(ecode2)) {
15391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
15392 }
15393 arg2 = static_cast< int >(val2);
15394 ecode3 = SWIG_AsVal_int(obj2, &val3);
15395 if (!SWIG_IsOK(ecode3)) {
15396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
15397 }
15398 arg3 = static_cast< int >(val3);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->DrawPoint(arg2,arg3);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_Py_Void();
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_DC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj = 0;
15414 wxDC *arg1 = (wxDC *) 0 ;
15415 wxPoint *arg2 = 0 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 wxPoint temp2 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 char * kwnames[] = {
15422 (char *) "self",(char *) "pt", NULL
15423 };
15424
15425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPointPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15429 }
15430 arg1 = reinterpret_cast< wxDC * >(argp1);
15431 {
15432 arg2 = &temp2;
15433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15434 }
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 (arg1)->DrawPoint((wxPoint const &)*arg2);
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_Py_Void();
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_DC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj = 0;
15450 wxDC *arg1 = (wxDC *) 0 ;
15451 int arg2 ;
15452 int arg3 ;
15453 int arg4 ;
15454 int arg5 ;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 int val2 ;
15458 int ecode2 = 0 ;
15459 int val3 ;
15460 int ecode3 = 0 ;
15461 int val4 ;
15462 int ecode4 = 0 ;
15463 int val5 ;
15464 int ecode5 = 0 ;
15465 PyObject * obj0 = 0 ;
15466 PyObject * obj1 = 0 ;
15467 PyObject * obj2 = 0 ;
15468 PyObject * obj3 = 0 ;
15469 PyObject * obj4 = 0 ;
15470 char * kwnames[] = {
15471 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15472 };
15473
15474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15476 if (!SWIG_IsOK(res1)) {
15477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
15478 }
15479 arg1 = reinterpret_cast< wxDC * >(argp1);
15480 ecode2 = SWIG_AsVal_int(obj1, &val2);
15481 if (!SWIG_IsOK(ecode2)) {
15482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
15483 }
15484 arg2 = static_cast< int >(val2);
15485 ecode3 = SWIG_AsVal_int(obj2, &val3);
15486 if (!SWIG_IsOK(ecode3)) {
15487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
15488 }
15489 arg3 = static_cast< int >(val3);
15490 ecode4 = SWIG_AsVal_int(obj3, &val4);
15491 if (!SWIG_IsOK(ecode4)) {
15492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
15493 }
15494 arg4 = static_cast< int >(val4);
15495 ecode5 = SWIG_AsVal_int(obj4, &val5);
15496 if (!SWIG_IsOK(ecode5)) {
15497 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
15498 }
15499 arg5 = static_cast< int >(val5);
15500 {
15501 PyThreadState* __tstate = wxPyBeginAllowThreads();
15502 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 resultobj = SWIG_Py_Void();
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 SWIGINTERN PyObject *_wrap_DC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15514 PyObject *resultobj = 0;
15515 wxDC *arg1 = (wxDC *) 0 ;
15516 wxRect *arg2 = 0 ;
15517 void *argp1 = 0 ;
15518 int res1 = 0 ;
15519 wxRect temp2 ;
15520 PyObject * obj0 = 0 ;
15521 PyObject * obj1 = 0 ;
15522 char * kwnames[] = {
15523 (char *) "self",(char *) "rect", NULL
15524 };
15525
15526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
15527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15528 if (!SWIG_IsOK(res1)) {
15529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
15530 }
15531 arg1 = reinterpret_cast< wxDC * >(argp1);
15532 {
15533 arg2 = &temp2;
15534 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15535 }
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 (arg1)->DrawRectangle((wxRect const &)*arg2);
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = SWIG_Py_Void();
15543 return resultobj;
15544 fail:
15545 return NULL;
15546 }
15547
15548
15549 SWIGINTERN PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15550 PyObject *resultobj = 0;
15551 wxDC *arg1 = (wxDC *) 0 ;
15552 wxPoint *arg2 = 0 ;
15553 wxSize *arg3 = 0 ;
15554 void *argp1 = 0 ;
15555 int res1 = 0 ;
15556 wxPoint temp2 ;
15557 wxSize temp3 ;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 PyObject * obj2 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "pt",(char *) "sz", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15569 }
15570 arg1 = reinterpret_cast< wxDC * >(argp1);
15571 {
15572 arg2 = &temp2;
15573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15574 }
15575 {
15576 arg3 = &temp3;
15577 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15578 }
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_Py_Void();
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15593 PyObject *resultobj = 0;
15594 wxDC *arg1 = (wxDC *) 0 ;
15595 int arg2 ;
15596 int arg3 ;
15597 int arg4 ;
15598 int arg5 ;
15599 double arg6 ;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 int val2 ;
15603 int ecode2 = 0 ;
15604 int val3 ;
15605 int ecode3 = 0 ;
15606 int val4 ;
15607 int ecode4 = 0 ;
15608 int val5 ;
15609 int ecode5 = 0 ;
15610 double val6 ;
15611 int ecode6 = 0 ;
15612 PyObject * obj0 = 0 ;
15613 PyObject * obj1 = 0 ;
15614 PyObject * obj2 = 0 ;
15615 PyObject * obj3 = 0 ;
15616 PyObject * obj4 = 0 ;
15617 PyObject * obj5 = 0 ;
15618 char * kwnames[] = {
15619 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
15620 };
15621
15622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
15626 }
15627 arg1 = reinterpret_cast< wxDC * >(argp1);
15628 ecode2 = SWIG_AsVal_int(obj1, &val2);
15629 if (!SWIG_IsOK(ecode2)) {
15630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
15631 }
15632 arg2 = static_cast< int >(val2);
15633 ecode3 = SWIG_AsVal_int(obj2, &val3);
15634 if (!SWIG_IsOK(ecode3)) {
15635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
15636 }
15637 arg3 = static_cast< int >(val3);
15638 ecode4 = SWIG_AsVal_int(obj3, &val4);
15639 if (!SWIG_IsOK(ecode4)) {
15640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
15641 }
15642 arg4 = static_cast< int >(val4);
15643 ecode5 = SWIG_AsVal_int(obj4, &val5);
15644 if (!SWIG_IsOK(ecode5)) {
15645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
15646 }
15647 arg5 = static_cast< int >(val5);
15648 ecode6 = SWIG_AsVal_double(obj5, &val6);
15649 if (!SWIG_IsOK(ecode6)) {
15650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
15651 }
15652 arg6 = static_cast< double >(val6);
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 resultobj = SWIG_Py_Void();
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15667 PyObject *resultobj = 0;
15668 wxDC *arg1 = (wxDC *) 0 ;
15669 wxRect *arg2 = 0 ;
15670 double arg3 ;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 wxRect temp2 ;
15674 double val3 ;
15675 int ecode3 = 0 ;
15676 PyObject * obj0 = 0 ;
15677 PyObject * obj1 = 0 ;
15678 PyObject * obj2 = 0 ;
15679 char * kwnames[] = {
15680 (char *) "self",(char *) "r",(char *) "radius", NULL
15681 };
15682
15683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15685 if (!SWIG_IsOK(res1)) {
15686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
15687 }
15688 arg1 = reinterpret_cast< wxDC * >(argp1);
15689 {
15690 arg2 = &temp2;
15691 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15692 }
15693 ecode3 = SWIG_AsVal_double(obj2, &val3);
15694 if (!SWIG_IsOK(ecode3)) {
15695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
15696 }
15697 arg3 = static_cast< double >(val3);
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 resultobj = SWIG_Py_Void();
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj = 0;
15713 wxDC *arg1 = (wxDC *) 0 ;
15714 wxPoint *arg2 = 0 ;
15715 wxSize *arg3 = 0 ;
15716 double arg4 ;
15717 void *argp1 = 0 ;
15718 int res1 = 0 ;
15719 wxPoint temp2 ;
15720 wxSize temp3 ;
15721 double val4 ;
15722 int ecode4 = 0 ;
15723 PyObject * obj0 = 0 ;
15724 PyObject * obj1 = 0 ;
15725 PyObject * obj2 = 0 ;
15726 PyObject * obj3 = 0 ;
15727 char * kwnames[] = {
15728 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
15729 };
15730
15731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15733 if (!SWIG_IsOK(res1)) {
15734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15735 }
15736 arg1 = reinterpret_cast< wxDC * >(argp1);
15737 {
15738 arg2 = &temp2;
15739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15740 }
15741 {
15742 arg3 = &temp3;
15743 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15744 }
15745 ecode4 = SWIG_AsVal_double(obj3, &val4);
15746 if (!SWIG_IsOK(ecode4)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
15748 }
15749 arg4 = static_cast< double >(val4);
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 resultobj = SWIG_Py_Void();
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_DC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15764 PyObject *resultobj = 0;
15765 wxDC *arg1 = (wxDC *) 0 ;
15766 int arg2 ;
15767 int arg3 ;
15768 int arg4 ;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 int val2 ;
15772 int ecode2 = 0 ;
15773 int val3 ;
15774 int ecode3 = 0 ;
15775 int val4 ;
15776 int ecode4 = 0 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 PyObject * obj2 = 0 ;
15780 PyObject * obj3 = 0 ;
15781 char * kwnames[] = {
15782 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
15783 };
15784
15785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCircle" "', expected argument " "1"" of type '" "wxDC *""'");
15789 }
15790 arg1 = reinterpret_cast< wxDC * >(argp1);
15791 ecode2 = SWIG_AsVal_int(obj1, &val2);
15792 if (!SWIG_IsOK(ecode2)) {
15793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
15794 }
15795 arg2 = static_cast< int >(val2);
15796 ecode3 = SWIG_AsVal_int(obj2, &val3);
15797 if (!SWIG_IsOK(ecode3)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
15799 }
15800 arg3 = static_cast< int >(val3);
15801 ecode4 = SWIG_AsVal_int(obj3, &val4);
15802 if (!SWIG_IsOK(ecode4)) {
15803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
15804 }
15805 arg4 = static_cast< int >(val4);
15806 {
15807 PyThreadState* __tstate = wxPyBeginAllowThreads();
15808 (arg1)->DrawCircle(arg2,arg3,arg4);
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 resultobj = SWIG_Py_Void();
15813 return resultobj;
15814 fail:
15815 return NULL;
15816 }
15817
15818
15819 SWIGINTERN PyObject *_wrap_DC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15820 PyObject *resultobj = 0;
15821 wxDC *arg1 = (wxDC *) 0 ;
15822 wxPoint *arg2 = 0 ;
15823 int arg3 ;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 wxPoint temp2 ;
15827 int val3 ;
15828 int ecode3 = 0 ;
15829 PyObject * obj0 = 0 ;
15830 PyObject * obj1 = 0 ;
15831 PyObject * obj2 = 0 ;
15832 char * kwnames[] = {
15833 (char *) "self",(char *) "pt",(char *) "radius", NULL
15834 };
15835
15836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15838 if (!SWIG_IsOK(res1)) {
15839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxDC *""'");
15840 }
15841 arg1 = reinterpret_cast< wxDC * >(argp1);
15842 {
15843 arg2 = &temp2;
15844 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15845 }
15846 ecode3 = SWIG_AsVal_int(obj2, &val3);
15847 if (!SWIG_IsOK(ecode3)) {
15848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
15849 }
15850 arg3 = static_cast< int >(val3);
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_Py_Void();
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_DC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 wxDC *arg1 = (wxDC *) 0 ;
15867 int arg2 ;
15868 int arg3 ;
15869 int arg4 ;
15870 int arg5 ;
15871 void *argp1 = 0 ;
15872 int res1 = 0 ;
15873 int val2 ;
15874 int ecode2 = 0 ;
15875 int val3 ;
15876 int ecode3 = 0 ;
15877 int val4 ;
15878 int ecode4 = 0 ;
15879 int val5 ;
15880 int ecode5 = 0 ;
15881 PyObject * obj0 = 0 ;
15882 PyObject * obj1 = 0 ;
15883 PyObject * obj2 = 0 ;
15884 PyObject * obj3 = 0 ;
15885 PyObject * obj4 = 0 ;
15886 char * kwnames[] = {
15887 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15888 };
15889
15890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15892 if (!SWIG_IsOK(res1)) {
15893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipse" "', expected argument " "1"" of type '" "wxDC *""'");
15894 }
15895 arg1 = reinterpret_cast< wxDC * >(argp1);
15896 ecode2 = SWIG_AsVal_int(obj1, &val2);
15897 if (!SWIG_IsOK(ecode2)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
15899 }
15900 arg2 = static_cast< int >(val2);
15901 ecode3 = SWIG_AsVal_int(obj2, &val3);
15902 if (!SWIG_IsOK(ecode3)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
15904 }
15905 arg3 = static_cast< int >(val3);
15906 ecode4 = SWIG_AsVal_int(obj3, &val4);
15907 if (!SWIG_IsOK(ecode4)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
15909 }
15910 arg4 = static_cast< int >(val4);
15911 ecode5 = SWIG_AsVal_int(obj4, &val5);
15912 if (!SWIG_IsOK(ecode5)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
15914 }
15915 arg5 = static_cast< int >(val5);
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 resultobj = SWIG_Py_Void();
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 SWIGINTERN PyObject *_wrap_DC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj = 0;
15931 wxDC *arg1 = (wxDC *) 0 ;
15932 wxRect *arg2 = 0 ;
15933 void *argp1 = 0 ;
15934 int res1 = 0 ;
15935 wxRect temp2 ;
15936 PyObject * obj0 = 0 ;
15937 PyObject * obj1 = 0 ;
15938 char * kwnames[] = {
15939 (char *) "self",(char *) "rect", NULL
15940 };
15941
15942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
15943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxDC *""'");
15946 }
15947 arg1 = reinterpret_cast< wxDC * >(argp1);
15948 {
15949 arg2 = &temp2;
15950 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15951 }
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 (arg1)->DrawEllipse((wxRect const &)*arg2);
15955 wxPyEndAllowThreads(__tstate);
15956 if (PyErr_Occurred()) SWIG_fail;
15957 }
15958 resultobj = SWIG_Py_Void();
15959 return resultobj;
15960 fail:
15961 return NULL;
15962 }
15963
15964
15965 SWIGINTERN PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15966 PyObject *resultobj = 0;
15967 wxDC *arg1 = (wxDC *) 0 ;
15968 wxPoint *arg2 = 0 ;
15969 wxSize *arg3 = 0 ;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 wxPoint temp2 ;
15973 wxSize temp3 ;
15974 PyObject * obj0 = 0 ;
15975 PyObject * obj1 = 0 ;
15976 PyObject * obj2 = 0 ;
15977 char * kwnames[] = {
15978 (char *) "self",(char *) "pt",(char *) "sz", NULL
15979 };
15980
15981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15983 if (!SWIG_IsOK(res1)) {
15984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15985 }
15986 arg1 = reinterpret_cast< wxDC * >(argp1);
15987 {
15988 arg2 = &temp2;
15989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15990 }
15991 {
15992 arg3 = &temp3;
15993 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15994 }
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
15998 wxPyEndAllowThreads(__tstate);
15999 if (PyErr_Occurred()) SWIG_fail;
16000 }
16001 resultobj = SWIG_Py_Void();
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 SWIGINTERN PyObject *_wrap_DC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16009 PyObject *resultobj = 0;
16010 wxDC *arg1 = (wxDC *) 0 ;
16011 wxIcon *arg2 = 0 ;
16012 int arg3 ;
16013 int arg4 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 void *argp2 = 0 ;
16017 int res2 = 0 ;
16018 int val3 ;
16019 int ecode3 = 0 ;
16020 int val4 ;
16021 int ecode4 = 0 ;
16022 PyObject * obj0 = 0 ;
16023 PyObject * obj1 = 0 ;
16024 PyObject * obj2 = 0 ;
16025 PyObject * obj3 = 0 ;
16026 char * kwnames[] = {
16027 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
16028 };
16029
16030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIcon" "', expected argument " "1"" of type '" "wxDC *""'");
16034 }
16035 arg1 = reinterpret_cast< wxDC * >(argp1);
16036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
16037 if (!SWIG_IsOK(res2)) {
16038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
16039 }
16040 if (!argp2) {
16041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
16042 }
16043 arg2 = reinterpret_cast< wxIcon * >(argp2);
16044 ecode3 = SWIG_AsVal_int(obj2, &val3);
16045 if (!SWIG_IsOK(ecode3)) {
16046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
16047 }
16048 arg3 = static_cast< int >(val3);
16049 ecode4 = SWIG_AsVal_int(obj3, &val4);
16050 if (!SWIG_IsOK(ecode4)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
16052 }
16053 arg4 = static_cast< int >(val4);
16054 {
16055 PyThreadState* __tstate = wxPyBeginAllowThreads();
16056 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
16057 wxPyEndAllowThreads(__tstate);
16058 if (PyErr_Occurred()) SWIG_fail;
16059 }
16060 resultobj = SWIG_Py_Void();
16061 return resultobj;
16062 fail:
16063 return NULL;
16064 }
16065
16066
16067 SWIGINTERN PyObject *_wrap_DC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16068 PyObject *resultobj = 0;
16069 wxDC *arg1 = (wxDC *) 0 ;
16070 wxIcon *arg2 = 0 ;
16071 wxPoint *arg3 = 0 ;
16072 void *argp1 = 0 ;
16073 int res1 = 0 ;
16074 void *argp2 = 0 ;
16075 int res2 = 0 ;
16076 wxPoint temp3 ;
16077 PyObject * obj0 = 0 ;
16078 PyObject * obj1 = 0 ;
16079 PyObject * obj2 = 0 ;
16080 char * kwnames[] = {
16081 (char *) "self",(char *) "icon",(char *) "pt", NULL
16082 };
16083
16084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16086 if (!SWIG_IsOK(res1)) {
16087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIconPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16088 }
16089 arg1 = reinterpret_cast< wxDC * >(argp1);
16090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
16091 if (!SWIG_IsOK(res2)) {
16092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
16093 }
16094 if (!argp2) {
16095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
16096 }
16097 arg2 = reinterpret_cast< wxIcon * >(argp2);
16098 {
16099 arg3 = &temp3;
16100 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16101 }
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 resultobj = SWIG_Py_Void();
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 SWIGINTERN PyObject *_wrap_DC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj = 0;
16117 wxDC *arg1 = (wxDC *) 0 ;
16118 wxBitmap *arg2 = 0 ;
16119 int arg3 ;
16120 int arg4 ;
16121 bool arg5 = (bool) false ;
16122 void *argp1 = 0 ;
16123 int res1 = 0 ;
16124 void *argp2 = 0 ;
16125 int res2 = 0 ;
16126 int val3 ;
16127 int ecode3 = 0 ;
16128 int val4 ;
16129 int ecode4 = 0 ;
16130 bool val5 ;
16131 int ecode5 = 0 ;
16132 PyObject * obj0 = 0 ;
16133 PyObject * obj1 = 0 ;
16134 PyObject * obj2 = 0 ;
16135 PyObject * obj3 = 0 ;
16136 PyObject * obj4 = 0 ;
16137 char * kwnames[] = {
16138 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
16139 };
16140
16141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16143 if (!SWIG_IsOK(res1)) {
16144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmap" "', expected argument " "1"" of type '" "wxDC *""'");
16145 }
16146 arg1 = reinterpret_cast< wxDC * >(argp1);
16147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
16148 if (!SWIG_IsOK(res2)) {
16149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16150 }
16151 if (!argp2) {
16152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16153 }
16154 arg2 = reinterpret_cast< wxBitmap * >(argp2);
16155 ecode3 = SWIG_AsVal_int(obj2, &val3);
16156 if (!SWIG_IsOK(ecode3)) {
16157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
16158 }
16159 arg3 = static_cast< int >(val3);
16160 ecode4 = SWIG_AsVal_int(obj3, &val4);
16161 if (!SWIG_IsOK(ecode4)) {
16162 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
16163 }
16164 arg4 = static_cast< int >(val4);
16165 if (obj4) {
16166 ecode5 = SWIG_AsVal_bool(obj4, &val5);
16167 if (!SWIG_IsOK(ecode5)) {
16168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
16169 }
16170 arg5 = static_cast< bool >(val5);
16171 }
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 resultobj = SWIG_Py_Void();
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 SWIGINTERN PyObject *_wrap_DC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj = 0;
16187 wxDC *arg1 = (wxDC *) 0 ;
16188 wxBitmap *arg2 = 0 ;
16189 wxPoint *arg3 = 0 ;
16190 bool arg4 = (bool) false ;
16191 void *argp1 = 0 ;
16192 int res1 = 0 ;
16193 void *argp2 = 0 ;
16194 int res2 = 0 ;
16195 wxPoint temp3 ;
16196 bool val4 ;
16197 int ecode4 = 0 ;
16198 PyObject * obj0 = 0 ;
16199 PyObject * obj1 = 0 ;
16200 PyObject * obj2 = 0 ;
16201 PyObject * obj3 = 0 ;
16202 char * kwnames[] = {
16203 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
16204 };
16205
16206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16208 if (!SWIG_IsOK(res1)) {
16209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16210 }
16211 arg1 = reinterpret_cast< wxDC * >(argp1);
16212 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
16213 if (!SWIG_IsOK(res2)) {
16214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16215 }
16216 if (!argp2) {
16217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16218 }
16219 arg2 = reinterpret_cast< wxBitmap * >(argp2);
16220 {
16221 arg3 = &temp3;
16222 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16223 }
16224 if (obj3) {
16225 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16226 if (!SWIG_IsOK(ecode4)) {
16227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
16228 }
16229 arg4 = static_cast< bool >(val4);
16230 }
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
16234 wxPyEndAllowThreads(__tstate);
16235 if (PyErr_Occurred()) SWIG_fail;
16236 }
16237 resultobj = SWIG_Py_Void();
16238 return resultobj;
16239 fail:
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_DC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxDC *arg1 = (wxDC *) 0 ;
16247 wxString *arg2 = 0 ;
16248 int arg3 ;
16249 int arg4 ;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 bool temp2 = false ;
16253 int val3 ;
16254 int ecode3 = 0 ;
16255 int val4 ;
16256 int ecode4 = 0 ;
16257 PyObject * obj0 = 0 ;
16258 PyObject * obj1 = 0 ;
16259 PyObject * obj2 = 0 ;
16260 PyObject * obj3 = 0 ;
16261 char * kwnames[] = {
16262 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
16263 };
16264
16265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16267 if (!SWIG_IsOK(res1)) {
16268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawText" "', expected argument " "1"" of type '" "wxDC *""'");
16269 }
16270 arg1 = reinterpret_cast< wxDC * >(argp1);
16271 {
16272 arg2 = wxString_in_helper(obj1);
16273 if (arg2 == NULL) SWIG_fail;
16274 temp2 = true;
16275 }
16276 ecode3 = SWIG_AsVal_int(obj2, &val3);
16277 if (!SWIG_IsOK(ecode3)) {
16278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawText" "', expected argument " "3"" of type '" "int""'");
16279 }
16280 arg3 = static_cast< int >(val3);
16281 ecode4 = SWIG_AsVal_int(obj3, &val4);
16282 if (!SWIG_IsOK(ecode4)) {
16283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawText" "', expected argument " "4"" of type '" "int""'");
16284 }
16285 arg4 = static_cast< int >(val4);
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 resultobj = SWIG_Py_Void();
16293 {
16294 if (temp2)
16295 delete arg2;
16296 }
16297 return resultobj;
16298 fail:
16299 {
16300 if (temp2)
16301 delete arg2;
16302 }
16303 return NULL;
16304 }
16305
16306
16307 SWIGINTERN PyObject *_wrap_DC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16308 PyObject *resultobj = 0;
16309 wxDC *arg1 = (wxDC *) 0 ;
16310 wxString *arg2 = 0 ;
16311 wxPoint *arg3 = 0 ;
16312 void *argp1 = 0 ;
16313 int res1 = 0 ;
16314 bool temp2 = false ;
16315 wxPoint temp3 ;
16316 PyObject * obj0 = 0 ;
16317 PyObject * obj1 = 0 ;
16318 PyObject * obj2 = 0 ;
16319 char * kwnames[] = {
16320 (char *) "self",(char *) "text",(char *) "pt", NULL
16321 };
16322
16323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16325 if (!SWIG_IsOK(res1)) {
16326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16327 }
16328 arg1 = reinterpret_cast< wxDC * >(argp1);
16329 {
16330 arg2 = wxString_in_helper(obj1);
16331 if (arg2 == NULL) SWIG_fail;
16332 temp2 = true;
16333 }
16334 {
16335 arg3 = &temp3;
16336 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16337 }
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_Py_Void();
16345 {
16346 if (temp2)
16347 delete arg2;
16348 }
16349 return resultobj;
16350 fail:
16351 {
16352 if (temp2)
16353 delete arg2;
16354 }
16355 return NULL;
16356 }
16357
16358
16359 SWIGINTERN PyObject *_wrap_DC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj = 0;
16361 wxDC *arg1 = (wxDC *) 0 ;
16362 wxString *arg2 = 0 ;
16363 int arg3 ;
16364 int arg4 ;
16365 double arg5 ;
16366 void *argp1 = 0 ;
16367 int res1 = 0 ;
16368 bool temp2 = false ;
16369 int val3 ;
16370 int ecode3 = 0 ;
16371 int val4 ;
16372 int ecode4 = 0 ;
16373 double val5 ;
16374 int ecode5 = 0 ;
16375 PyObject * obj0 = 0 ;
16376 PyObject * obj1 = 0 ;
16377 PyObject * obj2 = 0 ;
16378 PyObject * obj3 = 0 ;
16379 PyObject * obj4 = 0 ;
16380 char * kwnames[] = {
16381 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
16382 };
16383
16384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16386 if (!SWIG_IsOK(res1)) {
16387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedText" "', expected argument " "1"" of type '" "wxDC *""'");
16388 }
16389 arg1 = reinterpret_cast< wxDC * >(argp1);
16390 {
16391 arg2 = wxString_in_helper(obj1);
16392 if (arg2 == NULL) SWIG_fail;
16393 temp2 = true;
16394 }
16395 ecode3 = SWIG_AsVal_int(obj2, &val3);
16396 if (!SWIG_IsOK(ecode3)) {
16397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
16398 }
16399 arg3 = static_cast< int >(val3);
16400 ecode4 = SWIG_AsVal_int(obj3, &val4);
16401 if (!SWIG_IsOK(ecode4)) {
16402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
16403 }
16404 arg4 = static_cast< int >(val4);
16405 ecode5 = SWIG_AsVal_double(obj4, &val5);
16406 if (!SWIG_IsOK(ecode5)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
16408 }
16409 arg5 = static_cast< double >(val5);
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 resultobj = SWIG_Py_Void();
16417 {
16418 if (temp2)
16419 delete arg2;
16420 }
16421 return resultobj;
16422 fail:
16423 {
16424 if (temp2)
16425 delete arg2;
16426 }
16427 return NULL;
16428 }
16429
16430
16431 SWIGINTERN PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16432 PyObject *resultobj = 0;
16433 wxDC *arg1 = (wxDC *) 0 ;
16434 wxString *arg2 = 0 ;
16435 wxPoint *arg3 = 0 ;
16436 double arg4 ;
16437 void *argp1 = 0 ;
16438 int res1 = 0 ;
16439 bool temp2 = false ;
16440 wxPoint temp3 ;
16441 double val4 ;
16442 int ecode4 = 0 ;
16443 PyObject * obj0 = 0 ;
16444 PyObject * obj1 = 0 ;
16445 PyObject * obj2 = 0 ;
16446 PyObject * obj3 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16455 }
16456 arg1 = reinterpret_cast< wxDC * >(argp1);
16457 {
16458 arg2 = wxString_in_helper(obj1);
16459 if (arg2 == NULL) SWIG_fail;
16460 temp2 = true;
16461 }
16462 {
16463 arg3 = &temp3;
16464 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16465 }
16466 ecode4 = SWIG_AsVal_double(obj3, &val4);
16467 if (!SWIG_IsOK(ecode4)) {
16468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
16469 }
16470 arg4 = static_cast< double >(val4);
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 resultobj = SWIG_Py_Void();
16478 {
16479 if (temp2)
16480 delete arg2;
16481 }
16482 return resultobj;
16483 fail:
16484 {
16485 if (temp2)
16486 delete arg2;
16487 }
16488 return NULL;
16489 }
16490
16491
16492 SWIGINTERN PyObject *_wrap_DC_Blit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj = 0;
16494 wxDC *arg1 = (wxDC *) 0 ;
16495 int arg2 ;
16496 int arg3 ;
16497 int arg4 ;
16498 int arg5 ;
16499 wxDC *arg6 = (wxDC *) 0 ;
16500 int arg7 ;
16501 int arg8 ;
16502 int arg9 = (int) wxCOPY ;
16503 bool arg10 = (bool) false ;
16504 int arg11 = (int) -1 ;
16505 int arg12 = (int) -1 ;
16506 bool result;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 int val2 ;
16510 int ecode2 = 0 ;
16511 int val3 ;
16512 int ecode3 = 0 ;
16513 int val4 ;
16514 int ecode4 = 0 ;
16515 int val5 ;
16516 int ecode5 = 0 ;
16517 void *argp6 = 0 ;
16518 int res6 = 0 ;
16519 int val7 ;
16520 int ecode7 = 0 ;
16521 int val8 ;
16522 int ecode8 = 0 ;
16523 int val9 ;
16524 int ecode9 = 0 ;
16525 bool val10 ;
16526 int ecode10 = 0 ;
16527 int val11 ;
16528 int ecode11 = 0 ;
16529 int val12 ;
16530 int ecode12 = 0 ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 PyObject * obj2 = 0 ;
16534 PyObject * obj3 = 0 ;
16535 PyObject * obj4 = 0 ;
16536 PyObject * obj5 = 0 ;
16537 PyObject * obj6 = 0 ;
16538 PyObject * obj7 = 0 ;
16539 PyObject * obj8 = 0 ;
16540 PyObject * obj9 = 0 ;
16541 PyObject * obj10 = 0 ;
16542 PyObject * obj11 = 0 ;
16543 char * kwnames[] = {
16544 (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
16545 };
16546
16547 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;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Blit" "', expected argument " "1"" of type '" "wxDC *""'");
16551 }
16552 arg1 = reinterpret_cast< wxDC * >(argp1);
16553 ecode2 = SWIG_AsVal_int(obj1, &val2);
16554 if (!SWIG_IsOK(ecode2)) {
16555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_Blit" "', expected argument " "2"" of type '" "int""'");
16556 }
16557 arg2 = static_cast< int >(val2);
16558 ecode3 = SWIG_AsVal_int(obj2, &val3);
16559 if (!SWIG_IsOK(ecode3)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_Blit" "', expected argument " "3"" of type '" "int""'");
16561 }
16562 arg3 = static_cast< int >(val3);
16563 ecode4 = SWIG_AsVal_int(obj3, &val4);
16564 if (!SWIG_IsOK(ecode4)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_Blit" "', expected argument " "4"" of type '" "int""'");
16566 }
16567 arg4 = static_cast< int >(val4);
16568 ecode5 = SWIG_AsVal_int(obj4, &val5);
16569 if (!SWIG_IsOK(ecode5)) {
16570 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_Blit" "', expected argument " "5"" of type '" "int""'");
16571 }
16572 arg5 = static_cast< int >(val5);
16573 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );
16574 if (!SWIG_IsOK(res6)) {
16575 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_Blit" "', expected argument " "6"" of type '" "wxDC *""'");
16576 }
16577 arg6 = reinterpret_cast< wxDC * >(argp6);
16578 ecode7 = SWIG_AsVal_int(obj6, &val7);
16579 if (!SWIG_IsOK(ecode7)) {
16580 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_Blit" "', expected argument " "7"" of type '" "int""'");
16581 }
16582 arg7 = static_cast< int >(val7);
16583 ecode8 = SWIG_AsVal_int(obj7, &val8);
16584 if (!SWIG_IsOK(ecode8)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DC_Blit" "', expected argument " "8"" of type '" "int""'");
16586 }
16587 arg8 = static_cast< int >(val8);
16588 if (obj8) {
16589 ecode9 = SWIG_AsVal_int(obj8, &val9);
16590 if (!SWIG_IsOK(ecode9)) {
16591 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DC_Blit" "', expected argument " "9"" of type '" "int""'");
16592 }
16593 arg9 = static_cast< int >(val9);
16594 }
16595 if (obj9) {
16596 ecode10 = SWIG_AsVal_bool(obj9, &val10);
16597 if (!SWIG_IsOK(ecode10)) {
16598 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DC_Blit" "', expected argument " "10"" of type '" "bool""'");
16599 }
16600 arg10 = static_cast< bool >(val10);
16601 }
16602 if (obj10) {
16603 ecode11 = SWIG_AsVal_int(obj10, &val11);
16604 if (!SWIG_IsOK(ecode11)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DC_Blit" "', expected argument " "11"" of type '" "int""'");
16606 }
16607 arg11 = static_cast< int >(val11);
16608 }
16609 if (obj11) {
16610 ecode12 = SWIG_AsVal_int(obj11, &val12);
16611 if (!SWIG_IsOK(ecode12)) {
16612 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DC_Blit" "', expected argument " "12"" of type '" "int""'");
16613 }
16614 arg12 = static_cast< int >(val12);
16615 }
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 {
16623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16624 }
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 SWIGINTERN PyObject *_wrap_DC_BlitPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj = 0;
16633 wxDC *arg1 = (wxDC *) 0 ;
16634 wxPoint *arg2 = 0 ;
16635 wxSize *arg3 = 0 ;
16636 wxDC *arg4 = (wxDC *) 0 ;
16637 wxPoint *arg5 = 0 ;
16638 int arg6 = (int) wxCOPY ;
16639 bool arg7 = (bool) false ;
16640 wxPoint const &arg8_defvalue = wxDefaultPosition ;
16641 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
16642 bool result;
16643 void *argp1 = 0 ;
16644 int res1 = 0 ;
16645 wxPoint temp2 ;
16646 wxSize temp3 ;
16647 void *argp4 = 0 ;
16648 int res4 = 0 ;
16649 wxPoint temp5 ;
16650 int val6 ;
16651 int ecode6 = 0 ;
16652 bool val7 ;
16653 int ecode7 = 0 ;
16654 wxPoint temp8 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 PyObject * obj2 = 0 ;
16658 PyObject * obj3 = 0 ;
16659 PyObject * obj4 = 0 ;
16660 PyObject * obj5 = 0 ;
16661 PyObject * obj6 = 0 ;
16662 PyObject * obj7 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
16668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_BlitPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
16671 }
16672 arg1 = reinterpret_cast< wxDC * >(argp1);
16673 {
16674 arg2 = &temp2;
16675 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16676 }
16677 {
16678 arg3 = &temp3;
16679 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16680 }
16681 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxDC, 0 | 0 );
16682 if (!SWIG_IsOK(res4)) {
16683 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DC_BlitPointSize" "', expected argument " "4"" of type '" "wxDC *""'");
16684 }
16685 arg4 = reinterpret_cast< wxDC * >(argp4);
16686 {
16687 arg5 = &temp5;
16688 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16689 }
16690 if (obj5) {
16691 ecode6 = SWIG_AsVal_int(obj5, &val6);
16692 if (!SWIG_IsOK(ecode6)) {
16693 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_BlitPointSize" "', expected argument " "6"" of type '" "int""'");
16694 }
16695 arg6 = static_cast< int >(val6);
16696 }
16697 if (obj6) {
16698 ecode7 = SWIG_AsVal_bool(obj6, &val7);
16699 if (!SWIG_IsOK(ecode7)) {
16700 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_BlitPointSize" "', expected argument " "7"" of type '" "bool""'");
16701 }
16702 arg7 = static_cast< bool >(val7);
16703 }
16704 if (obj7) {
16705 {
16706 arg8 = &temp8;
16707 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
16708 }
16709 }
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 {
16717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16718 }
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 SWIGINTERN PyObject *_wrap_DC_SetClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj = 0;
16727 wxDC *arg1 = (wxDC *) 0 ;
16728 int arg2 ;
16729 int arg3 ;
16730 int arg4 ;
16731 int arg5 ;
16732 void *argp1 = 0 ;
16733 int res1 = 0 ;
16734 int val2 ;
16735 int ecode2 = 0 ;
16736 int val3 ;
16737 int ecode3 = 0 ;
16738 int val4 ;
16739 int ecode4 = 0 ;
16740 int val5 ;
16741 int ecode5 = 0 ;
16742 PyObject * obj0 = 0 ;
16743 PyObject * obj1 = 0 ;
16744 PyObject * obj2 = 0 ;
16745 PyObject * obj3 = 0 ;
16746 PyObject * obj4 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
16755 }
16756 arg1 = reinterpret_cast< wxDC * >(argp1);
16757 ecode2 = SWIG_AsVal_int(obj1, &val2);
16758 if (!SWIG_IsOK(ecode2)) {
16759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetClippingRegion" "', expected argument " "2"" of type '" "int""'");
16760 }
16761 arg2 = static_cast< int >(val2);
16762 ecode3 = SWIG_AsVal_int(obj2, &val3);
16763 if (!SWIG_IsOK(ecode3)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetClippingRegion" "', expected argument " "3"" of type '" "int""'");
16765 }
16766 arg3 = static_cast< int >(val3);
16767 ecode4 = SWIG_AsVal_int(obj3, &val4);
16768 if (!SWIG_IsOK(ecode4)) {
16769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_SetClippingRegion" "', expected argument " "4"" of type '" "int""'");
16770 }
16771 arg4 = static_cast< int >(val4);
16772 ecode5 = SWIG_AsVal_int(obj4, &val5);
16773 if (!SWIG_IsOK(ecode5)) {
16774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_SetClippingRegion" "', expected argument " "5"" of type '" "int""'");
16775 }
16776 arg5 = static_cast< int >(val5);
16777 {
16778 PyThreadState* __tstate = wxPyBeginAllowThreads();
16779 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
16780 wxPyEndAllowThreads(__tstate);
16781 if (PyErr_Occurred()) SWIG_fail;
16782 }
16783 resultobj = SWIG_Py_Void();
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj = 0;
16792 wxDC *arg1 = (wxDC *) 0 ;
16793 wxPoint *arg2 = 0 ;
16794 wxSize *arg3 = 0 ;
16795 void *argp1 = 0 ;
16796 int res1 = 0 ;
16797 wxPoint temp2 ;
16798 wxSize temp3 ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 PyObject * obj2 = 0 ;
16802 char * kwnames[] = {
16803 (char *) "self",(char *) "pt",(char *) "sz", NULL
16804 };
16805
16806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16808 if (!SWIG_IsOK(res1)) {
16809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
16810 }
16811 arg1 = reinterpret_cast< wxDC * >(argp1);
16812 {
16813 arg2 = &temp2;
16814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16815 }
16816 {
16817 arg3 = &temp3;
16818 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16819 }
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
16823 wxPyEndAllowThreads(__tstate);
16824 if (PyErr_Occurred()) SWIG_fail;
16825 }
16826 resultobj = SWIG_Py_Void();
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj = 0;
16835 wxDC *arg1 = (wxDC *) 0 ;
16836 wxRegion *arg2 = 0 ;
16837 void *argp1 = 0 ;
16838 int res1 = 0 ;
16839 void *argp2 = 0 ;
16840 int res2 = 0 ;
16841 PyObject * obj0 = 0 ;
16842 PyObject * obj1 = 0 ;
16843 char * kwnames[] = {
16844 (char *) "self",(char *) "region", NULL
16845 };
16846
16847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) SWIG_fail;
16848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16849 if (!SWIG_IsOK(res1)) {
16850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "1"" of type '" "wxDC *""'");
16851 }
16852 arg1 = reinterpret_cast< wxDC * >(argp1);
16853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
16854 if (!SWIG_IsOK(res2)) {
16855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
16856 }
16857 if (!argp2) {
16858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
16859 }
16860 arg2 = reinterpret_cast< wxRegion * >(argp2);
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 resultobj = SWIG_Py_Void();
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 SWIGINTERN PyObject *_wrap_DC_SetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj = 0;
16876 wxDC *arg1 = (wxDC *) 0 ;
16877 wxRect *arg2 = 0 ;
16878 void *argp1 = 0 ;
16879 int res1 = 0 ;
16880 wxRect temp2 ;
16881 PyObject * obj0 = 0 ;
16882 PyObject * obj1 = 0 ;
16883 char * kwnames[] = {
16884 (char *) "self",(char *) "rect", NULL
16885 };
16886
16887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) SWIG_fail;
16888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16889 if (!SWIG_IsOK(res1)) {
16890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
16891 }
16892 arg1 = reinterpret_cast< wxDC * >(argp1);
16893 {
16894 arg2 = &temp2;
16895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16896 }
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 (arg1)->SetClippingRegion((wxRect const &)*arg2);
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 resultobj = SWIG_Py_Void();
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 SWIGINTERN PyObject *_wrap_DC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj = 0;
16912 wxDC *arg1 = (wxDC *) 0 ;
16913 int arg2 ;
16914 wxPoint *arg3 = (wxPoint *) 0 ;
16915 int arg4 = (int) 0 ;
16916 int arg5 = (int) 0 ;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 int val4 ;
16920 int ecode4 = 0 ;
16921 int val5 ;
16922 int ecode5 = 0 ;
16923 PyObject * obj0 = 0 ;
16924 PyObject * obj1 = 0 ;
16925 PyObject * obj2 = 0 ;
16926 PyObject * obj3 = 0 ;
16927 char * kwnames[] = {
16928 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
16929 };
16930
16931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16933 if (!SWIG_IsOK(res1)) {
16934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLines" "', expected argument " "1"" of type '" "wxDC *""'");
16935 }
16936 arg1 = reinterpret_cast< wxDC * >(argp1);
16937 {
16938 arg3 = wxPoint_LIST_helper(obj1, &arg2);
16939 if (arg3 == NULL) SWIG_fail;
16940 }
16941 if (obj2) {
16942 ecode4 = SWIG_AsVal_int(obj2, &val4);
16943 if (!SWIG_IsOK(ecode4)) {
16944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLines" "', expected argument " "4"" of type '" "int""'");
16945 }
16946 arg4 = static_cast< int >(val4);
16947 }
16948 if (obj3) {
16949 ecode5 = SWIG_AsVal_int(obj3, &val5);
16950 if (!SWIG_IsOK(ecode5)) {
16951 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLines" "', expected argument " "5"" of type '" "int""'");
16952 }
16953 arg5 = static_cast< int >(val5);
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 resultobj = SWIG_Py_Void();
16962 {
16963 if (arg3) delete [] arg3;
16964 }
16965 return resultobj;
16966 fail:
16967 {
16968 if (arg3) delete [] arg3;
16969 }
16970 return NULL;
16971 }
16972
16973
16974 SWIGINTERN PyObject *_wrap_DC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16975 PyObject *resultobj = 0;
16976 wxDC *arg1 = (wxDC *) 0 ;
16977 int arg2 ;
16978 wxPoint *arg3 = (wxPoint *) 0 ;
16979 int arg4 = (int) 0 ;
16980 int arg5 = (int) 0 ;
16981 int arg6 = (int) wxODDEVEN_RULE ;
16982 void *argp1 = 0 ;
16983 int res1 = 0 ;
16984 int val4 ;
16985 int ecode4 = 0 ;
16986 int val5 ;
16987 int ecode5 = 0 ;
16988 int val6 ;
16989 int ecode6 = 0 ;
16990 PyObject * obj0 = 0 ;
16991 PyObject * obj1 = 0 ;
16992 PyObject * obj2 = 0 ;
16993 PyObject * obj3 = 0 ;
16994 PyObject * obj4 = 0 ;
16995 char * kwnames[] = {
16996 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
16997 };
16998
16999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17001 if (!SWIG_IsOK(res1)) {
17002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPolygon" "', expected argument " "1"" of type '" "wxDC *""'");
17003 }
17004 arg1 = reinterpret_cast< wxDC * >(argp1);
17005 {
17006 arg3 = wxPoint_LIST_helper(obj1, &arg2);
17007 if (arg3 == NULL) SWIG_fail;
17008 }
17009 if (obj2) {
17010 ecode4 = SWIG_AsVal_int(obj2, &val4);
17011 if (!SWIG_IsOK(ecode4)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
17013 }
17014 arg4 = static_cast< int >(val4);
17015 }
17016 if (obj3) {
17017 ecode5 = SWIG_AsVal_int(obj3, &val5);
17018 if (!SWIG_IsOK(ecode5)) {
17019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
17020 }
17021 arg5 = static_cast< int >(val5);
17022 }
17023 if (obj4) {
17024 ecode6 = SWIG_AsVal_int(obj4, &val6);
17025 if (!SWIG_IsOK(ecode6)) {
17026 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
17027 }
17028 arg6 = static_cast< int >(val6);
17029 }
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 resultobj = SWIG_Py_Void();
17037 {
17038 if (arg3) delete [] arg3;
17039 }
17040 return resultobj;
17041 fail:
17042 {
17043 if (arg3) delete [] arg3;
17044 }
17045 return NULL;
17046 }
17047
17048
17049 SWIGINTERN PyObject *_wrap_DC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj = 0;
17051 wxDC *arg1 = (wxDC *) 0 ;
17052 wxString *arg2 = 0 ;
17053 wxRect *arg3 = 0 ;
17054 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
17055 int arg5 = (int) -1 ;
17056 void *argp1 = 0 ;
17057 int res1 = 0 ;
17058 bool temp2 = false ;
17059 wxRect temp3 ;
17060 int val4 ;
17061 int ecode4 = 0 ;
17062 int val5 ;
17063 int ecode5 = 0 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 PyObject * obj2 = 0 ;
17067 PyObject * obj3 = 0 ;
17068 PyObject * obj4 = 0 ;
17069 char * kwnames[] = {
17070 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
17071 };
17072
17073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17075 if (!SWIG_IsOK(res1)) {
17076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLabel" "', expected argument " "1"" of type '" "wxDC *""'");
17077 }
17078 arg1 = reinterpret_cast< wxDC * >(argp1);
17079 {
17080 arg2 = wxString_in_helper(obj1);
17081 if (arg2 == NULL) SWIG_fail;
17082 temp2 = true;
17083 }
17084 {
17085 arg3 = &temp3;
17086 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
17087 }
17088 if (obj3) {
17089 ecode4 = SWIG_AsVal_int(obj3, &val4);
17090 if (!SWIG_IsOK(ecode4)) {
17091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
17092 }
17093 arg4 = static_cast< int >(val4);
17094 }
17095 if (obj4) {
17096 ecode5 = SWIG_AsVal_int(obj4, &val5);
17097 if (!SWIG_IsOK(ecode5)) {
17098 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
17099 }
17100 arg5 = static_cast< int >(val5);
17101 }
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 resultobj = SWIG_Py_Void();
17109 {
17110 if (temp2)
17111 delete arg2;
17112 }
17113 return resultobj;
17114 fail:
17115 {
17116 if (temp2)
17117 delete arg2;
17118 }
17119 return NULL;
17120 }
17121
17122
17123 SWIGINTERN PyObject *_wrap_DC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = 0;
17125 wxDC *arg1 = (wxDC *) 0 ;
17126 wxString *arg2 = 0 ;
17127 wxBitmap *arg3 = 0 ;
17128 wxRect *arg4 = 0 ;
17129 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
17130 int arg6 = (int) -1 ;
17131 wxRect result;
17132 void *argp1 = 0 ;
17133 int res1 = 0 ;
17134 bool temp2 = false ;
17135 void *argp3 = 0 ;
17136 int res3 = 0 ;
17137 wxRect temp4 ;
17138 int val5 ;
17139 int ecode5 = 0 ;
17140 int val6 ;
17141 int ecode6 = 0 ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 PyObject * obj2 = 0 ;
17145 PyObject * obj3 = 0 ;
17146 PyObject * obj4 = 0 ;
17147 PyObject * obj5 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawImageLabel" "', expected argument " "1"" of type '" "wxDC *""'");
17156 }
17157 arg1 = reinterpret_cast< wxDC * >(argp1);
17158 {
17159 arg2 = wxString_in_helper(obj1);
17160 if (arg2 == NULL) SWIG_fail;
17161 temp2 = true;
17162 }
17163 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
17164 if (!SWIG_IsOK(res3)) {
17165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
17166 }
17167 if (!argp3) {
17168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
17169 }
17170 arg3 = reinterpret_cast< wxBitmap * >(argp3);
17171 {
17172 arg4 = &temp4;
17173 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
17174 }
17175 if (obj4) {
17176 ecode5 = SWIG_AsVal_int(obj4, &val5);
17177 if (!SWIG_IsOK(ecode5)) {
17178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
17179 }
17180 arg5 = static_cast< int >(val5);
17181 }
17182 if (obj5) {
17183 ecode6 = SWIG_AsVal_int(obj5, &val6);
17184 if (!SWIG_IsOK(ecode6)) {
17185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
17186 }
17187 arg6 = static_cast< int >(val6);
17188 }
17189 {
17190 PyThreadState* __tstate = wxPyBeginAllowThreads();
17191 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
17192 wxPyEndAllowThreads(__tstate);
17193 if (PyErr_Occurred()) SWIG_fail;
17194 }
17195 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17196 {
17197 if (temp2)
17198 delete arg2;
17199 }
17200 return resultobj;
17201 fail:
17202 {
17203 if (temp2)
17204 delete arg2;
17205 }
17206 return NULL;
17207 }
17208
17209
17210 SWIGINTERN PyObject *_wrap_DC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj = 0;
17212 wxDC *arg1 = (wxDC *) 0 ;
17213 int arg2 ;
17214 wxPoint *arg3 = (wxPoint *) 0 ;
17215 void *argp1 = 0 ;
17216 int res1 = 0 ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 char * kwnames[] = {
17220 (char *) "self",(char *) "points", NULL
17221 };
17222
17223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
17224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17225 if (!SWIG_IsOK(res1)) {
17226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawSpline" "', expected argument " "1"" of type '" "wxDC *""'");
17227 }
17228 arg1 = reinterpret_cast< wxDC * >(argp1);
17229 {
17230 arg3 = wxPoint_LIST_helper(obj1, &arg2);
17231 if (arg3 == NULL) SWIG_fail;
17232 }
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 (arg1)->DrawSpline(arg2,arg3);
17236 wxPyEndAllowThreads(__tstate);
17237 if (PyErr_Occurred()) SWIG_fail;
17238 }
17239 resultobj = SWIG_Py_Void();
17240 {
17241 if (arg3) delete [] arg3;
17242 }
17243 return resultobj;
17244 fail:
17245 {
17246 if (arg3) delete [] arg3;
17247 }
17248 return NULL;
17249 }
17250
17251
17252 SWIGINTERN PyObject *_wrap_DC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17253 PyObject *resultobj = 0;
17254 wxDC *arg1 = (wxDC *) 0 ;
17255 void *argp1 = 0 ;
17256 int res1 = 0 ;
17257 PyObject *swig_obj[1] ;
17258
17259 if (!args) SWIG_fail;
17260 swig_obj[0] = args;
17261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17262 if (!SWIG_IsOK(res1)) {
17263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Clear" "', expected argument " "1"" of type '" "wxDC *""'");
17264 }
17265 arg1 = reinterpret_cast< wxDC * >(argp1);
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 (arg1)->Clear();
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 resultobj = SWIG_Py_Void();
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 SWIGINTERN PyObject *_wrap_DC_StartDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj = 0;
17281 wxDC *arg1 = (wxDC *) 0 ;
17282 wxString *arg2 = 0 ;
17283 bool result;
17284 void *argp1 = 0 ;
17285 int res1 = 0 ;
17286 bool temp2 = false ;
17287 PyObject * obj0 = 0 ;
17288 PyObject * obj1 = 0 ;
17289 char * kwnames[] = {
17290 (char *) "self",(char *) "message", NULL
17291 };
17292
17293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) SWIG_fail;
17294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17295 if (!SWIG_IsOK(res1)) {
17296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartDoc" "', expected argument " "1"" of type '" "wxDC *""'");
17297 }
17298 arg1 = reinterpret_cast< wxDC * >(argp1);
17299 {
17300 arg2 = wxString_in_helper(obj1);
17301 if (arg2 == NULL) SWIG_fail;
17302 temp2 = true;
17303 }
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
17307 wxPyEndAllowThreads(__tstate);
17308 if (PyErr_Occurred()) SWIG_fail;
17309 }
17310 {
17311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17312 }
17313 {
17314 if (temp2)
17315 delete arg2;
17316 }
17317 return resultobj;
17318 fail:
17319 {
17320 if (temp2)
17321 delete arg2;
17322 }
17323 return NULL;
17324 }
17325
17326
17327 SWIGINTERN PyObject *_wrap_DC_EndDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *resultobj = 0;
17329 wxDC *arg1 = (wxDC *) 0 ;
17330 void *argp1 = 0 ;
17331 int res1 = 0 ;
17332 PyObject *swig_obj[1] ;
17333
17334 if (!args) SWIG_fail;
17335 swig_obj[0] = args;
17336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17337 if (!SWIG_IsOK(res1)) {
17338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndDoc" "', expected argument " "1"" of type '" "wxDC *""'");
17339 }
17340 arg1 = reinterpret_cast< wxDC * >(argp1);
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 (arg1)->EndDoc();
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 resultobj = SWIG_Py_Void();
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_DC_StartPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *resultobj = 0;
17356 wxDC *arg1 = (wxDC *) 0 ;
17357 void *argp1 = 0 ;
17358 int res1 = 0 ;
17359 PyObject *swig_obj[1] ;
17360
17361 if (!args) SWIG_fail;
17362 swig_obj[0] = args;
17363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17364 if (!SWIG_IsOK(res1)) {
17365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartPage" "', expected argument " "1"" of type '" "wxDC *""'");
17366 }
17367 arg1 = reinterpret_cast< wxDC * >(argp1);
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 (arg1)->StartPage();
17371 wxPyEndAllowThreads(__tstate);
17372 if (PyErr_Occurred()) SWIG_fail;
17373 }
17374 resultobj = SWIG_Py_Void();
17375 return resultobj;
17376 fail:
17377 return NULL;
17378 }
17379
17380
17381 SWIGINTERN PyObject *_wrap_DC_EndPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 PyObject *resultobj = 0;
17383 wxDC *arg1 = (wxDC *) 0 ;
17384 void *argp1 = 0 ;
17385 int res1 = 0 ;
17386 PyObject *swig_obj[1] ;
17387
17388 if (!args) SWIG_fail;
17389 swig_obj[0] = args;
17390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17391 if (!SWIG_IsOK(res1)) {
17392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndPage" "', expected argument " "1"" of type '" "wxDC *""'");
17393 }
17394 arg1 = reinterpret_cast< wxDC * >(argp1);
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 (arg1)->EndPage();
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 resultobj = SWIG_Py_Void();
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 SWIGINTERN PyObject *_wrap_DC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17409 PyObject *resultobj = 0;
17410 wxDC *arg1 = (wxDC *) 0 ;
17411 wxFont *arg2 = 0 ;
17412 void *argp1 = 0 ;
17413 int res1 = 0 ;
17414 void *argp2 = 0 ;
17415 int res2 = 0 ;
17416 PyObject * obj0 = 0 ;
17417 PyObject * obj1 = 0 ;
17418 char * kwnames[] = {
17419 (char *) "self",(char *) "font", NULL
17420 };
17421
17422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
17423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17424 if (!SWIG_IsOK(res1)) {
17425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetFont" "', expected argument " "1"" of type '" "wxDC *""'");
17426 }
17427 arg1 = reinterpret_cast< wxDC * >(argp1);
17428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
17429 if (!SWIG_IsOK(res2)) {
17430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
17431 }
17432 if (!argp2) {
17433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
17434 }
17435 arg2 = reinterpret_cast< wxFont * >(argp2);
17436 {
17437 PyThreadState* __tstate = wxPyBeginAllowThreads();
17438 (arg1)->SetFont((wxFont const &)*arg2);
17439 wxPyEndAllowThreads(__tstate);
17440 if (PyErr_Occurred()) SWIG_fail;
17441 }
17442 resultobj = SWIG_Py_Void();
17443 return resultobj;
17444 fail:
17445 return NULL;
17446 }
17447
17448
17449 SWIGINTERN PyObject *_wrap_DC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17450 PyObject *resultobj = 0;
17451 wxDC *arg1 = (wxDC *) 0 ;
17452 wxPen *arg2 = 0 ;
17453 void *argp1 = 0 ;
17454 int res1 = 0 ;
17455 void *argp2 = 0 ;
17456 int res2 = 0 ;
17457 PyObject * obj0 = 0 ;
17458 PyObject * obj1 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "pen", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPen" "', expected argument " "1"" of type '" "wxDC *""'");
17467 }
17468 arg1 = reinterpret_cast< wxDC * >(argp1);
17469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
17470 if (!SWIG_IsOK(res2)) {
17471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
17472 }
17473 if (!argp2) {
17474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
17475 }
17476 arg2 = reinterpret_cast< wxPen * >(argp2);
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 (arg1)->SetPen((wxPen const &)*arg2);
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_Py_Void();
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_DC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj = 0;
17492 wxDC *arg1 = (wxDC *) 0 ;
17493 wxBrush *arg2 = 0 ;
17494 void *argp1 = 0 ;
17495 int res1 = 0 ;
17496 void *argp2 = 0 ;
17497 int res2 = 0 ;
17498 PyObject * obj0 = 0 ;
17499 PyObject * obj1 = 0 ;
17500 char * kwnames[] = {
17501 (char *) "self",(char *) "brush", NULL
17502 };
17503
17504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
17505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17506 if (!SWIG_IsOK(res1)) {
17507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBrush" "', expected argument " "1"" of type '" "wxDC *""'");
17508 }
17509 arg1 = reinterpret_cast< wxDC * >(argp1);
17510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
17511 if (!SWIG_IsOK(res2)) {
17512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
17513 }
17514 if (!argp2) {
17515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
17516 }
17517 arg2 = reinterpret_cast< wxBrush * >(argp2);
17518 {
17519 PyThreadState* __tstate = wxPyBeginAllowThreads();
17520 (arg1)->SetBrush((wxBrush const &)*arg2);
17521 wxPyEndAllowThreads(__tstate);
17522 if (PyErr_Occurred()) SWIG_fail;
17523 }
17524 resultobj = SWIG_Py_Void();
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_DC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj = 0;
17533 wxDC *arg1 = (wxDC *) 0 ;
17534 wxBrush *arg2 = 0 ;
17535 void *argp1 = 0 ;
17536 int res1 = 0 ;
17537 void *argp2 = 0 ;
17538 int res2 = 0 ;
17539 PyObject * obj0 = 0 ;
17540 PyObject * obj1 = 0 ;
17541 char * kwnames[] = {
17542 (char *) "self",(char *) "brush", NULL
17543 };
17544
17545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17547 if (!SWIG_IsOK(res1)) {
17548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackground" "', expected argument " "1"" of type '" "wxDC *""'");
17549 }
17550 arg1 = reinterpret_cast< wxDC * >(argp1);
17551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
17552 if (!SWIG_IsOK(res2)) {
17553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
17554 }
17555 if (!argp2) {
17556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
17557 }
17558 arg2 = reinterpret_cast< wxBrush * >(argp2);
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 (arg1)->SetBackground((wxBrush const &)*arg2);
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_Py_Void();
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_DC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = 0;
17574 wxDC *arg1 = (wxDC *) 0 ;
17575 int arg2 ;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 int val2 ;
17579 int ecode2 = 0 ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 char * kwnames[] = {
17583 (char *) "self",(char *) "mode", NULL
17584 };
17585
17586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
17587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17588 if (!SWIG_IsOK(res1)) {
17589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxDC *""'");
17590 }
17591 arg1 = reinterpret_cast< wxDC * >(argp1);
17592 ecode2 = SWIG_AsVal_int(obj1, &val2);
17593 if (!SWIG_IsOK(ecode2)) {
17594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
17595 }
17596 arg2 = static_cast< int >(val2);
17597 {
17598 PyThreadState* __tstate = wxPyBeginAllowThreads();
17599 (arg1)->SetBackgroundMode(arg2);
17600 wxPyEndAllowThreads(__tstate);
17601 if (PyErr_Occurred()) SWIG_fail;
17602 }
17603 resultobj = SWIG_Py_Void();
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 SWIGINTERN PyObject *_wrap_DC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj = 0;
17612 wxDC *arg1 = (wxDC *) 0 ;
17613 wxPalette *arg2 = 0 ;
17614 void *argp1 = 0 ;
17615 int res1 = 0 ;
17616 void *argp2 = 0 ;
17617 int res2 = 0 ;
17618 PyObject * obj0 = 0 ;
17619 PyObject * obj1 = 0 ;
17620 char * kwnames[] = {
17621 (char *) "self",(char *) "palette", NULL
17622 };
17623
17624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
17625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17626 if (!SWIG_IsOK(res1)) {
17627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPalette" "', expected argument " "1"" of type '" "wxDC *""'");
17628 }
17629 arg1 = reinterpret_cast< wxDC * >(argp1);
17630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
17631 if (!SWIG_IsOK(res2)) {
17632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
17633 }
17634 if (!argp2) {
17635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
17636 }
17637 arg2 = reinterpret_cast< wxPalette * >(argp2);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 (arg1)->SetPalette((wxPalette const &)*arg2);
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 resultobj = SWIG_Py_Void();
17645 return resultobj;
17646 fail:
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_DC_DestroyClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17652 PyObject *resultobj = 0;
17653 wxDC *arg1 = (wxDC *) 0 ;
17654 void *argp1 = 0 ;
17655 int res1 = 0 ;
17656 PyObject *swig_obj[1] ;
17657
17658 if (!args) SWIG_fail;
17659 swig_obj[0] = args;
17660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17661 if (!SWIG_IsOK(res1)) {
17662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DestroyClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
17663 }
17664 arg1 = reinterpret_cast< wxDC * >(argp1);
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 (arg1)->DestroyClippingRegion();
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_Py_Void();
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *_wrap_DC_GetClippingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *resultobj = 0;
17680 wxDC *arg1 = (wxDC *) 0 ;
17681 int *arg2 = (int *) 0 ;
17682 int *arg3 = (int *) 0 ;
17683 int *arg4 = (int *) 0 ;
17684 int *arg5 = (int *) 0 ;
17685 void *argp1 = 0 ;
17686 int res1 = 0 ;
17687 int temp2 ;
17688 int res2 = SWIG_TMPOBJ ;
17689 int temp3 ;
17690 int res3 = SWIG_TMPOBJ ;
17691 int temp4 ;
17692 int res4 = SWIG_TMPOBJ ;
17693 int temp5 ;
17694 int res5 = SWIG_TMPOBJ ;
17695 PyObject *swig_obj[1] ;
17696
17697 arg2 = &temp2;
17698 arg3 = &temp3;
17699 arg4 = &temp4;
17700 arg5 = &temp5;
17701 if (!args) SWIG_fail;
17702 swig_obj[0] = args;
17703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17704 if (!SWIG_IsOK(res1)) {
17705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingBox" "', expected argument " "1"" of type '" "wxDC const *""'");
17706 }
17707 arg1 = reinterpret_cast< wxDC * >(argp1);
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
17711 wxPyEndAllowThreads(__tstate);
17712 if (PyErr_Occurred()) SWIG_fail;
17713 }
17714 resultobj = SWIG_Py_Void();
17715 if (SWIG_IsTmpObj(res2)) {
17716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
17717 } else {
17718 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17720 }
17721 if (SWIG_IsTmpObj(res3)) {
17722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17723 } else {
17724 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17726 }
17727 if (SWIG_IsTmpObj(res4)) {
17728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
17729 } else {
17730 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17732 }
17733 if (SWIG_IsTmpObj(res5)) {
17734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
17735 } else {
17736 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_DC_GetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17746 PyObject *resultobj = 0;
17747 wxDC *arg1 = (wxDC *) 0 ;
17748 wxRect result;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 PyObject *swig_obj[1] ;
17752
17753 if (!args) SWIG_fail;
17754 swig_obj[0] = args;
17755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17756 if (!SWIG_IsOK(res1)) {
17757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
17758 }
17759 arg1 = reinterpret_cast< wxDC * >(argp1);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = wxDC_GetClippingRect(arg1);
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_DC_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17774 PyObject *resultobj = 0;
17775 wxDC *arg1 = (wxDC *) 0 ;
17776 int result;
17777 void *argp1 = 0 ;
17778 int res1 = 0 ;
17779 PyObject *swig_obj[1] ;
17780
17781 if (!args) SWIG_fail;
17782 swig_obj[0] = args;
17783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17784 if (!SWIG_IsOK(res1)) {
17785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharHeight" "', expected argument " "1"" of type '" "wxDC const *""'");
17786 }
17787 arg1 = reinterpret_cast< wxDC * >(argp1);
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (int)((wxDC const *)arg1)->GetCharHeight();
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 resultobj = SWIG_From_int(static_cast< int >(result));
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 SWIGINTERN PyObject *_wrap_DC_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17802 PyObject *resultobj = 0;
17803 wxDC *arg1 = (wxDC *) 0 ;
17804 int result;
17805 void *argp1 = 0 ;
17806 int res1 = 0 ;
17807 PyObject *swig_obj[1] ;
17808
17809 if (!args) SWIG_fail;
17810 swig_obj[0] = args;
17811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17812 if (!SWIG_IsOK(res1)) {
17813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharWidth" "', expected argument " "1"" of type '" "wxDC const *""'");
17814 }
17815 arg1 = reinterpret_cast< wxDC * >(argp1);
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (int)((wxDC const *)arg1)->GetCharWidth();
17819 wxPyEndAllowThreads(__tstate);
17820 if (PyErr_Occurred()) SWIG_fail;
17821 }
17822 resultobj = SWIG_From_int(static_cast< int >(result));
17823 return resultobj;
17824 fail:
17825 return NULL;
17826 }
17827
17828
17829 SWIGINTERN PyObject *_wrap_DC_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17830 PyObject *resultobj = 0;
17831 wxDC *arg1 = (wxDC *) 0 ;
17832 wxString *arg2 = 0 ;
17833 int *arg3 = (int *) 0 ;
17834 int *arg4 = (int *) 0 ;
17835 void *argp1 = 0 ;
17836 int res1 = 0 ;
17837 bool temp2 = false ;
17838 int temp3 ;
17839 int res3 = SWIG_TMPOBJ ;
17840 int temp4 ;
17841 int res4 = SWIG_TMPOBJ ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 char * kwnames[] = {
17845 (char *) "self",(char *) "string", NULL
17846 };
17847
17848 arg3 = &temp3;
17849 arg4 = &temp4;
17850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
17851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
17854 }
17855 arg1 = reinterpret_cast< wxDC * >(argp1);
17856 {
17857 arg2 = wxString_in_helper(obj1);
17858 if (arg2 == NULL) SWIG_fail;
17859 temp2 = true;
17860 }
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 resultobj = SWIG_Py_Void();
17868 if (SWIG_IsTmpObj(res3)) {
17869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17870 } else {
17871 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17873 }
17874 if (SWIG_IsTmpObj(res4)) {
17875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
17876 } else {
17877 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17879 }
17880 {
17881 if (temp2)
17882 delete arg2;
17883 }
17884 return resultobj;
17885 fail:
17886 {
17887 if (temp2)
17888 delete arg2;
17889 }
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_DC_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxDC *arg1 = (wxDC *) 0 ;
17897 wxString *arg2 = 0 ;
17898 int *arg3 = (int *) 0 ;
17899 int *arg4 = (int *) 0 ;
17900 int *arg5 = (int *) 0 ;
17901 int *arg6 = (int *) 0 ;
17902 wxFont *arg7 = (wxFont *) NULL ;
17903 void *argp1 = 0 ;
17904 int res1 = 0 ;
17905 bool temp2 = false ;
17906 int temp3 ;
17907 int res3 = SWIG_TMPOBJ ;
17908 int temp4 ;
17909 int res4 = SWIG_TMPOBJ ;
17910 int temp5 ;
17911 int res5 = SWIG_TMPOBJ ;
17912 int temp6 ;
17913 int res6 = SWIG_TMPOBJ ;
17914 void *argp7 = 0 ;
17915 int res7 = 0 ;
17916 PyObject * obj0 = 0 ;
17917 PyObject * obj1 = 0 ;
17918 PyObject * obj2 = 0 ;
17919 char * kwnames[] = {
17920 (char *) "self",(char *) "string",(char *) "font", NULL
17921 };
17922
17923 arg3 = &temp3;
17924 arg4 = &temp4;
17925 arg5 = &temp5;
17926 arg6 = &temp6;
17927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFullTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
17931 }
17932 arg1 = reinterpret_cast< wxDC * >(argp1);
17933 {
17934 arg2 = wxString_in_helper(obj1);
17935 if (arg2 == NULL) SWIG_fail;
17936 temp2 = true;
17937 }
17938 if (obj2) {
17939 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
17940 if (!SWIG_IsOK(res7)) {
17941 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DC_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont *""'");
17942 }
17943 arg7 = reinterpret_cast< wxFont * >(argp7);
17944 }
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 resultobj = SWIG_Py_Void();
17952 if (SWIG_IsTmpObj(res3)) {
17953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17954 } else {
17955 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17957 }
17958 if (SWIG_IsTmpObj(res4)) {
17959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
17960 } else {
17961 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17963 }
17964 if (SWIG_IsTmpObj(res5)) {
17965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
17966 } else {
17967 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17969 }
17970 if (SWIG_IsTmpObj(res6)) {
17971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
17972 } else {
17973 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
17975 }
17976 {
17977 if (temp2)
17978 delete arg2;
17979 }
17980 return resultobj;
17981 fail:
17982 {
17983 if (temp2)
17984 delete arg2;
17985 }
17986 return NULL;
17987 }
17988
17989
17990 SWIGINTERN PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17991 PyObject *resultobj = 0;
17992 wxDC *arg1 = (wxDC *) 0 ;
17993 wxString *arg2 = 0 ;
17994 int *arg3 = (int *) 0 ;
17995 int *arg4 = (int *) 0 ;
17996 int *arg5 = (int *) 0 ;
17997 wxFont *arg6 = (wxFont *) NULL ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 bool temp2 = false ;
18001 int temp3 ;
18002 int res3 = SWIG_TMPOBJ ;
18003 int temp4 ;
18004 int res4 = SWIG_TMPOBJ ;
18005 int temp5 ;
18006 int res5 = SWIG_TMPOBJ ;
18007 void *argp6 = 0 ;
18008 int res6 = 0 ;
18009 PyObject * obj0 = 0 ;
18010 PyObject * obj1 = 0 ;
18011 PyObject * obj2 = 0 ;
18012 char * kwnames[] = {
18013 (char *) "self",(char *) "text",(char *) "font", NULL
18014 };
18015
18016 arg3 = &temp3;
18017 arg4 = &temp4;
18018 arg5 = &temp5;
18019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18021 if (!SWIG_IsOK(res1)) {
18022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
18023 }
18024 arg1 = reinterpret_cast< wxDC * >(argp1);
18025 {
18026 arg2 = wxString_in_helper(obj1);
18027 if (arg2 == NULL) SWIG_fail;
18028 temp2 = true;
18029 }
18030 if (obj2) {
18031 res6 = SWIG_ConvertPtr(obj2, &argp6,SWIGTYPE_p_wxFont, 0 | 0 );
18032 if (!SWIG_IsOK(res6)) {
18033 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "6"" of type '" "wxFont *""'");
18034 }
18035 arg6 = reinterpret_cast< wxFont * >(argp6);
18036 }
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = SWIG_Py_Void();
18044 if (SWIG_IsTmpObj(res3)) {
18045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18046 } else {
18047 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18049 }
18050 if (SWIG_IsTmpObj(res4)) {
18051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
18052 } else {
18053 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18055 }
18056 if (SWIG_IsTmpObj(res5)) {
18057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
18058 } else {
18059 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18061 }
18062 {
18063 if (temp2)
18064 delete arg2;
18065 }
18066 return resultobj;
18067 fail:
18068 {
18069 if (temp2)
18070 delete arg2;
18071 }
18072 return NULL;
18073 }
18074
18075
18076 SWIGINTERN PyObject *_wrap_DC_GetPartialTextExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj = 0;
18078 wxDC *arg1 = (wxDC *) 0 ;
18079 wxString *arg2 = 0 ;
18080 wxArrayInt result;
18081 void *argp1 = 0 ;
18082 int res1 = 0 ;
18083 bool temp2 = false ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 char * kwnames[] = {
18087 (char *) "self",(char *) "text", NULL
18088 };
18089
18090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) SWIG_fail;
18091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18092 if (!SWIG_IsOK(res1)) {
18093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPartialTextExtents" "', expected argument " "1"" of type '" "wxDC *""'");
18094 }
18095 arg1 = reinterpret_cast< wxDC * >(argp1);
18096 {
18097 arg2 = wxString_in_helper(obj1);
18098 if (arg2 == NULL) SWIG_fail;
18099 temp2 = true;
18100 }
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 {
18108 resultobj = PyList_New(0);
18109 size_t idx;
18110 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
18111 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
18112 PyList_Append(resultobj, val);
18113 Py_DECREF(val);
18114 }
18115 }
18116 {
18117 if (temp2)
18118 delete arg2;
18119 }
18120 return resultobj;
18121 fail:
18122 {
18123 if (temp2)
18124 delete arg2;
18125 }
18126 return NULL;
18127 }
18128
18129
18130 SWIGINTERN PyObject *_wrap_DC_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18131 PyObject *resultobj = 0;
18132 wxDC *arg1 = (wxDC *) 0 ;
18133 wxSize result;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 PyObject *swig_obj[1] ;
18137
18138 if (!args) SWIG_fail;
18139 swig_obj[0] = args;
18140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18141 if (!SWIG_IsOK(res1)) {
18142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSize" "', expected argument " "1"" of type '" "wxDC *""'");
18143 }
18144 arg1 = reinterpret_cast< wxDC * >(argp1);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (arg1)->GetSize();
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_DC_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18159 PyObject *resultobj = 0;
18160 wxDC *arg1 = (wxDC *) 0 ;
18161 int *arg2 = (int *) 0 ;
18162 int *arg3 = (int *) 0 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 int temp2 ;
18166 int res2 = SWIG_TMPOBJ ;
18167 int temp3 ;
18168 int res3 = SWIG_TMPOBJ ;
18169 PyObject *swig_obj[1] ;
18170
18171 arg2 = &temp2;
18172 arg3 = &temp3;
18173 if (!args) SWIG_fail;
18174 swig_obj[0] = args;
18175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18176 if (!SWIG_IsOK(res1)) {
18177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeTuple" "', expected argument " "1"" of type '" "wxDC *""'");
18178 }
18179 arg1 = reinterpret_cast< wxDC * >(argp1);
18180 {
18181 PyThreadState* __tstate = wxPyBeginAllowThreads();
18182 (arg1)->GetSize(arg2,arg3);
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 resultobj = SWIG_Py_Void();
18187 if (SWIG_IsTmpObj(res2)) {
18188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
18189 } else {
18190 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18192 }
18193 if (SWIG_IsTmpObj(res3)) {
18194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18195 } else {
18196 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18198 }
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 SWIGINTERN PyObject *_wrap_DC_GetSizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18206 PyObject *resultobj = 0;
18207 wxDC *arg1 = (wxDC *) 0 ;
18208 wxSize result;
18209 void *argp1 = 0 ;
18210 int res1 = 0 ;
18211 PyObject *swig_obj[1] ;
18212
18213 if (!args) SWIG_fail;
18214 swig_obj[0] = args;
18215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18216 if (!SWIG_IsOK(res1)) {
18217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMM" "', expected argument " "1"" of type '" "wxDC const *""'");
18218 }
18219 arg1 = reinterpret_cast< wxDC * >(argp1);
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 result = ((wxDC const *)arg1)->GetSizeMM();
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 SWIGINTERN PyObject *_wrap_DC_GetSizeMMTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234 PyObject *resultobj = 0;
18235 wxDC *arg1 = (wxDC *) 0 ;
18236 int *arg2 = (int *) 0 ;
18237 int *arg3 = (int *) 0 ;
18238 void *argp1 = 0 ;
18239 int res1 = 0 ;
18240 int temp2 ;
18241 int res2 = SWIG_TMPOBJ ;
18242 int temp3 ;
18243 int res3 = SWIG_TMPOBJ ;
18244 PyObject *swig_obj[1] ;
18245
18246 arg2 = &temp2;
18247 arg3 = &temp3;
18248 if (!args) SWIG_fail;
18249 swig_obj[0] = args;
18250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18251 if (!SWIG_IsOK(res1)) {
18252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMMTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
18253 }
18254 arg1 = reinterpret_cast< wxDC * >(argp1);
18255 {
18256 PyThreadState* __tstate = wxPyBeginAllowThreads();
18257 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 resultobj = SWIG_Py_Void();
18262 if (SWIG_IsTmpObj(res2)) {
18263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
18264 } else {
18265 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18267 }
18268 if (SWIG_IsTmpObj(res3)) {
18269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18270 } else {
18271 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18273 }
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj = 0;
18282 wxDC *arg1 = (wxDC *) 0 ;
18283 int arg2 ;
18284 int result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 int val2 ;
18288 int ecode2 = 0 ;
18289 PyObject * obj0 = 0 ;
18290 PyObject * obj1 = 0 ;
18291 char * kwnames[] = {
18292 (char *) "self",(char *) "x", NULL
18293 };
18294
18295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) SWIG_fail;
18296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18297 if (!SWIG_IsOK(res1)) {
18298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalX" "', expected argument " "1"" of type '" "wxDC const *""'");
18299 }
18300 arg1 = reinterpret_cast< wxDC * >(argp1);
18301 ecode2 = SWIG_AsVal_int(obj1, &val2);
18302 if (!SWIG_IsOK(ecode2)) {
18303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalX" "', expected argument " "2"" of type '" "int""'");
18304 }
18305 arg2 = static_cast< int >(val2);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_From_int(static_cast< int >(result));
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj = 0;
18321 wxDC *arg1 = (wxDC *) 0 ;
18322 int arg2 ;
18323 int result;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 int val2 ;
18327 int ecode2 = 0 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "y", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalY" "', expected argument " "1"" of type '" "wxDC const *""'");
18338 }
18339 arg1 = reinterpret_cast< wxDC * >(argp1);
18340 ecode2 = SWIG_AsVal_int(obj1, &val2);
18341 if (!SWIG_IsOK(ecode2)) {
18342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalY" "', expected argument " "2"" of type '" "int""'");
18343 }
18344 arg2 = static_cast< int >(val2);
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_From_int(static_cast< int >(result));
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj = 0;
18360 wxDC *arg1 = (wxDC *) 0 ;
18361 int arg2 ;
18362 int result;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 int val2 ;
18366 int ecode2 = 0 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char * kwnames[] = {
18370 (char *) "self",(char *) "x", NULL
18371 };
18372
18373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) SWIG_fail;
18374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18375 if (!SWIG_IsOK(res1)) {
18376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18377 }
18378 arg1 = reinterpret_cast< wxDC * >(argp1);
18379 ecode2 = SWIG_AsVal_int(obj1, &val2);
18380 if (!SWIG_IsOK(ecode2)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "2"" of type '" "int""'");
18382 }
18383 arg2 = static_cast< int >(val2);
18384 {
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 resultobj = SWIG_From_int(static_cast< int >(result));
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18398 PyObject *resultobj = 0;
18399 wxDC *arg1 = (wxDC *) 0 ;
18400 int arg2 ;
18401 int result;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 int val2 ;
18405 int ecode2 = 0 ;
18406 PyObject * obj0 = 0 ;
18407 PyObject * obj1 = 0 ;
18408 char * kwnames[] = {
18409 (char *) "self",(char *) "y", NULL
18410 };
18411
18412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) SWIG_fail;
18413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18414 if (!SWIG_IsOK(res1)) {
18415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18416 }
18417 arg1 = reinterpret_cast< wxDC * >(argp1);
18418 ecode2 = SWIG_AsVal_int(obj1, &val2);
18419 if (!SWIG_IsOK(ecode2)) {
18420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "2"" of type '" "int""'");
18421 }
18422 arg2 = static_cast< int >(val2);
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
18426 wxPyEndAllowThreads(__tstate);
18427 if (PyErr_Occurred()) SWIG_fail;
18428 }
18429 resultobj = SWIG_From_int(static_cast< int >(result));
18430 return resultobj;
18431 fail:
18432 return NULL;
18433 }
18434
18435
18436 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18437 PyObject *resultobj = 0;
18438 wxDC *arg1 = (wxDC *) 0 ;
18439 int arg2 ;
18440 int result;
18441 void *argp1 = 0 ;
18442 int res1 = 0 ;
18443 int val2 ;
18444 int ecode2 = 0 ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 char * kwnames[] = {
18448 (char *) "self",(char *) "x", NULL
18449 };
18450
18451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) SWIG_fail;
18452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18453 if (!SWIG_IsOK(res1)) {
18454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceX" "', expected argument " "1"" of type '" "wxDC const *""'");
18455 }
18456 arg1 = reinterpret_cast< wxDC * >(argp1);
18457 ecode2 = SWIG_AsVal_int(obj1, &val2);
18458 if (!SWIG_IsOK(ecode2)) {
18459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceX" "', expected argument " "2"" of type '" "int""'");
18460 }
18461 arg2 = static_cast< int >(val2);
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_From_int(static_cast< int >(result));
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18476 PyObject *resultobj = 0;
18477 wxDC *arg1 = (wxDC *) 0 ;
18478 int arg2 ;
18479 int result;
18480 void *argp1 = 0 ;
18481 int res1 = 0 ;
18482 int val2 ;
18483 int ecode2 = 0 ;
18484 PyObject * obj0 = 0 ;
18485 PyObject * obj1 = 0 ;
18486 char * kwnames[] = {
18487 (char *) "self",(char *) "y", NULL
18488 };
18489
18490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) SWIG_fail;
18491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18492 if (!SWIG_IsOK(res1)) {
18493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceY" "', expected argument " "1"" of type '" "wxDC const *""'");
18494 }
18495 arg1 = reinterpret_cast< wxDC * >(argp1);
18496 ecode2 = SWIG_AsVal_int(obj1, &val2);
18497 if (!SWIG_IsOK(ecode2)) {
18498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceY" "', expected argument " "2"" of type '" "int""'");
18499 }
18500 arg2 = static_cast< int >(val2);
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
18504 wxPyEndAllowThreads(__tstate);
18505 if (PyErr_Occurred()) SWIG_fail;
18506 }
18507 resultobj = SWIG_From_int(static_cast< int >(result));
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj = 0;
18516 wxDC *arg1 = (wxDC *) 0 ;
18517 int arg2 ;
18518 int result;
18519 void *argp1 = 0 ;
18520 int res1 = 0 ;
18521 int val2 ;
18522 int ecode2 = 0 ;
18523 PyObject * obj0 = 0 ;
18524 PyObject * obj1 = 0 ;
18525 char * kwnames[] = {
18526 (char *) "self",(char *) "x", NULL
18527 };
18528
18529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) SWIG_fail;
18530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18531 if (!SWIG_IsOK(res1)) {
18532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18533 }
18534 arg1 = reinterpret_cast< wxDC * >(argp1);
18535 ecode2 = SWIG_AsVal_int(obj1, &val2);
18536 if (!SWIG_IsOK(ecode2)) {
18537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "2"" of type '" "int""'");
18538 }
18539 arg2 = static_cast< int >(val2);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_From_int(static_cast< int >(result));
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj = 0;
18555 wxDC *arg1 = (wxDC *) 0 ;
18556 int arg2 ;
18557 int result;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 int val2 ;
18561 int ecode2 = 0 ;
18562 PyObject * obj0 = 0 ;
18563 PyObject * obj1 = 0 ;
18564 char * kwnames[] = {
18565 (char *) "self",(char *) "y", NULL
18566 };
18567
18568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) SWIG_fail;
18569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18570 if (!SWIG_IsOK(res1)) {
18571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18572 }
18573 arg1 = reinterpret_cast< wxDC * >(argp1);
18574 ecode2 = SWIG_AsVal_int(obj1, &val2);
18575 if (!SWIG_IsOK(ecode2)) {
18576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "2"" of type '" "int""'");
18577 }
18578 arg2 = static_cast< int >(val2);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_From_int(static_cast< int >(result));
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_DC_CanDrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18593 PyObject *resultobj = 0;
18594 wxDC *arg1 = (wxDC *) 0 ;
18595 bool result;
18596 void *argp1 = 0 ;
18597 int res1 = 0 ;
18598 PyObject *swig_obj[1] ;
18599
18600 if (!args) SWIG_fail;
18601 swig_obj[0] = args;
18602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18603 if (!SWIG_IsOK(res1)) {
18604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanDrawBitmap" "', expected argument " "1"" of type '" "wxDC const *""'");
18605 }
18606 arg1 = reinterpret_cast< wxDC * >(argp1);
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
18610 wxPyEndAllowThreads(__tstate);
18611 if (PyErr_Occurred()) SWIG_fail;
18612 }
18613 {
18614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18615 }
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_DC_CanGetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18623 PyObject *resultobj = 0;
18624 wxDC *arg1 = (wxDC *) 0 ;
18625 bool result;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 PyObject *swig_obj[1] ;
18629
18630 if (!args) SWIG_fail;
18631 swig_obj[0] = args;
18632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18633 if (!SWIG_IsOK(res1)) {
18634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanGetTextExtent" "', expected argument " "1"" of type '" "wxDC const *""'");
18635 }
18636 arg1 = reinterpret_cast< wxDC * >(argp1);
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 {
18644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18645 }
18646 return resultobj;
18647 fail:
18648 return NULL;
18649 }
18650
18651
18652 SWIGINTERN PyObject *_wrap_DC_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18653 PyObject *resultobj = 0;
18654 wxDC *arg1 = (wxDC *) 0 ;
18655 int result;
18656 void *argp1 = 0 ;
18657 int res1 = 0 ;
18658 PyObject *swig_obj[1] ;
18659
18660 if (!args) SWIG_fail;
18661 swig_obj[0] = args;
18662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18663 if (!SWIG_IsOK(res1)) {
18664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDepth" "', expected argument " "1"" of type '" "wxDC const *""'");
18665 }
18666 arg1 = reinterpret_cast< wxDC * >(argp1);
18667 {
18668 PyThreadState* __tstate = wxPyBeginAllowThreads();
18669 result = (int)((wxDC const *)arg1)->GetDepth();
18670 wxPyEndAllowThreads(__tstate);
18671 if (PyErr_Occurred()) SWIG_fail;
18672 }
18673 resultobj = SWIG_From_int(static_cast< int >(result));
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 SWIGINTERN PyObject *_wrap_DC_GetPPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18681 PyObject *resultobj = 0;
18682 wxDC *arg1 = (wxDC *) 0 ;
18683 wxSize result;
18684 void *argp1 = 0 ;
18685 int res1 = 0 ;
18686 PyObject *swig_obj[1] ;
18687
18688 if (!args) SWIG_fail;
18689 swig_obj[0] = args;
18690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18691 if (!SWIG_IsOK(res1)) {
18692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPPI" "', expected argument " "1"" of type '" "wxDC const *""'");
18693 }
18694 arg1 = reinterpret_cast< wxDC * >(argp1);
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 result = ((wxDC const *)arg1)->GetPPI();
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_DC_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxDC *arg1 = (wxDC *) 0 ;
18711 bool result;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Ok" "', expected argument " "1"" of type '" "wxDC const *""'");
18721 }
18722 arg1 = reinterpret_cast< wxDC * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (bool)((wxDC const *)arg1)->Ok();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 {
18730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18731 }
18732 return resultobj;
18733 fail:
18734 return NULL;
18735 }
18736
18737
18738 SWIGINTERN PyObject *_wrap_DC_GetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18739 PyObject *resultobj = 0;
18740 wxDC *arg1 = (wxDC *) 0 ;
18741 int result;
18742 void *argp1 = 0 ;
18743 int res1 = 0 ;
18744 PyObject *swig_obj[1] ;
18745
18746 if (!args) SWIG_fail;
18747 swig_obj[0] = args;
18748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18749 if (!SWIG_IsOK(res1)) {
18750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackgroundMode" "', expected argument " "1"" of type '" "wxDC const *""'");
18751 }
18752 arg1 = reinterpret_cast< wxDC * >(argp1);
18753 {
18754 PyThreadState* __tstate = wxPyBeginAllowThreads();
18755 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
18756 wxPyEndAllowThreads(__tstate);
18757 if (PyErr_Occurred()) SWIG_fail;
18758 }
18759 resultobj = SWIG_From_int(static_cast< int >(result));
18760 return resultobj;
18761 fail:
18762 return NULL;
18763 }
18764
18765
18766 SWIGINTERN PyObject *_wrap_DC_GetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18767 PyObject *resultobj = 0;
18768 wxDC *arg1 = (wxDC *) 0 ;
18769 wxBrush *result = 0 ;
18770 void *argp1 = 0 ;
18771 int res1 = 0 ;
18772 PyObject *swig_obj[1] ;
18773
18774 if (!args) SWIG_fail;
18775 swig_obj[0] = args;
18776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
18779 }
18780 arg1 = reinterpret_cast< wxDC * >(argp1);
18781 {
18782 PyThreadState* __tstate = wxPyBeginAllowThreads();
18783 {
18784 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
18785 result = (wxBrush *) &_result_ref;
18786 }
18787 wxPyEndAllowThreads(__tstate);
18788 if (PyErr_Occurred()) SWIG_fail;
18789 }
18790 {
18791 wxBrush* resultptr = new wxBrush(*result);
18792 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
18793 }
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_DC_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18801 PyObject *resultobj = 0;
18802 wxDC *arg1 = (wxDC *) 0 ;
18803 wxBrush *result = 0 ;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject *swig_obj[1] ;
18807
18808 if (!args) SWIG_fail;
18809 swig_obj[0] = args;
18810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18811 if (!SWIG_IsOK(res1)) {
18812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBrush" "', expected argument " "1"" of type '" "wxDC const *""'");
18813 }
18814 arg1 = reinterpret_cast< wxDC * >(argp1);
18815 {
18816 PyThreadState* __tstate = wxPyBeginAllowThreads();
18817 {
18818 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
18819 result = (wxBrush *) &_result_ref;
18820 }
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 {
18825 wxBrush* resultptr = new wxBrush(*result);
18826 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 SWIGINTERN PyObject *_wrap_DC_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18835 PyObject *resultobj = 0;
18836 wxDC *arg1 = (wxDC *) 0 ;
18837 wxFont *result = 0 ;
18838 void *argp1 = 0 ;
18839 int res1 = 0 ;
18840 PyObject *swig_obj[1] ;
18841
18842 if (!args) SWIG_fail;
18843 swig_obj[0] = args;
18844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18845 if (!SWIG_IsOK(res1)) {
18846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFont" "', expected argument " "1"" of type '" "wxDC const *""'");
18847 }
18848 arg1 = reinterpret_cast< wxDC * >(argp1);
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 {
18852 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
18853 result = (wxFont *) &_result_ref;
18854 }
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 {
18859 wxFont* resultptr = new wxFont(*result);
18860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
18861 }
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *_wrap_DC_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869 PyObject *resultobj = 0;
18870 wxDC *arg1 = (wxDC *) 0 ;
18871 wxPen *result = 0 ;
18872 void *argp1 = 0 ;
18873 int res1 = 0 ;
18874 PyObject *swig_obj[1] ;
18875
18876 if (!args) SWIG_fail;
18877 swig_obj[0] = args;
18878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPen" "', expected argument " "1"" of type '" "wxDC const *""'");
18881 }
18882 arg1 = reinterpret_cast< wxDC * >(argp1);
18883 {
18884 PyThreadState* __tstate = wxPyBeginAllowThreads();
18885 {
18886 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
18887 result = (wxPen *) &_result_ref;
18888 }
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 wxPen* resultptr = new wxPen(*result);
18894 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
18895 }
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 SWIGINTERN PyObject *_wrap_DC_GetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18903 PyObject *resultobj = 0;
18904 wxDC *arg1 = (wxDC *) 0 ;
18905 wxColour *result = 0 ;
18906 void *argp1 = 0 ;
18907 int res1 = 0 ;
18908 PyObject *swig_obj[1] ;
18909
18910 if (!args) SWIG_fail;
18911 swig_obj[0] = args;
18912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18913 if (!SWIG_IsOK(res1)) {
18914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
18915 }
18916 arg1 = reinterpret_cast< wxDC * >(argp1);
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 {
18920 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
18921 result = (wxColour *) &_result_ref;
18922 }
18923 wxPyEndAllowThreads(__tstate);
18924 if (PyErr_Occurred()) SWIG_fail;
18925 }
18926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
18927 return resultobj;
18928 fail:
18929 return NULL;
18930 }
18931
18932
18933 SWIGINTERN PyObject *_wrap_DC_GetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18934 PyObject *resultobj = 0;
18935 wxDC *arg1 = (wxDC *) 0 ;
18936 wxColour *result = 0 ;
18937 void *argp1 = 0 ;
18938 int res1 = 0 ;
18939 PyObject *swig_obj[1] ;
18940
18941 if (!args) SWIG_fail;
18942 swig_obj[0] = args;
18943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextForeground" "', expected argument " "1"" of type '" "wxDC const *""'");
18946 }
18947 arg1 = reinterpret_cast< wxDC * >(argp1);
18948 {
18949 PyThreadState* __tstate = wxPyBeginAllowThreads();
18950 {
18951 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
18952 result = (wxColour *) &_result_ref;
18953 }
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 SWIGINTERN PyObject *_wrap_DC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18965 PyObject *resultobj = 0;
18966 wxDC *arg1 = (wxDC *) 0 ;
18967 wxColour *arg2 = 0 ;
18968 void *argp1 = 0 ;
18969 int res1 = 0 ;
18970 wxColour temp2 ;
18971 PyObject * obj0 = 0 ;
18972 PyObject * obj1 = 0 ;
18973 char * kwnames[] = {
18974 (char *) "self",(char *) "colour", NULL
18975 };
18976
18977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18979 if (!SWIG_IsOK(res1)) {
18980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextForeground" "', expected argument " "1"" of type '" "wxDC *""'");
18981 }
18982 arg1 = reinterpret_cast< wxDC * >(argp1);
18983 {
18984 arg2 = &temp2;
18985 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18986 }
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 (arg1)->SetTextForeground((wxColour const &)*arg2);
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 resultobj = SWIG_Py_Void();
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_DC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19001 PyObject *resultobj = 0;
19002 wxDC *arg1 = (wxDC *) 0 ;
19003 wxColour *arg2 = 0 ;
19004 void *argp1 = 0 ;
19005 int res1 = 0 ;
19006 wxColour temp2 ;
19007 PyObject * obj0 = 0 ;
19008 PyObject * obj1 = 0 ;
19009 char * kwnames[] = {
19010 (char *) "self",(char *) "colour", NULL
19011 };
19012
19013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
19014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19015 if (!SWIG_IsOK(res1)) {
19016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextBackground" "', expected argument " "1"" of type '" "wxDC *""'");
19017 }
19018 arg1 = reinterpret_cast< wxDC * >(argp1);
19019 {
19020 arg2 = &temp2;
19021 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19022 }
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 (arg1)->SetTextBackground((wxColour const &)*arg2);
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 resultobj = SWIG_Py_Void();
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_DC_GetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19037 PyObject *resultobj = 0;
19038 wxDC *arg1 = (wxDC *) 0 ;
19039 int result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 PyObject *swig_obj[1] ;
19043
19044 if (!args) SWIG_fail;
19045 swig_obj[0] = args;
19046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMapMode" "', expected argument " "1"" of type '" "wxDC const *""'");
19049 }
19050 arg1 = reinterpret_cast< wxDC * >(argp1);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 result = (int)((wxDC const *)arg1)->GetMapMode();
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 resultobj = SWIG_From_int(static_cast< int >(result));
19058 return resultobj;
19059 fail:
19060 return NULL;
19061 }
19062
19063
19064 SWIGINTERN PyObject *_wrap_DC_SetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19065 PyObject *resultobj = 0;
19066 wxDC *arg1 = (wxDC *) 0 ;
19067 int arg2 ;
19068 void *argp1 = 0 ;
19069 int res1 = 0 ;
19070 int val2 ;
19071 int ecode2 = 0 ;
19072 PyObject * obj0 = 0 ;
19073 PyObject * obj1 = 0 ;
19074 char * kwnames[] = {
19075 (char *) "self",(char *) "mode", NULL
19076 };
19077
19078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) SWIG_fail;
19079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19080 if (!SWIG_IsOK(res1)) {
19081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetMapMode" "', expected argument " "1"" of type '" "wxDC *""'");
19082 }
19083 arg1 = reinterpret_cast< wxDC * >(argp1);
19084 ecode2 = SWIG_AsVal_int(obj1, &val2);
19085 if (!SWIG_IsOK(ecode2)) {
19086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetMapMode" "', expected argument " "2"" of type '" "int""'");
19087 }
19088 arg2 = static_cast< int >(val2);
19089 {
19090 PyThreadState* __tstate = wxPyBeginAllowThreads();
19091 (arg1)->SetMapMode(arg2);
19092 wxPyEndAllowThreads(__tstate);
19093 if (PyErr_Occurred()) SWIG_fail;
19094 }
19095 resultobj = SWIG_Py_Void();
19096 return resultobj;
19097 fail:
19098 return NULL;
19099 }
19100
19101
19102 SWIGINTERN PyObject *_wrap_DC_GetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19103 PyObject *resultobj = 0;
19104 wxDC *arg1 = (wxDC *) 0 ;
19105 double *arg2 = (double *) 0 ;
19106 double *arg3 = (double *) 0 ;
19107 void *argp1 = 0 ;
19108 int res1 = 0 ;
19109 double temp2 ;
19110 int res2 = SWIG_TMPOBJ ;
19111 double temp3 ;
19112 int res3 = SWIG_TMPOBJ ;
19113 PyObject *swig_obj[1] ;
19114
19115 arg2 = &temp2;
19116 arg3 = &temp3;
19117 if (!args) SWIG_fail;
19118 swig_obj[0] = args;
19119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19120 if (!SWIG_IsOK(res1)) {
19121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetUserScale" "', expected argument " "1"" of type '" "wxDC const *""'");
19122 }
19123 arg1 = reinterpret_cast< wxDC * >(argp1);
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 resultobj = SWIG_Py_Void();
19131 if (SWIG_IsTmpObj(res2)) {
19132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
19133 } else {
19134 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19136 }
19137 if (SWIG_IsTmpObj(res3)) {
19138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
19139 } else {
19140 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19142 }
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_DC_SetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = 0;
19151 wxDC *arg1 = (wxDC *) 0 ;
19152 double arg2 ;
19153 double arg3 ;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 double val2 ;
19157 int ecode2 = 0 ;
19158 double val3 ;
19159 int ecode3 = 0 ;
19160 PyObject * obj0 = 0 ;
19161 PyObject * obj1 = 0 ;
19162 PyObject * obj2 = 0 ;
19163 char * kwnames[] = {
19164 (char *) "self",(char *) "x",(char *) "y", NULL
19165 };
19166
19167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19169 if (!SWIG_IsOK(res1)) {
19170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetUserScale" "', expected argument " "1"" of type '" "wxDC *""'");
19171 }
19172 arg1 = reinterpret_cast< wxDC * >(argp1);
19173 ecode2 = SWIG_AsVal_double(obj1, &val2);
19174 if (!SWIG_IsOK(ecode2)) {
19175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetUserScale" "', expected argument " "2"" of type '" "double""'");
19176 }
19177 arg2 = static_cast< double >(val2);
19178 ecode3 = SWIG_AsVal_double(obj2, &val3);
19179 if (!SWIG_IsOK(ecode3)) {
19180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetUserScale" "', expected argument " "3"" of type '" "double""'");
19181 }
19182 arg3 = static_cast< double >(val3);
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 (arg1)->SetUserScale(arg2,arg3);
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 resultobj = SWIG_Py_Void();
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 SWIGINTERN PyObject *_wrap_DC_GetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19197 PyObject *resultobj = 0;
19198 wxDC *arg1 = (wxDC *) 0 ;
19199 double *arg2 = (double *) 0 ;
19200 double *arg3 = (double *) 0 ;
19201 void *argp1 = 0 ;
19202 int res1 = 0 ;
19203 double temp2 ;
19204 int res2 = SWIG_TMPOBJ ;
19205 double temp3 ;
19206 int res3 = SWIG_TMPOBJ ;
19207 PyObject *swig_obj[1] ;
19208
19209 arg2 = &temp2;
19210 arg3 = &temp3;
19211 if (!args) SWIG_fail;
19212 swig_obj[0] = args;
19213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
19216 }
19217 arg1 = reinterpret_cast< wxDC * >(argp1);
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 (arg1)->GetLogicalScale(arg2,arg3);
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 resultobj = SWIG_Py_Void();
19225 if (SWIG_IsTmpObj(res2)) {
19226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
19227 } else {
19228 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19230 }
19231 if (SWIG_IsTmpObj(res3)) {
19232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
19233 } else {
19234 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19236 }
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_DC_SetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = 0;
19245 wxDC *arg1 = (wxDC *) 0 ;
19246 double arg2 ;
19247 double arg3 ;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 double val2 ;
19251 int ecode2 = 0 ;
19252 double val3 ;
19253 int ecode3 = 0 ;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 PyObject * obj2 = 0 ;
19257 char * kwnames[] = {
19258 (char *) "self",(char *) "x",(char *) "y", NULL
19259 };
19260
19261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19263 if (!SWIG_IsOK(res1)) {
19264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
19265 }
19266 arg1 = reinterpret_cast< wxDC * >(argp1);
19267 ecode2 = SWIG_AsVal_double(obj1, &val2);
19268 if (!SWIG_IsOK(ecode2)) {
19269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalScale" "', expected argument " "2"" of type '" "double""'");
19270 }
19271 arg2 = static_cast< double >(val2);
19272 ecode3 = SWIG_AsVal_double(obj2, &val3);
19273 if (!SWIG_IsOK(ecode3)) {
19274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalScale" "', expected argument " "3"" of type '" "double""'");
19275 }
19276 arg3 = static_cast< double >(val3);
19277 {
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 (arg1)->SetLogicalScale(arg2,arg3);
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_Py_Void();
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_DC_GetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxDC *arg1 = (wxDC *) 0 ;
19293 wxPoint result;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 PyObject *swig_obj[1] ;
19297
19298 if (!args) SWIG_fail;
19299 swig_obj[0] = args;
19300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
19303 }
19304 arg1 = reinterpret_cast< wxDC * >(argp1);
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 result = ((wxDC const *)arg1)->GetLogicalOrigin();
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19319 PyObject *resultobj = 0;
19320 wxDC *arg1 = (wxDC *) 0 ;
19321 int *arg2 = (int *) 0 ;
19322 int *arg3 = (int *) 0 ;
19323 void *argp1 = 0 ;
19324 int res1 = 0 ;
19325 int temp2 ;
19326 int res2 = SWIG_TMPOBJ ;
19327 int temp3 ;
19328 int res3 = SWIG_TMPOBJ ;
19329 PyObject *swig_obj[1] ;
19330
19331 arg2 = &temp2;
19332 arg3 = &temp3;
19333 if (!args) SWIG_fail;
19334 swig_obj[0] = args;
19335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19336 if (!SWIG_IsOK(res1)) {
19337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
19338 }
19339 arg1 = reinterpret_cast< wxDC * >(argp1);
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_Py_Void();
19347 if (SWIG_IsTmpObj(res2)) {
19348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
19349 } else {
19350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19352 }
19353 if (SWIG_IsTmpObj(res3)) {
19354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
19355 } else {
19356 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19358 }
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 SWIGINTERN PyObject *_wrap_DC_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj = 0;
19367 wxDC *arg1 = (wxDC *) 0 ;
19368 int arg2 ;
19369 int arg3 ;
19370 void *argp1 = 0 ;
19371 int res1 = 0 ;
19372 int val2 ;
19373 int ecode2 = 0 ;
19374 int val3 ;
19375 int ecode3 = 0 ;
19376 PyObject * obj0 = 0 ;
19377 PyObject * obj1 = 0 ;
19378 PyObject * obj2 = 0 ;
19379 char * kwnames[] = {
19380 (char *) "self",(char *) "x",(char *) "y", NULL
19381 };
19382
19383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19385 if (!SWIG_IsOK(res1)) {
19386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19387 }
19388 arg1 = reinterpret_cast< wxDC * >(argp1);
19389 ecode2 = SWIG_AsVal_int(obj1, &val2);
19390 if (!SWIG_IsOK(ecode2)) {
19391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
19392 }
19393 arg2 = static_cast< int >(val2);
19394 ecode3 = SWIG_AsVal_int(obj2, &val3);
19395 if (!SWIG_IsOK(ecode3)) {
19396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
19397 }
19398 arg3 = static_cast< int >(val3);
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 (arg1)->SetLogicalOrigin(arg2,arg3);
19402 wxPyEndAllowThreads(__tstate);
19403 if (PyErr_Occurred()) SWIG_fail;
19404 }
19405 resultobj = SWIG_Py_Void();
19406 return resultobj;
19407 fail:
19408 return NULL;
19409 }
19410
19411
19412 SWIGINTERN PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19413 PyObject *resultobj = 0;
19414 wxDC *arg1 = (wxDC *) 0 ;
19415 wxPoint *arg2 = 0 ;
19416 void *argp1 = 0 ;
19417 int res1 = 0 ;
19418 wxPoint temp2 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char * kwnames[] = {
19422 (char *) "self",(char *) "point", NULL
19423 };
19424
19425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
19426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19429 }
19430 arg1 = reinterpret_cast< wxDC * >(argp1);
19431 {
19432 arg2 = &temp2;
19433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19434 }
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_Py_Void();
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_DC_GetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 PyObject *resultobj = 0;
19450 wxDC *arg1 = (wxDC *) 0 ;
19451 wxPoint result;
19452 void *argp1 = 0 ;
19453 int res1 = 0 ;
19454 PyObject *swig_obj[1] ;
19455
19456 if (!args) SWIG_fail;
19457 swig_obj[0] = args;
19458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19459 if (!SWIG_IsOK(res1)) {
19460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
19461 }
19462 arg1 = reinterpret_cast< wxDC * >(argp1);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = ((wxDC const *)arg1)->GetDeviceOrigin();
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 wxDC *arg1 = (wxDC *) 0 ;
19479 int *arg2 = (int *) 0 ;
19480 int *arg3 = (int *) 0 ;
19481 void *argp1 = 0 ;
19482 int res1 = 0 ;
19483 int temp2 ;
19484 int res2 = SWIG_TMPOBJ ;
19485 int temp3 ;
19486 int res3 = SWIG_TMPOBJ ;
19487 PyObject *swig_obj[1] ;
19488
19489 arg2 = &temp2;
19490 arg3 = &temp3;
19491 if (!args) SWIG_fail;
19492 swig_obj[0] = args;
19493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19494 if (!SWIG_IsOK(res1)) {
19495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
19496 }
19497 arg1 = reinterpret_cast< wxDC * >(argp1);
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_Py_Void();
19505 if (SWIG_IsTmpObj(res2)) {
19506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
19507 } else {
19508 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19510 }
19511 if (SWIG_IsTmpObj(res3)) {
19512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
19513 } else {
19514 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19516 }
19517 return resultobj;
19518 fail:
19519 return NULL;
19520 }
19521
19522
19523 SWIGINTERN PyObject *_wrap_DC_SetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19524 PyObject *resultobj = 0;
19525 wxDC *arg1 = (wxDC *) 0 ;
19526 int arg2 ;
19527 int arg3 ;
19528 void *argp1 = 0 ;
19529 int res1 = 0 ;
19530 int val2 ;
19531 int ecode2 = 0 ;
19532 int val3 ;
19533 int ecode3 = 0 ;
19534 PyObject * obj0 = 0 ;
19535 PyObject * obj1 = 0 ;
19536 PyObject * obj2 = 0 ;
19537 char * kwnames[] = {
19538 (char *) "self",(char *) "x",(char *) "y", NULL
19539 };
19540
19541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19545 }
19546 arg1 = reinterpret_cast< wxDC * >(argp1);
19547 ecode2 = SWIG_AsVal_int(obj1, &val2);
19548 if (!SWIG_IsOK(ecode2)) {
19549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetDeviceOrigin" "', expected argument " "2"" of type '" "int""'");
19550 }
19551 arg2 = static_cast< int >(val2);
19552 ecode3 = SWIG_AsVal_int(obj2, &val3);
19553 if (!SWIG_IsOK(ecode3)) {
19554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetDeviceOrigin" "', expected argument " "3"" of type '" "int""'");
19555 }
19556 arg3 = static_cast< int >(val3);
19557 {
19558 PyThreadState* __tstate = wxPyBeginAllowThreads();
19559 (arg1)->SetDeviceOrigin(arg2,arg3);
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 resultobj = SWIG_Py_Void();
19564 return resultobj;
19565 fail:
19566 return NULL;
19567 }
19568
19569
19570 SWIGINTERN PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19571 PyObject *resultobj = 0;
19572 wxDC *arg1 = (wxDC *) 0 ;
19573 wxPoint *arg2 = 0 ;
19574 void *argp1 = 0 ;
19575 int res1 = 0 ;
19576 wxPoint temp2 ;
19577 PyObject * obj0 = 0 ;
19578 PyObject * obj1 = 0 ;
19579 char * kwnames[] = {
19580 (char *) "self",(char *) "point", NULL
19581 };
19582
19583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
19584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19585 if (!SWIG_IsOK(res1)) {
19586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19587 }
19588 arg1 = reinterpret_cast< wxDC * >(argp1);
19589 {
19590 arg2 = &temp2;
19591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19592 }
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_Py_Void();
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 SWIGINTERN PyObject *_wrap_DC_SetAxisOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19607 PyObject *resultobj = 0;
19608 wxDC *arg1 = (wxDC *) 0 ;
19609 bool arg2 ;
19610 bool arg3 ;
19611 void *argp1 = 0 ;
19612 int res1 = 0 ;
19613 bool val2 ;
19614 int ecode2 = 0 ;
19615 bool val3 ;
19616 int ecode3 = 0 ;
19617 PyObject * obj0 = 0 ;
19618 PyObject * obj1 = 0 ;
19619 PyObject * obj2 = 0 ;
19620 char * kwnames[] = {
19621 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
19622 };
19623
19624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetAxisOrientation" "', expected argument " "1"" of type '" "wxDC *""'");
19628 }
19629 arg1 = reinterpret_cast< wxDC * >(argp1);
19630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19631 if (!SWIG_IsOK(ecode2)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetAxisOrientation" "', expected argument " "2"" of type '" "bool""'");
19633 }
19634 arg2 = static_cast< bool >(val2);
19635 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19636 if (!SWIG_IsOK(ecode3)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetAxisOrientation" "', expected argument " "3"" of type '" "bool""'");
19638 }
19639 arg3 = static_cast< bool >(val3);
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 (arg1)->SetAxisOrientation(arg2,arg3);
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_Py_Void();
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_DC_GetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *resultobj = 0;
19655 wxDC *arg1 = (wxDC *) 0 ;
19656 int result;
19657 void *argp1 = 0 ;
19658 int res1 = 0 ;
19659 PyObject *swig_obj[1] ;
19660
19661 if (!args) SWIG_fail;
19662 swig_obj[0] = args;
19663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19664 if (!SWIG_IsOK(res1)) {
19665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalFunction" "', expected argument " "1"" of type '" "wxDC const *""'");
19666 }
19667 arg1 = reinterpret_cast< wxDC * >(argp1);
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 resultobj = SWIG_From_int(static_cast< int >(result));
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 SWIGINTERN PyObject *_wrap_DC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19682 PyObject *resultobj = 0;
19683 wxDC *arg1 = (wxDC *) 0 ;
19684 int arg2 ;
19685 void *argp1 = 0 ;
19686 int res1 = 0 ;
19687 int val2 ;
19688 int ecode2 = 0 ;
19689 PyObject * obj0 = 0 ;
19690 PyObject * obj1 = 0 ;
19691 char * kwnames[] = {
19692 (char *) "self",(char *) "function", NULL
19693 };
19694
19695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
19696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19697 if (!SWIG_IsOK(res1)) {
19698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxDC *""'");
19699 }
19700 arg1 = reinterpret_cast< wxDC * >(argp1);
19701 ecode2 = SWIG_AsVal_int(obj1, &val2);
19702 if (!SWIG_IsOK(ecode2)) {
19703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
19704 }
19705 arg2 = static_cast< int >(val2);
19706 {
19707 PyThreadState* __tstate = wxPyBeginAllowThreads();
19708 (arg1)->SetLogicalFunction(arg2);
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 resultobj = SWIG_Py_Void();
19713 return resultobj;
19714 fail:
19715 return NULL;
19716 }
19717
19718
19719 SWIGINTERN PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19720 PyObject *resultobj = 0;
19721 wxDC *arg1 = (wxDC *) 0 ;
19722 void *argp1 = 0 ;
19723 int res1 = 0 ;
19724 PyObject *swig_obj[1] ;
19725
19726 if (!args) SWIG_fail;
19727 swig_obj[0] = args;
19728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19729 if (!SWIG_IsOK(res1)) {
19730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ComputeScaleAndOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19731 }
19732 arg1 = reinterpret_cast< wxDC * >(argp1);
19733 {
19734 PyThreadState* __tstate = wxPyBeginAllowThreads();
19735 (arg1)->ComputeScaleAndOrigin();
19736 wxPyEndAllowThreads(__tstate);
19737 if (PyErr_Occurred()) SWIG_fail;
19738 }
19739 resultobj = SWIG_Py_Void();
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj = 0;
19748 wxDC *arg1 = (wxDC *) 0 ;
19749 int arg2 ;
19750 int arg3 ;
19751 void *argp1 = 0 ;
19752 int res1 = 0 ;
19753 int val2 ;
19754 int ecode2 = 0 ;
19755 int val3 ;
19756 int ecode3 = 0 ;
19757 PyObject * obj0 = 0 ;
19758 PyObject * obj1 = 0 ;
19759 PyObject * obj2 = 0 ;
19760 char * kwnames[] = {
19761 (char *) "self",(char *) "x",(char *) "y", NULL
19762 };
19763
19764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19766 if (!SWIG_IsOK(res1)) {
19767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
19768 }
19769 arg1 = reinterpret_cast< wxDC * >(argp1);
19770 ecode2 = SWIG_AsVal_int(obj1, &val2);
19771 if (!SWIG_IsOK(ecode2)) {
19772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CalcBoundingBox" "', expected argument " "2"" of type '" "int""'");
19773 }
19774 arg2 = static_cast< int >(val2);
19775 ecode3 = SWIG_AsVal_int(obj2, &val3);
19776 if (!SWIG_IsOK(ecode3)) {
19777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CalcBoundingBox" "', expected argument " "3"" of type '" "int""'");
19778 }
19779 arg3 = static_cast< int >(val3);
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 (arg1)->CalcBoundingBox(arg2,arg3);
19783 wxPyEndAllowThreads(__tstate);
19784 if (PyErr_Occurred()) SWIG_fail;
19785 }
19786 resultobj = SWIG_Py_Void();
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19794 PyObject *resultobj = 0;
19795 wxDC *arg1 = (wxDC *) 0 ;
19796 wxPoint *arg2 = 0 ;
19797 void *argp1 = 0 ;
19798 int res1 = 0 ;
19799 wxPoint temp2 ;
19800 PyObject * obj0 = 0 ;
19801 PyObject * obj1 = 0 ;
19802 char * kwnames[] = {
19803 (char *) "self",(char *) "point", NULL
19804 };
19805
19806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) SWIG_fail;
19807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19808 if (!SWIG_IsOK(res1)) {
19809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBoxPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19810 }
19811 arg1 = reinterpret_cast< wxDC * >(argp1);
19812 {
19813 arg2 = &temp2;
19814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19815 }
19816 {
19817 PyThreadState* __tstate = wxPyBeginAllowThreads();
19818 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
19819 wxPyEndAllowThreads(__tstate);
19820 if (PyErr_Occurred()) SWIG_fail;
19821 }
19822 resultobj = SWIG_Py_Void();
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 SWIGINTERN PyObject *_wrap_DC_ResetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19830 PyObject *resultobj = 0;
19831 wxDC *arg1 = (wxDC *) 0 ;
19832 void *argp1 = 0 ;
19833 int res1 = 0 ;
19834 PyObject *swig_obj[1] ;
19835
19836 if (!args) SWIG_fail;
19837 swig_obj[0] = args;
19838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ResetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
19841 }
19842 arg1 = reinterpret_cast< wxDC * >(argp1);
19843 {
19844 PyThreadState* __tstate = wxPyBeginAllowThreads();
19845 (arg1)->ResetBoundingBox();
19846 wxPyEndAllowThreads(__tstate);
19847 if (PyErr_Occurred()) SWIG_fail;
19848 }
19849 resultobj = SWIG_Py_Void();
19850 return resultobj;
19851 fail:
19852 return NULL;
19853 }
19854
19855
19856 SWIGINTERN PyObject *_wrap_DC_MinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19857 PyObject *resultobj = 0;
19858 wxDC *arg1 = (wxDC *) 0 ;
19859 int result;
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_MinX" "', expected argument " "1"" of type '" "wxDC const *""'");
19869 }
19870 arg1 = reinterpret_cast< wxDC * >(argp1);
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (int)((wxDC const *)arg1)->MinX();
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 resultobj = SWIG_From_int(static_cast< int >(result));
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_DC_MaxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 PyObject *resultobj = 0;
19886 wxDC *arg1 = (wxDC *) 0 ;
19887 int result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 PyObject *swig_obj[1] ;
19891
19892 if (!args) SWIG_fail;
19893 swig_obj[0] = args;
19894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19895 if (!SWIG_IsOK(res1)) {
19896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxX" "', expected argument " "1"" of type '" "wxDC const *""'");
19897 }
19898 arg1 = reinterpret_cast< wxDC * >(argp1);
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (int)((wxDC const *)arg1)->MaxX();
19902 wxPyEndAllowThreads(__tstate);
19903 if (PyErr_Occurred()) SWIG_fail;
19904 }
19905 resultobj = SWIG_From_int(static_cast< int >(result));
19906 return resultobj;
19907 fail:
19908 return NULL;
19909 }
19910
19911
19912 SWIGINTERN PyObject *_wrap_DC_MinY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19913 PyObject *resultobj = 0;
19914 wxDC *arg1 = (wxDC *) 0 ;
19915 int result;
19916 void *argp1 = 0 ;
19917 int res1 = 0 ;
19918 PyObject *swig_obj[1] ;
19919
19920 if (!args) SWIG_fail;
19921 swig_obj[0] = args;
19922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19923 if (!SWIG_IsOK(res1)) {
19924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinY" "', expected argument " "1"" of type '" "wxDC const *""'");
19925 }
19926 arg1 = reinterpret_cast< wxDC * >(argp1);
19927 {
19928 PyThreadState* __tstate = wxPyBeginAllowThreads();
19929 result = (int)((wxDC const *)arg1)->MinY();
19930 wxPyEndAllowThreads(__tstate);
19931 if (PyErr_Occurred()) SWIG_fail;
19932 }
19933 resultobj = SWIG_From_int(static_cast< int >(result));
19934 return resultobj;
19935 fail:
19936 return NULL;
19937 }
19938
19939
19940 SWIGINTERN PyObject *_wrap_DC_MaxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19941 PyObject *resultobj = 0;
19942 wxDC *arg1 = (wxDC *) 0 ;
19943 int result;
19944 void *argp1 = 0 ;
19945 int res1 = 0 ;
19946 PyObject *swig_obj[1] ;
19947
19948 if (!args) SWIG_fail;
19949 swig_obj[0] = args;
19950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19951 if (!SWIG_IsOK(res1)) {
19952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxY" "', expected argument " "1"" of type '" "wxDC const *""'");
19953 }
19954 arg1 = reinterpret_cast< wxDC * >(argp1);
19955 {
19956 PyThreadState* __tstate = wxPyBeginAllowThreads();
19957 result = (int)((wxDC const *)arg1)->MaxY();
19958 wxPyEndAllowThreads(__tstate);
19959 if (PyErr_Occurred()) SWIG_fail;
19960 }
19961 resultobj = SWIG_From_int(static_cast< int >(result));
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 SWIGINTERN PyObject *_wrap_DC_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19969 PyObject *resultobj = 0;
19970 wxDC *arg1 = (wxDC *) 0 ;
19971 int *arg2 = (int *) 0 ;
19972 int *arg3 = (int *) 0 ;
19973 int *arg4 = (int *) 0 ;
19974 int *arg5 = (int *) 0 ;
19975 void *argp1 = 0 ;
19976 int res1 = 0 ;
19977 int temp2 ;
19978 int res2 = SWIG_TMPOBJ ;
19979 int temp3 ;
19980 int res3 = SWIG_TMPOBJ ;
19981 int temp4 ;
19982 int res4 = SWIG_TMPOBJ ;
19983 int temp5 ;
19984 int res5 = SWIG_TMPOBJ ;
19985 PyObject *swig_obj[1] ;
19986
19987 arg2 = &temp2;
19988 arg3 = &temp3;
19989 arg4 = &temp4;
19990 arg5 = &temp5;
19991 if (!args) SWIG_fail;
19992 swig_obj[0] = args;
19993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
19996 }
19997 arg1 = reinterpret_cast< wxDC * >(argp1);
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_Py_Void();
20005 if (SWIG_IsTmpObj(res2)) {
20006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20007 } else {
20008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20010 }
20011 if (SWIG_IsTmpObj(res3)) {
20012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20013 } else {
20014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20016 }
20017 if (SWIG_IsTmpObj(res4)) {
20018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20019 } else {
20020 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20022 }
20023 if (SWIG_IsTmpObj(res5)) {
20024 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20025 } else {
20026 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 SWIGINTERN PyObject *_wrap_DC__DrawPointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20036 PyObject *resultobj = 0;
20037 wxDC *arg1 = (wxDC *) 0 ;
20038 PyObject *arg2 = (PyObject *) 0 ;
20039 PyObject *arg3 = (PyObject *) 0 ;
20040 PyObject *arg4 = (PyObject *) 0 ;
20041 PyObject *result = 0 ;
20042 void *argp1 = 0 ;
20043 int res1 = 0 ;
20044 PyObject * obj0 = 0 ;
20045 PyObject * obj1 = 0 ;
20046 PyObject * obj2 = 0 ;
20047 PyObject * obj3 = 0 ;
20048 char * kwnames[] = {
20049 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20050 };
20051
20052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20054 if (!SWIG_IsOK(res1)) {
20055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPointList" "', expected argument " "1"" of type '" "wxDC *""'");
20056 }
20057 arg1 = reinterpret_cast< wxDC * >(argp1);
20058 arg2 = obj1;
20059 arg3 = obj2;
20060 arg4 = obj3;
20061 {
20062 PyThreadState* __tstate = wxPyBeginAllowThreads();
20063 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 resultobj = result;
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_DC__DrawLineList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj = 0;
20076 wxDC *arg1 = (wxDC *) 0 ;
20077 PyObject *arg2 = (PyObject *) 0 ;
20078 PyObject *arg3 = (PyObject *) 0 ;
20079 PyObject *arg4 = (PyObject *) 0 ;
20080 PyObject *result = 0 ;
20081 void *argp1 = 0 ;
20082 int res1 = 0 ;
20083 PyObject * obj0 = 0 ;
20084 PyObject * obj1 = 0 ;
20085 PyObject * obj2 = 0 ;
20086 PyObject * obj3 = 0 ;
20087 char * kwnames[] = {
20088 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20089 };
20090
20091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20093 if (!SWIG_IsOK(res1)) {
20094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawLineList" "', expected argument " "1"" of type '" "wxDC *""'");
20095 }
20096 arg1 = reinterpret_cast< wxDC * >(argp1);
20097 arg2 = obj1;
20098 arg3 = obj2;
20099 arg4 = obj3;
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = result;
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_DC__DrawRectangleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj = 0;
20115 wxDC *arg1 = (wxDC *) 0 ;
20116 PyObject *arg2 = (PyObject *) 0 ;
20117 PyObject *arg3 = (PyObject *) 0 ;
20118 PyObject *arg4 = (PyObject *) 0 ;
20119 PyObject *result = 0 ;
20120 void *argp1 = 0 ;
20121 int res1 = 0 ;
20122 PyObject * obj0 = 0 ;
20123 PyObject * obj1 = 0 ;
20124 PyObject * obj2 = 0 ;
20125 PyObject * obj3 = 0 ;
20126 char * kwnames[] = {
20127 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20128 };
20129
20130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20132 if (!SWIG_IsOK(res1)) {
20133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawRectangleList" "', expected argument " "1"" of type '" "wxDC *""'");
20134 }
20135 arg1 = reinterpret_cast< wxDC * >(argp1);
20136 arg2 = obj1;
20137 arg3 = obj2;
20138 arg4 = obj3;
20139 {
20140 PyThreadState* __tstate = wxPyBeginAllowThreads();
20141 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
20142 wxPyEndAllowThreads(__tstate);
20143 if (PyErr_Occurred()) SWIG_fail;
20144 }
20145 resultobj = result;
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_DC__DrawEllipseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20153 PyObject *resultobj = 0;
20154 wxDC *arg1 = (wxDC *) 0 ;
20155 PyObject *arg2 = (PyObject *) 0 ;
20156 PyObject *arg3 = (PyObject *) 0 ;
20157 PyObject *arg4 = (PyObject *) 0 ;
20158 PyObject *result = 0 ;
20159 void *argp1 = 0 ;
20160 int res1 = 0 ;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 PyObject * obj2 = 0 ;
20164 PyObject * obj3 = 0 ;
20165 char * kwnames[] = {
20166 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20167 };
20168
20169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20171 if (!SWIG_IsOK(res1)) {
20172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawEllipseList" "', expected argument " "1"" of type '" "wxDC *""'");
20173 }
20174 arg1 = reinterpret_cast< wxDC * >(argp1);
20175 arg2 = obj1;
20176 arg3 = obj2;
20177 arg4 = obj3;
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 resultobj = result;
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 SWIGINTERN PyObject *_wrap_DC__DrawPolygonList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj = 0;
20193 wxDC *arg1 = (wxDC *) 0 ;
20194 PyObject *arg2 = (PyObject *) 0 ;
20195 PyObject *arg3 = (PyObject *) 0 ;
20196 PyObject *arg4 = (PyObject *) 0 ;
20197 PyObject *result = 0 ;
20198 void *argp1 = 0 ;
20199 int res1 = 0 ;
20200 PyObject * obj0 = 0 ;
20201 PyObject * obj1 = 0 ;
20202 PyObject * obj2 = 0 ;
20203 PyObject * obj3 = 0 ;
20204 char * kwnames[] = {
20205 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20206 };
20207
20208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20210 if (!SWIG_IsOK(res1)) {
20211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPolygonList" "', expected argument " "1"" of type '" "wxDC *""'");
20212 }
20213 arg1 = reinterpret_cast< wxDC * >(argp1);
20214 arg2 = obj1;
20215 arg3 = obj2;
20216 arg4 = obj3;
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 resultobj = result;
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 SWIGINTERN PyObject *_wrap_DC__DrawTextList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20231 PyObject *resultobj = 0;
20232 wxDC *arg1 = (wxDC *) 0 ;
20233 PyObject *arg2 = (PyObject *) 0 ;
20234 PyObject *arg3 = (PyObject *) 0 ;
20235 PyObject *arg4 = (PyObject *) 0 ;
20236 PyObject *arg5 = (PyObject *) 0 ;
20237 PyObject *result = 0 ;
20238 void *argp1 = 0 ;
20239 int res1 = 0 ;
20240 PyObject * obj0 = 0 ;
20241 PyObject * obj1 = 0 ;
20242 PyObject * obj2 = 0 ;
20243 PyObject * obj3 = 0 ;
20244 PyObject * obj4 = 0 ;
20245 char * kwnames[] = {
20246 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
20247 };
20248
20249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20251 if (!SWIG_IsOK(res1)) {
20252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawTextList" "', expected argument " "1"" of type '" "wxDC *""'");
20253 }
20254 arg1 = reinterpret_cast< wxDC * >(argp1);
20255 arg2 = obj1;
20256 arg3 = obj2;
20257 arg4 = obj3;
20258 arg5 = obj4;
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 resultobj = result;
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 SWIGINTERN PyObject *DC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *obj;
20274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20275 SWIG_TypeNewClientData(SWIGTYPE_p_wxDC, SWIG_NewClientData(obj));
20276 return SWIG_Py_Void();
20277 }
20278
20279 SWIGINTERN PyObject *_wrap_new_MemoryDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20280 PyObject *resultobj = 0;
20281 wxMemoryDC *result = 0 ;
20282
20283 if (!SWIG_Python_UnpackTuple(args,"new_MemoryDC",0,0,0)) SWIG_fail;
20284 {
20285 if (!wxPyCheckForApp()) SWIG_fail;
20286 PyThreadState* __tstate = wxPyBeginAllowThreads();
20287 result = (wxMemoryDC *)new wxMemoryDC();
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_NEW | 0 );
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 SWIGINTERN PyObject *_wrap_new_MemoryDCFromDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj = 0;
20300 wxDC *arg1 = (wxDC *) 0 ;
20301 wxMemoryDC *result = 0 ;
20302 void *argp1 = 0 ;
20303 int res1 = 0 ;
20304 PyObject * obj0 = 0 ;
20305 char * kwnames[] = {
20306 (char *) "oldDC", NULL
20307 };
20308
20309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) SWIG_fail;
20310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20311 if (!SWIG_IsOK(res1)) {
20312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryDCFromDC" "', expected argument " "1"" of type '" "wxDC *""'");
20313 }
20314 arg1 = reinterpret_cast< wxDC * >(argp1);
20315 {
20316 if (!wxPyCheckForApp()) SWIG_fail;
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 result = (wxMemoryDC *)new wxMemoryDC(arg1);
20319 wxPyEndAllowThreads(__tstate);
20320 if (PyErr_Occurred()) SWIG_fail;
20321 }
20322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_OWN | 0 );
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_MemoryDC_SelectObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj = 0;
20331 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
20332 wxBitmap *arg2 = 0 ;
20333 void *argp1 = 0 ;
20334 int res1 = 0 ;
20335 void *argp2 = 0 ;
20336 int res2 = 0 ;
20337 PyObject * obj0 = 0 ;
20338 PyObject * obj1 = 0 ;
20339 char * kwnames[] = {
20340 (char *) "self",(char *) "bitmap", NULL
20341 };
20342
20343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) SWIG_fail;
20344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryDC, 0 | 0 );
20345 if (!SWIG_IsOK(res1)) {
20346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryDC_SelectObject" "', expected argument " "1"" of type '" "wxMemoryDC *""'");
20347 }
20348 arg1 = reinterpret_cast< wxMemoryDC * >(argp1);
20349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20350 if (!SWIG_IsOK(res2)) {
20351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20352 }
20353 if (!argp2) {
20354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20355 }
20356 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 (arg1)->SelectObject((wxBitmap const &)*arg2);
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 resultobj = SWIG_Py_Void();
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 SWIGINTERN PyObject *MemoryDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 PyObject *obj;
20372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20373 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryDC, SWIG_NewClientData(obj));
20374 return SWIG_Py_Void();
20375 }
20376
20377 SWIGINTERN PyObject *MemoryDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20378 return SWIG_Python_InitShadowInstance(args);
20379 }
20380
20381 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
20382 PyObject *resultobj = 0;
20383 wxDC *arg1 = (wxDC *) 0 ;
20384 wxBitmap const &arg2_defvalue = wxNullBitmap ;
20385 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
20386 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20387 wxBufferedDC *result = 0 ;
20388 void *argp1 = 0 ;
20389 int res1 = 0 ;
20390 void *argp2 = 0 ;
20391 int res2 = 0 ;
20392 int val3 ;
20393 int ecode3 = 0 ;
20394
20395 if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
20396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20397 if (!SWIG_IsOK(res1)) {
20398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
20399 }
20400 arg1 = reinterpret_cast< wxDC * >(argp1);
20401 if (swig_obj[1]) {
20402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20403 if (!SWIG_IsOK(res2)) {
20404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20405 }
20406 if (!argp2) {
20407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20408 }
20409 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20410 }
20411 if (swig_obj[2]) {
20412 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20413 if (!SWIG_IsOK(ecode3)) {
20414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
20415 }
20416 arg3 = static_cast< int >(val3);
20417 }
20418 {
20419 if (!wxPyCheckForApp()) SWIG_fail;
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
20433 PyObject *resultobj = 0;
20434 wxDC *arg1 = (wxDC *) 0 ;
20435 wxSize *arg2 = 0 ;
20436 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20437 wxBufferedDC *result = 0 ;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 wxSize temp2 ;
20441 int val3 ;
20442 int ecode3 = 0 ;
20443
20444 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
20445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20446 if (!SWIG_IsOK(res1)) {
20447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
20448 }
20449 arg1 = reinterpret_cast< wxDC * >(argp1);
20450 {
20451 arg2 = &temp2;
20452 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
20453 }
20454 if (swig_obj[2]) {
20455 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20456 if (!SWIG_IsOK(ecode3)) {
20457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
20458 }
20459 arg3 = static_cast< int >(val3);
20460 }
20461 {
20462 if (!wxPyCheckForApp()) SWIG_fail;
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
20476 int argc;
20477 PyObject *argv[4];
20478
20479 if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferedDC",0,3,argv))) SWIG_fail;
20480 --argc;
20481 if ((argc >= 1) && (argc <= 3)) {
20482 int _v = 0;
20483 if (argc > 1) {
20484 {
20485 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxBitmap, 0);
20486 _v = SWIG_CheckState(res);
20487 }
20488 if (!_v) goto check_1;
20489 }
20490 return _wrap_new_BufferedDC__SWIG_0(self, argc, argv);
20491 }
20492 check_1:
20493
20494 if ((argc >= 2) && (argc <= 3)) {
20495 return _wrap_new_BufferedDC__SWIG_1(self, argc, argv);
20496 }
20497
20498 fail:
20499 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_delete_BufferedDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20505 PyObject *resultobj = 0;
20506 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
20507 void *argp1 = 0 ;
20508 int res1 = 0 ;
20509 PyObject *swig_obj[1] ;
20510
20511 if (!args) SWIG_fail;
20512 swig_obj[0] = args;
20513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_DISOWN | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferedDC" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
20516 }
20517 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 delete arg1;
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 resultobj = SWIG_Py_Void();
20526 return resultobj;
20527 fail:
20528 return NULL;
20529 }
20530
20531
20532 SWIGINTERN PyObject *_wrap_BufferedDC_UnMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20533 PyObject *resultobj = 0;
20534 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
20535 void *argp1 = 0 ;
20536 int res1 = 0 ;
20537 PyObject *swig_obj[1] ;
20538
20539 if (!args) SWIG_fail;
20540 swig_obj[0] = args;
20541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, 0 | 0 );
20542 if (!SWIG_IsOK(res1)) {
20543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferedDC_UnMask" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
20544 }
20545 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 (arg1)->UnMask();
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 resultobj = SWIG_Py_Void();
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 SWIGINTERN PyObject *BufferedDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20560 PyObject *obj;
20561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20562 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedDC, SWIG_NewClientData(obj));
20563 return SWIG_Py_Void();
20564 }
20565
20566 SWIGINTERN PyObject *BufferedDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20567 return SWIG_Python_InitShadowInstance(args);
20568 }
20569
20570 SWIGINTERN PyObject *_wrap_new_BufferedPaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj = 0;
20572 wxWindow *arg1 = (wxWindow *) 0 ;
20573 wxBitmap const &arg2_defvalue = wxNullBitmap ;
20574 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
20575 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20576 wxBufferedPaintDC *result = 0 ;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 void *argp2 = 0 ;
20580 int res2 = 0 ;
20581 int val3 ;
20582 int ecode3 = 0 ;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 PyObject * obj2 = 0 ;
20586 char * kwnames[] = {
20587 (char *) "window",(char *) "buffer",(char *) "style", NULL
20588 };
20589
20590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedPaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20594 }
20595 arg1 = reinterpret_cast< wxWindow * >(argp1);
20596 if (obj1) {
20597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20598 if (!SWIG_IsOK(res2)) {
20599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20600 }
20601 if (!argp2) {
20602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20603 }
20604 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20605 }
20606 if (obj2) {
20607 ecode3 = SWIG_AsVal_int(obj2, &val3);
20608 if (!SWIG_IsOK(ecode3)) {
20609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedPaintDC" "', expected argument " "3"" of type '" "int""'");
20610 }
20611 arg3 = static_cast< int >(val3);
20612 }
20613 {
20614 if (!wxPyCheckForApp()) SWIG_fail;
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedPaintDC, SWIG_POINTER_NEW | 0 );
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *BufferedPaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20628 PyObject *obj;
20629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20630 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedPaintDC, SWIG_NewClientData(obj));
20631 return SWIG_Py_Void();
20632 }
20633
20634 SWIGINTERN PyObject *BufferedPaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20635 return SWIG_Python_InitShadowInstance(args);
20636 }
20637
20638 SWIGINTERN PyObject *_wrap_new_ScreenDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20639 PyObject *resultobj = 0;
20640 wxScreenDC *result = 0 ;
20641
20642 if (!SWIG_Python_UnpackTuple(args,"new_ScreenDC",0,0,0)) SWIG_fail;
20643 {
20644 if (!wxPyCheckForApp()) SWIG_fail;
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (wxScreenDC *)new wxScreenDC();
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScreenDC, SWIG_POINTER_NEW | 0 );
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj = 0;
20659 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20660 wxWindow *arg2 = (wxWindow *) 0 ;
20661 bool result;
20662 void *argp1 = 0 ;
20663 int res1 = 0 ;
20664 void *argp2 = 0 ;
20665 int res2 = 0 ;
20666 PyObject * obj0 = 0 ;
20667 PyObject * obj1 = 0 ;
20668 char * kwnames[] = {
20669 (char *) "self",(char *) "window", NULL
20670 };
20671
20672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) SWIG_fail;
20673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20676 }
20677 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
20679 if (!SWIG_IsOK(res2)) {
20680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "2"" of type '" "wxWindow *""'");
20681 }
20682 arg2 = reinterpret_cast< wxWindow * >(argp2);
20683 {
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 result = (bool)(arg1)->StartDrawingOnTop(arg2);
20686 wxPyEndAllowThreads(__tstate);
20687 if (PyErr_Occurred()) SWIG_fail;
20688 }
20689 {
20690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20691 }
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj = 0;
20700 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20701 wxRect *arg2 = (wxRect *) NULL ;
20702 bool result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 void *argp2 = 0 ;
20706 int res2 = 0 ;
20707 PyObject * obj0 = 0 ;
20708 PyObject * obj1 = 0 ;
20709 char * kwnames[] = {
20710 (char *) "self",(char *) "rect", NULL
20711 };
20712
20713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) SWIG_fail;
20714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20717 }
20718 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20719 if (obj1) {
20720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
20721 if (!SWIG_IsOK(res2)) {
20722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "2"" of type '" "wxRect *""'");
20723 }
20724 arg2 = reinterpret_cast< wxRect * >(argp2);
20725 }
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (bool)(arg1)->StartDrawingOnTop(arg2);
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 {
20733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20734 }
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 SWIGINTERN PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20742 PyObject *resultobj = 0;
20743 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20744 bool result;
20745 void *argp1 = 0 ;
20746 int res1 = 0 ;
20747 PyObject *swig_obj[1] ;
20748
20749 if (!args) SWIG_fail;
20750 swig_obj[0] = args;
20751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
20752 if (!SWIG_IsOK(res1)) {
20753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_EndDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20754 }
20755 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (bool)(arg1)->EndDrawingOnTop();
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 {
20763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20764 }
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 SWIGINTERN PyObject *ScreenDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20772 PyObject *obj;
20773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20774 SWIG_TypeNewClientData(SWIGTYPE_p_wxScreenDC, SWIG_NewClientData(obj));
20775 return SWIG_Py_Void();
20776 }
20777
20778 SWIGINTERN PyObject *ScreenDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 return SWIG_Python_InitShadowInstance(args);
20780 }
20781
20782 SWIGINTERN PyObject *_wrap_new_ClientDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20783 PyObject *resultobj = 0;
20784 wxWindow *arg1 = (wxWindow *) 0 ;
20785 wxClientDC *result = 0 ;
20786 void *argp1 = 0 ;
20787 int res1 = 0 ;
20788 PyObject * obj0 = 0 ;
20789 char * kwnames[] = {
20790 (char *) "win", NULL
20791 };
20792
20793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) SWIG_fail;
20794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20795 if (!SWIG_IsOK(res1)) {
20796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20797 }
20798 arg1 = reinterpret_cast< wxWindow * >(argp1);
20799 {
20800 if (!wxPyCheckForApp()) SWIG_fail;
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (wxClientDC *)new wxClientDC(arg1);
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClientDC, SWIG_POINTER_NEW | 0 );
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *ClientDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *obj;
20815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20816 SWIG_TypeNewClientData(SWIGTYPE_p_wxClientDC, SWIG_NewClientData(obj));
20817 return SWIG_Py_Void();
20818 }
20819
20820 SWIGINTERN PyObject *ClientDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 return SWIG_Python_InitShadowInstance(args);
20822 }
20823
20824 SWIGINTERN PyObject *_wrap_new_PaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj = 0;
20826 wxWindow *arg1 = (wxWindow *) 0 ;
20827 wxPaintDC *result = 0 ;
20828 void *argp1 = 0 ;
20829 int res1 = 0 ;
20830 PyObject * obj0 = 0 ;
20831 char * kwnames[] = {
20832 (char *) "win", NULL
20833 };
20834
20835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) SWIG_fail;
20836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20839 }
20840 arg1 = reinterpret_cast< wxWindow * >(argp1);
20841 {
20842 if (!wxPyCheckForApp()) SWIG_fail;
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (wxPaintDC *)new wxPaintDC(arg1);
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintDC, SWIG_POINTER_NEW | 0 );
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 SWIGINTERN PyObject *PaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20856 PyObject *obj;
20857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintDC, SWIG_NewClientData(obj));
20859 return SWIG_Py_Void();
20860 }
20861
20862 SWIGINTERN PyObject *PaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 return SWIG_Python_InitShadowInstance(args);
20864 }
20865
20866 SWIGINTERN PyObject *_wrap_new_WindowDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20867 PyObject *resultobj = 0;
20868 wxWindow *arg1 = (wxWindow *) 0 ;
20869 wxWindowDC *result = 0 ;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject * obj0 = 0 ;
20873 char * kwnames[] = {
20874 (char *) "win", NULL
20875 };
20876
20877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) SWIG_fail;
20878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20879 if (!SWIG_IsOK(res1)) {
20880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20881 }
20882 arg1 = reinterpret_cast< wxWindow * >(argp1);
20883 {
20884 if (!wxPyCheckForApp()) SWIG_fail;
20885 PyThreadState* __tstate = wxPyBeginAllowThreads();
20886 result = (wxWindowDC *)new wxWindowDC(arg1);
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDC, SWIG_POINTER_NEW | 0 );
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *WindowDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20898 PyObject *obj;
20899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20900 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDC, SWIG_NewClientData(obj));
20901 return SWIG_Py_Void();
20902 }
20903
20904 SWIGINTERN PyObject *WindowDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20905 return SWIG_Python_InitShadowInstance(args);
20906 }
20907
20908 SWIGINTERN PyObject *_wrap_new_MirrorDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20909 PyObject *resultobj = 0;
20910 wxDC *arg1 = 0 ;
20911 bool arg2 ;
20912 wxMirrorDC *result = 0 ;
20913 void *argp1 = 0 ;
20914 int res1 = 0 ;
20915 bool val2 ;
20916 int ecode2 = 0 ;
20917 PyObject * obj0 = 0 ;
20918 PyObject * obj1 = 0 ;
20919 char * kwnames[] = {
20920 (char *) "dc",(char *) "mirror", NULL
20921 };
20922
20923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) SWIG_fail;
20924 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDC, 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
20927 }
20928 if (!argp1) {
20929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
20930 }
20931 arg1 = reinterpret_cast< wxDC * >(argp1);
20932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20933 if (!SWIG_IsOK(ecode2)) {
20934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MirrorDC" "', expected argument " "2"" of type '" "bool""'");
20935 }
20936 arg2 = static_cast< bool >(val2);
20937 {
20938 if (!wxPyCheckForApp()) SWIG_fail;
20939 PyThreadState* __tstate = wxPyBeginAllowThreads();
20940 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMirrorDC, SWIG_POINTER_NEW | 0 );
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 SWIGINTERN PyObject *MirrorDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20952 PyObject *obj;
20953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20954 SWIG_TypeNewClientData(SWIGTYPE_p_wxMirrorDC, SWIG_NewClientData(obj));
20955 return SWIG_Py_Void();
20956 }
20957
20958 SWIGINTERN PyObject *MirrorDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 return SWIG_Python_InitShadowInstance(args);
20960 }
20961
20962 SWIGINTERN PyObject *_wrap_new_PostScriptDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20963 PyObject *resultobj = 0;
20964 wxPrintData *arg1 = 0 ;
20965 wxPostScriptDC *result = 0 ;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 PyObject * obj0 = 0 ;
20969 char * kwnames[] = {
20970 (char *) "printData", NULL
20971 };
20972
20973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) SWIG_fail;
20974 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
20975 if (!SWIG_IsOK(res1)) {
20976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
20977 }
20978 if (!argp1) {
20979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
20980 }
20981 arg1 = reinterpret_cast< wxPrintData * >(argp1);
20982 {
20983 if (!wxPyCheckForApp()) SWIG_fail;
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_NEW | 0 );
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 SWIGINTERN PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20997 PyObject *resultobj = 0;
20998 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
20999 wxPrintData *result = 0 ;
21000 void *argp1 = 0 ;
21001 int res1 = 0 ;
21002 PyObject *swig_obj[1] ;
21003
21004 if (!args) SWIG_fail;
21005 swig_obj[0] = args;
21006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
21007 if (!SWIG_IsOK(res1)) {
21008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_GetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
21009 }
21010 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
21011 {
21012 PyThreadState* __tstate = wxPyBeginAllowThreads();
21013 {
21014 wxPrintData &_result_ref = (arg1)->GetPrintData();
21015 result = (wxPrintData *) &_result_ref;
21016 }
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );
21021 return resultobj;
21022 fail:
21023 return NULL;
21024 }
21025
21026
21027 SWIGINTERN PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21028 PyObject *resultobj = 0;
21029 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
21030 wxPrintData *arg2 = 0 ;
21031 void *argp1 = 0 ;
21032 int res1 = 0 ;
21033 void *argp2 = 0 ;
21034 int res2 = 0 ;
21035 PyObject * obj0 = 0 ;
21036 PyObject * obj1 = 0 ;
21037 char * kwnames[] = {
21038 (char *) "self",(char *) "data", NULL
21039 };
21040
21041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;
21042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
21045 }
21046 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
21047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);
21048 if (!SWIG_IsOK(res2)) {
21049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
21050 }
21051 if (!argp2) {
21052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
21053 }
21054 arg2 = reinterpret_cast< wxPrintData * >(argp2);
21055 {
21056 PyThreadState* __tstate = wxPyBeginAllowThreads();
21057 (arg1)->SetPrintData((wxPrintData const &)*arg2);
21058 wxPyEndAllowThreads(__tstate);
21059 if (PyErr_Occurred()) SWIG_fail;
21060 }
21061 resultobj = SWIG_Py_Void();
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_PostScriptDC_SetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj = 0;
21070 int arg1 ;
21071 int val1 ;
21072 int ecode1 = 0 ;
21073 PyObject * obj0 = 0 ;
21074 char * kwnames[] = {
21075 (char *) "ppi", NULL
21076 };
21077
21078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) SWIG_fail;
21079 ecode1 = SWIG_AsVal_int(obj0, &val1);
21080 if (!SWIG_IsOK(ecode1)) {
21081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PostScriptDC_SetResolution" "', expected argument " "1"" of type '" "int""'");
21082 }
21083 arg1 = static_cast< int >(val1);
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 wxPostScriptDC::SetResolution(arg1);
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 resultobj = SWIG_Py_Void();
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_PostScriptDC_GetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 int result;
21100
21101 if (!SWIG_Python_UnpackTuple(args,"PostScriptDC_GetResolution",0,0,0)) SWIG_fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = (int)wxPostScriptDC::GetResolution();
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 resultobj = SWIG_From_int(static_cast< int >(result));
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 SWIGINTERN PyObject *PostScriptDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21116 PyObject *obj;
21117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21118 SWIG_TypeNewClientData(SWIGTYPE_p_wxPostScriptDC, SWIG_NewClientData(obj));
21119 return SWIG_Py_Void();
21120 }
21121
21122 SWIGINTERN PyObject *PostScriptDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 return SWIG_Python_InitShadowInstance(args);
21124 }
21125
21126 SWIGINTERN PyObject *_wrap_new_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj = 0;
21128 wxString const &arg1_defvalue = wxPyEmptyString ;
21129 wxString *arg1 = (wxString *) &arg1_defvalue ;
21130 wxMetaFile *result = 0 ;
21131 bool temp1 = false ;
21132 PyObject * obj0 = 0 ;
21133 char * kwnames[] = {
21134 (char *) "filename", NULL
21135 };
21136
21137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) SWIG_fail;
21138 if (obj0) {
21139 {
21140 arg1 = wxString_in_helper(obj0);
21141 if (arg1 == NULL) SWIG_fail;
21142 temp1 = true;
21143 }
21144 }
21145 {
21146 if (!wxPyCheckForApp()) SWIG_fail;
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, SWIG_POINTER_NEW | 0 );
21153 {
21154 if (temp1)
21155 delete arg1;
21156 }
21157 return resultobj;
21158 fail:
21159 {
21160 if (temp1)
21161 delete arg1;
21162 }
21163 return NULL;
21164 }
21165
21166
21167 SWIGINTERN PyObject *_wrap_delete_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21168 PyObject *resultobj = 0;
21169 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21170 void *argp1 = 0 ;
21171 int res1 = 0 ;
21172 PyObject *swig_obj[1] ;
21173
21174 if (!args) SWIG_fail;
21175 swig_obj[0] = args;
21176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, SWIG_POINTER_DISOWN | 0 );
21177 if (!SWIG_IsOK(res1)) {
21178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaFile" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21179 }
21180 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 delete arg1;
21184
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 resultobj = SWIG_Py_Void();
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_MetaFile_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21198 bool result;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 PyObject *swig_obj[1] ;
21202
21203 if (!args) SWIG_fail;
21204 swig_obj[0] = args;
21205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_Ok" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21208 }
21209 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (bool)(arg1)->Ok();
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 {
21217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21218 }
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_MetaFile_SetClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj = 0;
21227 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21228 int arg2 = (int) 0 ;
21229 int arg3 = (int) 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 int val2 ;
21234 int ecode2 = 0 ;
21235 int val3 ;
21236 int ecode3 = 0 ;
21237 PyObject * obj0 = 0 ;
21238 PyObject * obj1 = 0 ;
21239 PyObject * obj2 = 0 ;
21240 char * kwnames[] = {
21241 (char *) "self",(char *) "width",(char *) "height", NULL
21242 };
21243
21244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
21246 if (!SWIG_IsOK(res1)) {
21247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_SetClipboard" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21248 }
21249 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21250 if (obj1) {
21251 ecode2 = SWIG_AsVal_int(obj1, &val2);
21252 if (!SWIG_IsOK(ecode2)) {
21253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MetaFile_SetClipboard" "', expected argument " "2"" of type '" "int""'");
21254 }
21255 arg2 = static_cast< int >(val2);
21256 }
21257 if (obj2) {
21258 ecode3 = SWIG_AsVal_int(obj2, &val3);
21259 if (!SWIG_IsOK(ecode3)) {
21260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MetaFile_SetClipboard" "', expected argument " "3"" of type '" "int""'");
21261 }
21262 arg3 = static_cast< int >(val3);
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 result = (bool)(arg1)->SetClipboard(arg2,arg3);
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 {
21271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21272 }
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 SWIGINTERN PyObject *_wrap_MetaFile_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21280 PyObject *resultobj = 0;
21281 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21282 wxSize result;
21283 void *argp1 = 0 ;
21284 int res1 = 0 ;
21285 PyObject *swig_obj[1] ;
21286
21287 if (!args) SWIG_fail;
21288 swig_obj[0] = args;
21289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetSize" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21292 }
21293 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21294 {
21295 PyThreadState* __tstate = wxPyBeginAllowThreads();
21296 result = (arg1)->GetSize();
21297 wxPyEndAllowThreads(__tstate);
21298 if (PyErr_Occurred()) SWIG_fail;
21299 }
21300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_MetaFile_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 PyObject *resultobj = 0;
21309 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21310 int result;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 PyObject *swig_obj[1] ;
21314
21315 if (!args) SWIG_fail;
21316 swig_obj[0] = args;
21317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
21318 if (!SWIG_IsOK(res1)) {
21319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetWidth" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21320 }
21321 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (int)(arg1)->GetWidth();
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 resultobj = SWIG_From_int(static_cast< int >(result));
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 SWIGINTERN PyObject *_wrap_MetaFile_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336 PyObject *resultobj = 0;
21337 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
21338 int result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 PyObject *swig_obj[1] ;
21342
21343 if (!args) SWIG_fail;
21344 swig_obj[0] = args;
21345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetHeight" "', expected argument " "1"" of type '" "wxMetaFile *""'");
21348 }
21349 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
21350 {
21351 PyThreadState* __tstate = wxPyBeginAllowThreads();
21352 result = (int)(arg1)->GetHeight();
21353 wxPyEndAllowThreads(__tstate);
21354 if (PyErr_Occurred()) SWIG_fail;
21355 }
21356 resultobj = SWIG_From_int(static_cast< int >(result));
21357 return resultobj;
21358 fail:
21359 return NULL;
21360 }
21361
21362
21363 SWIGINTERN PyObject *MetaFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21364 PyObject *obj;
21365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFile, SWIG_NewClientData(obj));
21367 return SWIG_Py_Void();
21368 }
21369
21370 SWIGINTERN PyObject *MetaFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371 return SWIG_Python_InitShadowInstance(args);
21372 }
21373
21374 SWIGINTERN PyObject *_wrap_new_MetaFileDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21375 PyObject *resultobj = 0;
21376 wxString const &arg1_defvalue = wxPyEmptyString ;
21377 wxString *arg1 = (wxString *) &arg1_defvalue ;
21378 int arg2 = (int) 0 ;
21379 int arg3 = (int) 0 ;
21380 wxString const &arg4_defvalue = wxPyEmptyString ;
21381 wxString *arg4 = (wxString *) &arg4_defvalue ;
21382 wxMetaFileDC *result = 0 ;
21383 bool temp1 = false ;
21384 int val2 ;
21385 int ecode2 = 0 ;
21386 int val3 ;
21387 int ecode3 = 0 ;
21388 bool temp4 = false ;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 PyObject * obj2 = 0 ;
21392 PyObject * obj3 = 0 ;
21393 char * kwnames[] = {
21394 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
21395 };
21396
21397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21398 if (obj0) {
21399 {
21400 arg1 = wxString_in_helper(obj0);
21401 if (arg1 == NULL) SWIG_fail;
21402 temp1 = true;
21403 }
21404 }
21405 if (obj1) {
21406 ecode2 = SWIG_AsVal_int(obj1, &val2);
21407 if (!SWIG_IsOK(ecode2)) {
21408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MetaFileDC" "', expected argument " "2"" of type '" "int""'");
21409 }
21410 arg2 = static_cast< int >(val2);
21411 }
21412 if (obj2) {
21413 ecode3 = SWIG_AsVal_int(obj2, &val3);
21414 if (!SWIG_IsOK(ecode3)) {
21415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MetaFileDC" "', expected argument " "3"" of type '" "int""'");
21416 }
21417 arg3 = static_cast< int >(val3);
21418 }
21419 if (obj3) {
21420 {
21421 arg4 = wxString_in_helper(obj3);
21422 if (arg4 == NULL) SWIG_fail;
21423 temp4 = true;
21424 }
21425 }
21426 {
21427 if (!wxPyCheckForApp()) SWIG_fail;
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
21430 wxPyEndAllowThreads(__tstate);
21431 if (PyErr_Occurred()) SWIG_fail;
21432 }
21433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_NEW | 0 );
21434 {
21435 if (temp1)
21436 delete arg1;
21437 }
21438 {
21439 if (temp4)
21440 delete arg4;
21441 }
21442 return resultobj;
21443 fail:
21444 {
21445 if (temp1)
21446 delete arg1;
21447 }
21448 {
21449 if (temp4)
21450 delete arg4;
21451 }
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_MetaFileDC_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21457 PyObject *resultobj = 0;
21458 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
21459 wxMetaFile *result = 0 ;
21460 void *argp1 = 0 ;
21461 int res1 = 0 ;
21462 PyObject *swig_obj[1] ;
21463
21464 if (!args) SWIG_fail;
21465 swig_obj[0] = args;
21466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFileDC, 0 | 0 );
21467 if (!SWIG_IsOK(res1)) {
21468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFileDC_Close" "', expected argument " "1"" of type '" "wxMetaFileDC *""'");
21469 }
21470 arg1 = reinterpret_cast< wxMetaFileDC * >(argp1);
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = (wxMetaFile *)(arg1)->Close();
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, 0 | 0 );
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *MetaFileDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21485 PyObject *obj;
21486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21487 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFileDC, SWIG_NewClientData(obj));
21488 return SWIG_Py_Void();
21489 }
21490
21491 SWIGINTERN PyObject *MetaFileDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21492 return SWIG_Python_InitShadowInstance(args);
21493 }
21494
21495 SWIGINTERN PyObject *_wrap_new_PrinterDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21496 PyObject *resultobj = 0;
21497 wxPrintData *arg1 = 0 ;
21498 wxPrinterDC *result = 0 ;
21499 void *argp1 = 0 ;
21500 int res1 = 0 ;
21501 PyObject * obj0 = 0 ;
21502 char * kwnames[] = {
21503 (char *) "printData", NULL
21504 };
21505
21506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) SWIG_fail;
21507 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
21508 if (!SWIG_IsOK(res1)) {
21509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21510 }
21511 if (!argp1) {
21512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21513 }
21514 arg1 = reinterpret_cast< wxPrintData * >(argp1);
21515 {
21516 if (!wxPyCheckForApp()) SWIG_fail;
21517 PyThreadState* __tstate = wxPyBeginAllowThreads();
21518 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrinterDC, SWIG_POINTER_NEW | 0 );
21523 return resultobj;
21524 fail:
21525 return NULL;
21526 }
21527
21528
21529 SWIGINTERN PyObject *PrinterDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21530 PyObject *obj;
21531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21532 SWIG_TypeNewClientData(SWIGTYPE_p_wxPrinterDC, SWIG_NewClientData(obj));
21533 return SWIG_Py_Void();
21534 }
21535
21536 SWIGINTERN PyObject *PrinterDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537 return SWIG_Python_InitShadowInstance(args);
21538 }
21539
21540 SWIGINTERN PyObject *_wrap_new_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21541 PyObject *resultobj = 0;
21542 int arg1 ;
21543 int arg2 ;
21544 int arg3 = (int) true ;
21545 int arg4 = (int) 1 ;
21546 wxImageList *result = 0 ;
21547 int val1 ;
21548 int ecode1 = 0 ;
21549 int val2 ;
21550 int ecode2 = 0 ;
21551 int val3 ;
21552 int ecode3 = 0 ;
21553 int val4 ;
21554 int ecode4 = 0 ;
21555 PyObject * obj0 = 0 ;
21556 PyObject * obj1 = 0 ;
21557 PyObject * obj2 = 0 ;
21558 PyObject * obj3 = 0 ;
21559 char * kwnames[] = {
21560 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
21561 };
21562
21563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21564 ecode1 = SWIG_AsVal_int(obj0, &val1);
21565 if (!SWIG_IsOK(ecode1)) {
21566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageList" "', expected argument " "1"" of type '" "int""'");
21567 }
21568 arg1 = static_cast< int >(val1);
21569 ecode2 = SWIG_AsVal_int(obj1, &val2);
21570 if (!SWIG_IsOK(ecode2)) {
21571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageList" "', expected argument " "2"" of type '" "int""'");
21572 }
21573 arg2 = static_cast< int >(val2);
21574 if (obj2) {
21575 ecode3 = SWIG_AsVal_int(obj2, &val3);
21576 if (!SWIG_IsOK(ecode3)) {
21577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageList" "', expected argument " "3"" of type '" "int""'");
21578 }
21579 arg3 = static_cast< int >(val3);
21580 }
21581 if (obj3) {
21582 ecode4 = SWIG_AsVal_int(obj3, &val4);
21583 if (!SWIG_IsOK(ecode4)) {
21584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImageList" "', expected argument " "4"" of type '" "int""'");
21585 }
21586 arg4 = static_cast< int >(val4);
21587 }
21588 {
21589 if (!wxPyCheckForApp()) SWIG_fail;
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 {
21596 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
21597 }
21598 return resultobj;
21599 fail:
21600 return NULL;
21601 }
21602
21603
21604 SWIGINTERN PyObject *_wrap_delete_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21605 PyObject *resultobj = 0;
21606 wxImageList *arg1 = (wxImageList *) 0 ;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 PyObject *swig_obj[1] ;
21610
21611 if (!args) SWIG_fail;
21612 swig_obj[0] = args;
21613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageList" "', expected argument " "1"" of type '" "wxImageList *""'");
21616 }
21617 arg1 = reinterpret_cast< wxImageList * >(argp1);
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 delete arg1;
21621
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_ImageList_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21633 PyObject *resultobj = 0;
21634 wxImageList *arg1 = (wxImageList *) 0 ;
21635 wxBitmap *arg2 = 0 ;
21636 wxBitmap const &arg3_defvalue = wxNullBitmap ;
21637 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
21638 int result;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 void *argp2 = 0 ;
21642 int res2 = 0 ;
21643 void *argp3 = 0 ;
21644 int res3 = 0 ;
21645 PyObject * obj0 = 0 ;
21646 PyObject * obj1 = 0 ;
21647 PyObject * obj2 = 0 ;
21648 char * kwnames[] = {
21649 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
21650 };
21651
21652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Add" "', expected argument " "1"" of type '" "wxImageList *""'");
21656 }
21657 arg1 = reinterpret_cast< wxImageList * >(argp1);
21658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
21659 if (!SWIG_IsOK(res2)) {
21660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21661 }
21662 if (!argp2) {
21663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21664 }
21665 arg2 = reinterpret_cast< wxBitmap * >(argp2);
21666 if (obj2) {
21667 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
21668 if (!SWIG_IsOK(res3)) {
21669 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21670 }
21671 if (!argp3) {
21672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21673 }
21674 arg3 = reinterpret_cast< wxBitmap * >(argp3);
21675 }
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
21679 wxPyEndAllowThreads(__tstate);
21680 if (PyErr_Occurred()) SWIG_fail;
21681 }
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_ImageList_AddWithColourMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj = 0;
21691 wxImageList *arg1 = (wxImageList *) 0 ;
21692 wxBitmap *arg2 = 0 ;
21693 wxColour *arg3 = 0 ;
21694 int result;
21695 void *argp1 = 0 ;
21696 int res1 = 0 ;
21697 void *argp2 = 0 ;
21698 int res2 = 0 ;
21699 wxColour temp3 ;
21700 PyObject * obj0 = 0 ;
21701 PyObject * obj1 = 0 ;
21702 PyObject * obj2 = 0 ;
21703 char * kwnames[] = {
21704 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
21705 };
21706
21707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21709 if (!SWIG_IsOK(res1)) {
21710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddWithColourMask" "', expected argument " "1"" of type '" "wxImageList *""'");
21711 }
21712 arg1 = reinterpret_cast< wxImageList * >(argp1);
21713 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
21714 if (!SWIG_IsOK(res2)) {
21715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21716 }
21717 if (!argp2) {
21718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21719 }
21720 arg2 = reinterpret_cast< wxBitmap * >(argp2);
21721 {
21722 arg3 = &temp3;
21723 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21724 }
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 resultobj = SWIG_From_int(static_cast< int >(result));
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 SWIGINTERN PyObject *_wrap_ImageList_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21739 PyObject *resultobj = 0;
21740 wxImageList *arg1 = (wxImageList *) 0 ;
21741 wxIcon *arg2 = 0 ;
21742 int result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 void *argp2 = 0 ;
21746 int res2 = 0 ;
21747 PyObject * obj0 = 0 ;
21748 PyObject * obj1 = 0 ;
21749 char * kwnames[] = {
21750 (char *) "self",(char *) "icon", NULL
21751 };
21752
21753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
21754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddIcon" "', expected argument " "1"" of type '" "wxImageList *""'");
21757 }
21758 arg1 = reinterpret_cast< wxImageList * >(argp1);
21759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
21760 if (!SWIG_IsOK(res2)) {
21761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
21762 }
21763 if (!argp2) {
21764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
21765 }
21766 arg2 = reinterpret_cast< wxIcon * >(argp2);
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (int)(arg1)->Add((wxIcon const &)*arg2);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_From_int(static_cast< int >(result));
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_ImageList_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj = 0;
21782 wxImageList *arg1 = (wxImageList *) 0 ;
21783 int arg2 ;
21784 SwigValueWrapper<wxBitmap > result;
21785 void *argp1 = 0 ;
21786 int res1 = 0 ;
21787 int val2 ;
21788 int ecode2 = 0 ;
21789 PyObject * obj0 = 0 ;
21790 PyObject * obj1 = 0 ;
21791 char * kwnames[] = {
21792 (char *) "self",(char *) "index", NULL
21793 };
21794
21795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
21796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21797 if (!SWIG_IsOK(res1)) {
21798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetBitmap" "', expected argument " "1"" of type '" "wxImageList const *""'");
21799 }
21800 arg1 = reinterpret_cast< wxImageList * >(argp1);
21801 ecode2 = SWIG_AsVal_int(obj1, &val2);
21802 if (!SWIG_IsOK(ecode2)) {
21803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetBitmap" "', expected argument " "2"" of type '" "int""'");
21804 }
21805 arg2 = static_cast< int >(val2);
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
21813 return resultobj;
21814 fail:
21815 return NULL;
21816 }
21817
21818
21819 SWIGINTERN PyObject *_wrap_ImageList_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21820 PyObject *resultobj = 0;
21821 wxImageList *arg1 = (wxImageList *) 0 ;
21822 int arg2 ;
21823 wxIcon result;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 int val2 ;
21827 int ecode2 = 0 ;
21828 PyObject * obj0 = 0 ;
21829 PyObject * obj1 = 0 ;
21830 char * kwnames[] = {
21831 (char *) "self",(char *) "index", NULL
21832 };
21833
21834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
21835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetIcon" "', expected argument " "1"" of type '" "wxImageList const *""'");
21838 }
21839 arg1 = reinterpret_cast< wxImageList * >(argp1);
21840 ecode2 = SWIG_AsVal_int(obj1, &val2);
21841 if (!SWIG_IsOK(ecode2)) {
21842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetIcon" "', expected argument " "2"" of type '" "int""'");
21843 }
21844 arg2 = static_cast< int >(val2);
21845 {
21846 PyThreadState* __tstate = wxPyBeginAllowThreads();
21847 result = ((wxImageList const *)arg1)->GetIcon(arg2);
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 SWIGINTERN PyObject *_wrap_ImageList_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21859 PyObject *resultobj = 0;
21860 wxImageList *arg1 = (wxImageList *) 0 ;
21861 int arg2 ;
21862 wxBitmap *arg3 = 0 ;
21863 bool result;
21864 void *argp1 = 0 ;
21865 int res1 = 0 ;
21866 int val2 ;
21867 int ecode2 = 0 ;
21868 void *argp3 = 0 ;
21869 int res3 = 0 ;
21870 PyObject * obj0 = 0 ;
21871 PyObject * obj1 = 0 ;
21872 PyObject * obj2 = 0 ;
21873 char * kwnames[] = {
21874 (char *) "self",(char *) "index",(char *) "bitmap", NULL
21875 };
21876
21877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Replace" "', expected argument " "1"" of type '" "wxImageList *""'");
21881 }
21882 arg1 = reinterpret_cast< wxImageList * >(argp1);
21883 ecode2 = SWIG_AsVal_int(obj1, &val2);
21884 if (!SWIG_IsOK(ecode2)) {
21885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Replace" "', expected argument " "2"" of type '" "int""'");
21886 }
21887 arg2 = static_cast< int >(val2);
21888 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
21889 if (!SWIG_IsOK(res3)) {
21890 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21891 }
21892 if (!argp3) {
21893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21894 }
21895 arg3 = reinterpret_cast< wxBitmap * >(argp3);
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
21899 wxPyEndAllowThreads(__tstate);
21900 if (PyErr_Occurred()) SWIG_fail;
21901 }
21902 {
21903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21904 }
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 SWIGINTERN PyObject *_wrap_ImageList_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21912 PyObject *resultobj = 0;
21913 wxImageList *arg1 = (wxImageList *) 0 ;
21914 int arg2 ;
21915 wxDC *arg3 = 0 ;
21916 int arg4 ;
21917 int arg5 ;
21918 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
21919 bool arg7 = (bool) (bool)false ;
21920 bool result;
21921 void *argp1 = 0 ;
21922 int res1 = 0 ;
21923 int val2 ;
21924 int ecode2 = 0 ;
21925 void *argp3 = 0 ;
21926 int res3 = 0 ;
21927 int val4 ;
21928 int ecode4 = 0 ;
21929 int val5 ;
21930 int ecode5 = 0 ;
21931 int val6 ;
21932 int ecode6 = 0 ;
21933 bool val7 ;
21934 int ecode7 = 0 ;
21935 PyObject * obj0 = 0 ;
21936 PyObject * obj1 = 0 ;
21937 PyObject * obj2 = 0 ;
21938 PyObject * obj3 = 0 ;
21939 PyObject * obj4 = 0 ;
21940 PyObject * obj5 = 0 ;
21941 PyObject * obj6 = 0 ;
21942 char * kwnames[] = {
21943 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
21944 };
21945
21946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
21947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21948 if (!SWIG_IsOK(res1)) {
21949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Draw" "', expected argument " "1"" of type '" "wxImageList *""'");
21950 }
21951 arg1 = reinterpret_cast< wxImageList * >(argp1);
21952 ecode2 = SWIG_AsVal_int(obj1, &val2);
21953 if (!SWIG_IsOK(ecode2)) {
21954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Draw" "', expected argument " "2"" of type '" "int""'");
21955 }
21956 arg2 = static_cast< int >(val2);
21957 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
21958 if (!SWIG_IsOK(res3)) {
21959 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
21960 }
21961 if (!argp3) {
21962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
21963 }
21964 arg3 = reinterpret_cast< wxDC * >(argp3);
21965 ecode4 = SWIG_AsVal_int(obj3, &val4);
21966 if (!SWIG_IsOK(ecode4)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageList_Draw" "', expected argument " "4"" of type '" "int""'");
21968 }
21969 arg4 = static_cast< int >(val4);
21970 ecode5 = SWIG_AsVal_int(obj4, &val5);
21971 if (!SWIG_IsOK(ecode5)) {
21972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageList_Draw" "', expected argument " "5"" of type '" "int""'");
21973 }
21974 arg5 = static_cast< int >(val5);
21975 if (obj5) {
21976 ecode6 = SWIG_AsVal_int(obj5, &val6);
21977 if (!SWIG_IsOK(ecode6)) {
21978 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageList_Draw" "', expected argument " "6"" of type '" "int""'");
21979 }
21980 arg6 = static_cast< int >(val6);
21981 }
21982 if (obj6) {
21983 ecode7 = SWIG_AsVal_bool(obj6, &val7);
21984 if (!SWIG_IsOK(ecode7)) {
21985 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageList_Draw" "', expected argument " "7"" of type '" "bool""'");
21986 }
21987 arg7 = static_cast< bool >(val7);
21988 }
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 {
21996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21997 }
21998 return resultobj;
21999 fail:
22000 return NULL;
22001 }
22002
22003
22004 SWIGINTERN PyObject *_wrap_ImageList_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 PyObject *resultobj = 0;
22006 wxImageList *arg1 = (wxImageList *) 0 ;
22007 int result;
22008 void *argp1 = 0 ;
22009 int res1 = 0 ;
22010 PyObject *swig_obj[1] ;
22011
22012 if (!args) SWIG_fail;
22013 swig_obj[0] = args;
22014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetImageCount" "', expected argument " "1"" of type '" "wxImageList *""'");
22017 }
22018 arg1 = reinterpret_cast< wxImageList * >(argp1);
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (int)(arg1)->GetImageCount();
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_From_int(static_cast< int >(result));
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_ImageList_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj = 0;
22034 wxImageList *arg1 = (wxImageList *) 0 ;
22035 int arg2 ;
22036 bool result;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 int val2 ;
22040 int ecode2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "self",(char *) "index", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
22048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
22049 if (!SWIG_IsOK(res1)) {
22050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Remove" "', expected argument " "1"" of type '" "wxImageList *""'");
22051 }
22052 arg1 = reinterpret_cast< wxImageList * >(argp1);
22053 ecode2 = SWIG_AsVal_int(obj1, &val2);
22054 if (!SWIG_IsOK(ecode2)) {
22055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Remove" "', expected argument " "2"" of type '" "int""'");
22056 }
22057 arg2 = static_cast< int >(val2);
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 result = (bool)(arg1)->Remove(arg2);
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 {
22065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22066 }
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 SWIGINTERN PyObject *_wrap_ImageList_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22074 PyObject *resultobj = 0;
22075 wxImageList *arg1 = (wxImageList *) 0 ;
22076 bool result;
22077 void *argp1 = 0 ;
22078 int res1 = 0 ;
22079 PyObject *swig_obj[1] ;
22080
22081 if (!args) SWIG_fail;
22082 swig_obj[0] = args;
22083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
22084 if (!SWIG_IsOK(res1)) {
22085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_RemoveAll" "', expected argument " "1"" of type '" "wxImageList *""'");
22086 }
22087 arg1 = reinterpret_cast< wxImageList * >(argp1);
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (bool)(arg1)->RemoveAll();
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 {
22095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22096 }
22097 return resultobj;
22098 fail:
22099 return NULL;
22100 }
22101
22102
22103 SWIGINTERN PyObject *_wrap_ImageList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22104 PyObject *resultobj = 0;
22105 wxImageList *arg1 = (wxImageList *) 0 ;
22106 int arg2 ;
22107 int *arg3 = 0 ;
22108 int *arg4 = 0 ;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 int val2 ;
22112 int ecode2 = 0 ;
22113 int temp3 ;
22114 int res3 = SWIG_TMPOBJ ;
22115 int temp4 ;
22116 int res4 = SWIG_TMPOBJ ;
22117 PyObject * obj0 = 0 ;
22118 PyObject * obj1 = 0 ;
22119 char * kwnames[] = {
22120 (char *) "self",(char *) "index", NULL
22121 };
22122
22123 arg3 = &temp3;
22124 arg4 = &temp4;
22125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
22127 if (!SWIG_IsOK(res1)) {
22128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetSize" "', expected argument " "1"" of type '" "wxImageList *""'");
22129 }
22130 arg1 = reinterpret_cast< wxImageList * >(argp1);
22131 ecode2 = SWIG_AsVal_int(obj1, &val2);
22132 if (!SWIG_IsOK(ecode2)) {
22133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetSize" "', expected argument " "2"" of type '" "int""'");
22134 }
22135 arg2 = static_cast< int >(val2);
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 (arg1)->GetSize(arg2,*arg3,*arg4);
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 resultobj = SWIG_Py_Void();
22143 if (SWIG_IsTmpObj(res3)) {
22144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22145 } else {
22146 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22148 }
22149 if (SWIG_IsTmpObj(res4)) {
22150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
22151 } else {
22152 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
22154 }
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *ImageList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *obj;
22163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22164 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageList, SWIG_NewClientData(obj));
22165 return SWIG_Py_Void();
22166 }
22167
22168 SWIGINTERN PyObject *ImageList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22169 return SWIG_Python_InitShadowInstance(args);
22170 }
22171
22172 SWIGINTERN int NORMAL_FONT_set(PyObject *) {
22173 SWIG_Error(SWIG_AttributeError,"Variable NORMAL_FONT is read-only.");
22174 return 1;
22175 }
22176
22177
22178 SWIGINTERN PyObject *NORMAL_FONT_get(void) {
22179 PyObject *pyobj = 0;
22180
22181 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0 );
22182 return pyobj;
22183 }
22184
22185
22186 SWIGINTERN int SMALL_FONT_set(PyObject *) {
22187 SWIG_Error(SWIG_AttributeError,"Variable SMALL_FONT is read-only.");
22188 return 1;
22189 }
22190
22191
22192 SWIGINTERN PyObject *SMALL_FONT_get(void) {
22193 PyObject *pyobj = 0;
22194
22195 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0 );
22196 return pyobj;
22197 }
22198
22199
22200 SWIGINTERN int ITALIC_FONT_set(PyObject *) {
22201 SWIG_Error(SWIG_AttributeError,"Variable ITALIC_FONT is read-only.");
22202 return 1;
22203 }
22204
22205
22206 SWIGINTERN PyObject *ITALIC_FONT_get(void) {
22207 PyObject *pyobj = 0;
22208
22209 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0 );
22210 return pyobj;
22211 }
22212
22213
22214 SWIGINTERN int SWISS_FONT_set(PyObject *) {
22215 SWIG_Error(SWIG_AttributeError,"Variable SWISS_FONT is read-only.");
22216 return 1;
22217 }
22218
22219
22220 SWIGINTERN PyObject *SWISS_FONT_get(void) {
22221 PyObject *pyobj = 0;
22222
22223 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0 );
22224 return pyobj;
22225 }
22226
22227
22228 SWIGINTERN int RED_PEN_set(PyObject *) {
22229 SWIG_Error(SWIG_AttributeError,"Variable RED_PEN is read-only.");
22230 return 1;
22231 }
22232
22233
22234 SWIGINTERN PyObject *RED_PEN_get(void) {
22235 PyObject *pyobj = 0;
22236
22237 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxRED_PEN), SWIGTYPE_p_wxPen, 0 );
22238 return pyobj;
22239 }
22240
22241
22242 SWIGINTERN int CYAN_PEN_set(PyObject *) {
22243 SWIG_Error(SWIG_AttributeError,"Variable CYAN_PEN is read-only.");
22244 return 1;
22245 }
22246
22247
22248 SWIGINTERN PyObject *CYAN_PEN_get(void) {
22249 PyObject *pyobj = 0;
22250
22251 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0 );
22252 return pyobj;
22253 }
22254
22255
22256 SWIGINTERN int GREEN_PEN_set(PyObject *) {
22257 SWIG_Error(SWIG_AttributeError,"Variable GREEN_PEN is read-only.");
22258 return 1;
22259 }
22260
22261
22262 SWIGINTERN PyObject *GREEN_PEN_get(void) {
22263 PyObject *pyobj = 0;
22264
22265 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0 );
22266 return pyobj;
22267 }
22268
22269
22270 SWIGINTERN int BLACK_PEN_set(PyObject *) {
22271 SWIG_Error(SWIG_AttributeError,"Variable BLACK_PEN is read-only.");
22272 return 1;
22273 }
22274
22275
22276 SWIGINTERN PyObject *BLACK_PEN_get(void) {
22277 PyObject *pyobj = 0;
22278
22279 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0 );
22280 return pyobj;
22281 }
22282
22283
22284 SWIGINTERN int WHITE_PEN_set(PyObject *) {
22285 SWIG_Error(SWIG_AttributeError,"Variable WHITE_PEN is read-only.");
22286 return 1;
22287 }
22288
22289
22290 SWIGINTERN PyObject *WHITE_PEN_get(void) {
22291 PyObject *pyobj = 0;
22292
22293 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0 );
22294 return pyobj;
22295 }
22296
22297
22298 SWIGINTERN int TRANSPARENT_PEN_set(PyObject *) {
22299 SWIG_Error(SWIG_AttributeError,"Variable TRANSPARENT_PEN is read-only.");
22300 return 1;
22301 }
22302
22303
22304 SWIGINTERN PyObject *TRANSPARENT_PEN_get(void) {
22305 PyObject *pyobj = 0;
22306
22307 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0 );
22308 return pyobj;
22309 }
22310
22311
22312 SWIGINTERN int BLACK_DASHED_PEN_set(PyObject *) {
22313 SWIG_Error(SWIG_AttributeError,"Variable BLACK_DASHED_PEN is read-only.");
22314 return 1;
22315 }
22316
22317
22318 SWIGINTERN PyObject *BLACK_DASHED_PEN_get(void) {
22319 PyObject *pyobj = 0;
22320
22321 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0 );
22322 return pyobj;
22323 }
22324
22325
22326 SWIGINTERN int GREY_PEN_set(PyObject *) {
22327 SWIG_Error(SWIG_AttributeError,"Variable GREY_PEN is read-only.");
22328 return 1;
22329 }
22330
22331
22332 SWIGINTERN PyObject *GREY_PEN_get(void) {
22333 PyObject *pyobj = 0;
22334
22335 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxGREY_PEN), SWIGTYPE_p_wxPen, 0 );
22336 return pyobj;
22337 }
22338
22339
22340 SWIGINTERN int MEDIUM_GREY_PEN_set(PyObject *) {
22341 SWIG_Error(SWIG_AttributeError,"Variable MEDIUM_GREY_PEN is read-only.");
22342 return 1;
22343 }
22344
22345
22346 SWIGINTERN PyObject *MEDIUM_GREY_PEN_get(void) {
22347 PyObject *pyobj = 0;
22348
22349 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0 );
22350 return pyobj;
22351 }
22352
22353
22354 SWIGINTERN int LIGHT_GREY_PEN_set(PyObject *) {
22355 SWIG_Error(SWIG_AttributeError,"Variable LIGHT_GREY_PEN is read-only.");
22356 return 1;
22357 }
22358
22359
22360 SWIGINTERN PyObject *LIGHT_GREY_PEN_get(void) {
22361 PyObject *pyobj = 0;
22362
22363 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0 );
22364 return pyobj;
22365 }
22366
22367
22368 SWIGINTERN int BLUE_BRUSH_set(PyObject *) {
22369 SWIG_Error(SWIG_AttributeError,"Variable BLUE_BRUSH is read-only.");
22370 return 1;
22371 }
22372
22373
22374 SWIGINTERN PyObject *BLUE_BRUSH_get(void) {
22375 PyObject *pyobj = 0;
22376
22377 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22378 return pyobj;
22379 }
22380
22381
22382 SWIGINTERN int GREEN_BRUSH_set(PyObject *) {
22383 SWIG_Error(SWIG_AttributeError,"Variable GREEN_BRUSH is read-only.");
22384 return 1;
22385 }
22386
22387
22388 SWIGINTERN PyObject *GREEN_BRUSH_get(void) {
22389 PyObject *pyobj = 0;
22390
22391 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22392 return pyobj;
22393 }
22394
22395
22396 SWIGINTERN int WHITE_BRUSH_set(PyObject *) {
22397 SWIG_Error(SWIG_AttributeError,"Variable WHITE_BRUSH is read-only.");
22398 return 1;
22399 }
22400
22401
22402 SWIGINTERN PyObject *WHITE_BRUSH_get(void) {
22403 PyObject *pyobj = 0;
22404
22405 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22406 return pyobj;
22407 }
22408
22409
22410 SWIGINTERN int BLACK_BRUSH_set(PyObject *) {
22411 SWIG_Error(SWIG_AttributeError,"Variable BLACK_BRUSH is read-only.");
22412 return 1;
22413 }
22414
22415
22416 SWIGINTERN PyObject *BLACK_BRUSH_get(void) {
22417 PyObject *pyobj = 0;
22418
22419 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22420 return pyobj;
22421 }
22422
22423
22424 SWIGINTERN int TRANSPARENT_BRUSH_set(PyObject *) {
22425 SWIG_Error(SWIG_AttributeError,"Variable TRANSPARENT_BRUSH is read-only.");
22426 return 1;
22427 }
22428
22429
22430 SWIGINTERN PyObject *TRANSPARENT_BRUSH_get(void) {
22431 PyObject *pyobj = 0;
22432
22433 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22434 return pyobj;
22435 }
22436
22437
22438 SWIGINTERN int CYAN_BRUSH_set(PyObject *) {
22439 SWIG_Error(SWIG_AttributeError,"Variable CYAN_BRUSH is read-only.");
22440 return 1;
22441 }
22442
22443
22444 SWIGINTERN PyObject *CYAN_BRUSH_get(void) {
22445 PyObject *pyobj = 0;
22446
22447 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22448 return pyobj;
22449 }
22450
22451
22452 SWIGINTERN int RED_BRUSH_set(PyObject *) {
22453 SWIG_Error(SWIG_AttributeError,"Variable RED_BRUSH is read-only.");
22454 return 1;
22455 }
22456
22457
22458 SWIGINTERN PyObject *RED_BRUSH_get(void) {
22459 PyObject *pyobj = 0;
22460
22461 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22462 return pyobj;
22463 }
22464
22465
22466 SWIGINTERN int GREY_BRUSH_set(PyObject *) {
22467 SWIG_Error(SWIG_AttributeError,"Variable GREY_BRUSH is read-only.");
22468 return 1;
22469 }
22470
22471
22472 SWIGINTERN PyObject *GREY_BRUSH_get(void) {
22473 PyObject *pyobj = 0;
22474
22475 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22476 return pyobj;
22477 }
22478
22479
22480 SWIGINTERN int MEDIUM_GREY_BRUSH_set(PyObject *) {
22481 SWIG_Error(SWIG_AttributeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
22482 return 1;
22483 }
22484
22485
22486 SWIGINTERN PyObject *MEDIUM_GREY_BRUSH_get(void) {
22487 PyObject *pyobj = 0;
22488
22489 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22490 return pyobj;
22491 }
22492
22493
22494 SWIGINTERN int LIGHT_GREY_BRUSH_set(PyObject *) {
22495 SWIG_Error(SWIG_AttributeError,"Variable LIGHT_GREY_BRUSH is read-only.");
22496 return 1;
22497 }
22498
22499
22500 SWIGINTERN PyObject *LIGHT_GREY_BRUSH_get(void) {
22501 PyObject *pyobj = 0;
22502
22503 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0 );
22504 return pyobj;
22505 }
22506
22507
22508 SWIGINTERN int BLACK_set(PyObject *) {
22509 SWIG_Error(SWIG_AttributeError,"Variable BLACK is read-only.");
22510 return 1;
22511 }
22512
22513
22514 SWIGINTERN PyObject *BLACK_get(void) {
22515 PyObject *pyobj = 0;
22516
22517 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLACK), SWIGTYPE_p_wxColour, 0 );
22518 return pyobj;
22519 }
22520
22521
22522 SWIGINTERN int WHITE_set(PyObject *) {
22523 SWIG_Error(SWIG_AttributeError,"Variable WHITE is read-only.");
22524 return 1;
22525 }
22526
22527
22528 SWIGINTERN PyObject *WHITE_get(void) {
22529 PyObject *pyobj = 0;
22530
22531 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxWHITE), SWIGTYPE_p_wxColour, 0 );
22532 return pyobj;
22533 }
22534
22535
22536 SWIGINTERN int RED_set(PyObject *) {
22537 SWIG_Error(SWIG_AttributeError,"Variable RED is read-only.");
22538 return 1;
22539 }
22540
22541
22542 SWIGINTERN PyObject *RED_get(void) {
22543 PyObject *pyobj = 0;
22544
22545 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxRED), SWIGTYPE_p_wxColour, 0 );
22546 return pyobj;
22547 }
22548
22549
22550 SWIGINTERN int BLUE_set(PyObject *) {
22551 SWIG_Error(SWIG_AttributeError,"Variable BLUE is read-only.");
22552 return 1;
22553 }
22554
22555
22556 SWIGINTERN PyObject *BLUE_get(void) {
22557 PyObject *pyobj = 0;
22558
22559 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxBLUE), SWIGTYPE_p_wxColour, 0 );
22560 return pyobj;
22561 }
22562
22563
22564 SWIGINTERN int GREEN_set(PyObject *) {
22565 SWIG_Error(SWIG_AttributeError,"Variable GREEN is read-only.");
22566 return 1;
22567 }
22568
22569
22570 SWIGINTERN PyObject *GREEN_get(void) {
22571 PyObject *pyobj = 0;
22572
22573 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxGREEN), SWIGTYPE_p_wxColour, 0 );
22574 return pyobj;
22575 }
22576
22577
22578 SWIGINTERN int CYAN_set(PyObject *) {
22579 SWIG_Error(SWIG_AttributeError,"Variable CYAN is read-only.");
22580 return 1;
22581 }
22582
22583
22584 SWIGINTERN PyObject *CYAN_get(void) {
22585 PyObject *pyobj = 0;
22586
22587 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxCYAN), SWIGTYPE_p_wxColour, 0 );
22588 return pyobj;
22589 }
22590
22591
22592 SWIGINTERN int LIGHT_GREY_set(PyObject *) {
22593 SWIG_Error(SWIG_AttributeError,"Variable LIGHT_GREY is read-only.");
22594 return 1;
22595 }
22596
22597
22598 SWIGINTERN PyObject *LIGHT_GREY_get(void) {
22599 PyObject *pyobj = 0;
22600
22601 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0 );
22602 return pyobj;
22603 }
22604
22605
22606 SWIGINTERN int STANDARD_CURSOR_set(PyObject *) {
22607 SWIG_Error(SWIG_AttributeError,"Variable STANDARD_CURSOR is read-only.");
22608 return 1;
22609 }
22610
22611
22612 SWIGINTERN PyObject *STANDARD_CURSOR_get(void) {
22613 PyObject *pyobj = 0;
22614
22615 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0 );
22616 return pyobj;
22617 }
22618
22619
22620 SWIGINTERN int HOURGLASS_CURSOR_set(PyObject *) {
22621 SWIG_Error(SWIG_AttributeError,"Variable HOURGLASS_CURSOR is read-only.");
22622 return 1;
22623 }
22624
22625
22626 SWIGINTERN PyObject *HOURGLASS_CURSOR_get(void) {
22627 PyObject *pyobj = 0;
22628
22629 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0 );
22630 return pyobj;
22631 }
22632
22633
22634 SWIGINTERN int CROSS_CURSOR_set(PyObject *) {
22635 SWIG_Error(SWIG_AttributeError,"Variable CROSS_CURSOR is read-only.");
22636 return 1;
22637 }
22638
22639
22640 SWIGINTERN PyObject *CROSS_CURSOR_get(void) {
22641 PyObject *pyobj = 0;
22642
22643 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0 );
22644 return pyobj;
22645 }
22646
22647
22648 SWIGINTERN int NullBitmap_set(PyObject *) {
22649 SWIG_Error(SWIG_AttributeError,"Variable NullBitmap is read-only.");
22650 return 1;
22651 }
22652
22653
22654 SWIGINTERN PyObject *NullBitmap_get(void) {
22655 PyObject *pyobj = 0;
22656
22657 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0 );
22658 return pyobj;
22659 }
22660
22661
22662 SWIGINTERN int NullIcon_set(PyObject *) {
22663 SWIG_Error(SWIG_AttributeError,"Variable NullIcon is read-only.");
22664 return 1;
22665 }
22666
22667
22668 SWIGINTERN PyObject *NullIcon_get(void) {
22669 PyObject *pyobj = 0;
22670
22671 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullIcon), SWIGTYPE_p_wxIcon, 0 );
22672 return pyobj;
22673 }
22674
22675
22676 SWIGINTERN int NullCursor_set(PyObject *) {
22677 SWIG_Error(SWIG_AttributeError,"Variable NullCursor is read-only.");
22678 return 1;
22679 }
22680
22681
22682 SWIGINTERN PyObject *NullCursor_get(void) {
22683 PyObject *pyobj = 0;
22684
22685 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullCursor), SWIGTYPE_p_wxCursor, 0 );
22686 return pyobj;
22687 }
22688
22689
22690 SWIGINTERN int NullPen_set(PyObject *) {
22691 SWIG_Error(SWIG_AttributeError,"Variable NullPen is read-only.");
22692 return 1;
22693 }
22694
22695
22696 SWIGINTERN PyObject *NullPen_get(void) {
22697 PyObject *pyobj = 0;
22698
22699 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPen), SWIGTYPE_p_wxPen, 0 );
22700 return pyobj;
22701 }
22702
22703
22704 SWIGINTERN int NullBrush_set(PyObject *) {
22705 SWIG_Error(SWIG_AttributeError,"Variable NullBrush is read-only.");
22706 return 1;
22707 }
22708
22709
22710 SWIGINTERN PyObject *NullBrush_get(void) {
22711 PyObject *pyobj = 0;
22712
22713 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBrush), SWIGTYPE_p_wxBrush, 0 );
22714 return pyobj;
22715 }
22716
22717
22718 SWIGINTERN int NullPalette_set(PyObject *) {
22719 SWIG_Error(SWIG_AttributeError,"Variable NullPalette is read-only.");
22720 return 1;
22721 }
22722
22723
22724 SWIGINTERN PyObject *NullPalette_get(void) {
22725 PyObject *pyobj = 0;
22726
22727 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPalette), SWIGTYPE_p_wxPalette, 0 );
22728 return pyobj;
22729 }
22730
22731
22732 SWIGINTERN int NullFont_set(PyObject *) {
22733 SWIG_Error(SWIG_AttributeError,"Variable NullFont is read-only.");
22734 return 1;
22735 }
22736
22737
22738 SWIGINTERN PyObject *NullFont_get(void) {
22739 PyObject *pyobj = 0;
22740
22741 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullFont), SWIGTYPE_p_wxFont, 0 );
22742 return pyobj;
22743 }
22744
22745
22746 SWIGINTERN int NullColour_set(PyObject *) {
22747 SWIG_Error(SWIG_AttributeError,"Variable NullColour is read-only.");
22748 return 1;
22749 }
22750
22751
22752 SWIGINTERN PyObject *NullColour_get(void) {
22753 PyObject *pyobj = 0;
22754
22755 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullColour), SWIGTYPE_p_wxColour, 0 );
22756 return pyobj;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_PenList_AddPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj = 0;
22762 wxPenList *arg1 = (wxPenList *) 0 ;
22763 wxPen *arg2 = (wxPen *) 0 ;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 void *argp2 = 0 ;
22767 int res2 = 0 ;
22768 PyObject * obj0 = 0 ;
22769 PyObject * obj1 = 0 ;
22770 char * kwnames[] = {
22771 (char *) "self",(char *) "pen", NULL
22772 };
22773
22774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) SWIG_fail;
22775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22776 if (!SWIG_IsOK(res1)) {
22777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_AddPen" "', expected argument " "1"" of type '" "wxPenList *""'");
22778 }
22779 arg1 = reinterpret_cast< wxPenList * >(argp1);
22780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
22781 if (!SWIG_IsOK(res2)) {
22782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_AddPen" "', expected argument " "2"" of type '" "wxPen *""'");
22783 }
22784 arg2 = reinterpret_cast< wxPen * >(argp2);
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 (arg1)->AddPen(arg2);
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 resultobj = SWIG_Py_Void();
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_PenList_FindOrCreatePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj = 0;
22800 wxPenList *arg1 = (wxPenList *) 0 ;
22801 wxColour *arg2 = 0 ;
22802 int arg3 ;
22803 int arg4 ;
22804 wxPen *result = 0 ;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 wxColour temp2 ;
22808 int val3 ;
22809 int ecode3 = 0 ;
22810 int val4 ;
22811 int ecode4 = 0 ;
22812 PyObject * obj0 = 0 ;
22813 PyObject * obj1 = 0 ;
22814 PyObject * obj2 = 0 ;
22815 PyObject * obj3 = 0 ;
22816 char * kwnames[] = {
22817 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
22818 };
22819
22820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22822 if (!SWIG_IsOK(res1)) {
22823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_FindOrCreatePen" "', expected argument " "1"" of type '" "wxPenList *""'");
22824 }
22825 arg1 = reinterpret_cast< wxPenList * >(argp1);
22826 {
22827 arg2 = &temp2;
22828 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22829 }
22830 ecode3 = SWIG_AsVal_int(obj2, &val3);
22831 if (!SWIG_IsOK(ecode3)) {
22832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PenList_FindOrCreatePen" "', expected argument " "3"" of type '" "int""'");
22833 }
22834 arg3 = static_cast< int >(val3);
22835 ecode4 = SWIG_AsVal_int(obj3, &val4);
22836 if (!SWIG_IsOK(ecode4)) {
22837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PenList_FindOrCreatePen" "', expected argument " "4"" of type '" "int""'");
22838 }
22839 arg4 = static_cast< int >(val4);
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
22843 wxPyEndAllowThreads(__tstate);
22844 if (PyErr_Occurred()) SWIG_fail;
22845 }
22846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
22847 return resultobj;
22848 fail:
22849 return NULL;
22850 }
22851
22852
22853 SWIGINTERN PyObject *_wrap_PenList_RemovePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22854 PyObject *resultobj = 0;
22855 wxPenList *arg1 = (wxPenList *) 0 ;
22856 wxPen *arg2 = (wxPen *) 0 ;
22857 void *argp1 = 0 ;
22858 int res1 = 0 ;
22859 void *argp2 = 0 ;
22860 int res2 = 0 ;
22861 PyObject * obj0 = 0 ;
22862 PyObject * obj1 = 0 ;
22863 char * kwnames[] = {
22864 (char *) "self",(char *) "pen", NULL
22865 };
22866
22867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) SWIG_fail;
22868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22869 if (!SWIG_IsOK(res1)) {
22870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_RemovePen" "', expected argument " "1"" of type '" "wxPenList *""'");
22871 }
22872 arg1 = reinterpret_cast< wxPenList * >(argp1);
22873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
22874 if (!SWIG_IsOK(res2)) {
22875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_RemovePen" "', expected argument " "2"" of type '" "wxPen *""'");
22876 }
22877 arg2 = reinterpret_cast< wxPen * >(argp2);
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 (arg1)->RemovePen(arg2);
22881 wxPyEndAllowThreads(__tstate);
22882 if (PyErr_Occurred()) SWIG_fail;
22883 }
22884 resultobj = SWIG_Py_Void();
22885 return resultobj;
22886 fail:
22887 return NULL;
22888 }
22889
22890
22891 SWIGINTERN PyObject *_wrap_PenList_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22892 PyObject *resultobj = 0;
22893 wxPenList *arg1 = (wxPenList *) 0 ;
22894 int result;
22895 void *argp1 = 0 ;
22896 int res1 = 0 ;
22897 PyObject *swig_obj[1] ;
22898
22899 if (!args) SWIG_fail;
22900 swig_obj[0] = args;
22901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22902 if (!SWIG_IsOK(res1)) {
22903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_GetCount" "', expected argument " "1"" of type '" "wxPenList *""'");
22904 }
22905 arg1 = reinterpret_cast< wxPenList * >(argp1);
22906 {
22907 PyThreadState* __tstate = wxPyBeginAllowThreads();
22908 result = (int)(arg1)->GetCount();
22909 wxPyEndAllowThreads(__tstate);
22910 if (PyErr_Occurred()) SWIG_fail;
22911 }
22912 resultobj = SWIG_From_int(static_cast< int >(result));
22913 return resultobj;
22914 fail:
22915 return NULL;
22916 }
22917
22918
22919 SWIGINTERN PyObject *PenList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22920 PyObject *obj;
22921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22922 SWIG_TypeNewClientData(SWIGTYPE_p_wxPenList, SWIG_NewClientData(obj));
22923 return SWIG_Py_Void();
22924 }
22925
22926 SWIGINTERN PyObject *_wrap_BrushList_AddBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22927 PyObject *resultobj = 0;
22928 wxBrushList *arg1 = (wxBrushList *) 0 ;
22929 wxBrush *arg2 = (wxBrush *) 0 ;
22930 void *argp1 = 0 ;
22931 int res1 = 0 ;
22932 void *argp2 = 0 ;
22933 int res2 = 0 ;
22934 PyObject * obj0 = 0 ;
22935 PyObject * obj1 = 0 ;
22936 char * kwnames[] = {
22937 (char *) "self",(char *) "brush", NULL
22938 };
22939
22940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) SWIG_fail;
22941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_AddBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
22944 }
22945 arg1 = reinterpret_cast< wxBrushList * >(argp1);
22946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
22947 if (!SWIG_IsOK(res2)) {
22948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_AddBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
22949 }
22950 arg2 = reinterpret_cast< wxBrush * >(argp2);
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 (arg1)->AddBrush(arg2);
22954 wxPyEndAllowThreads(__tstate);
22955 if (PyErr_Occurred()) SWIG_fail;
22956 }
22957 resultobj = SWIG_Py_Void();
22958 return resultobj;
22959 fail:
22960 return NULL;
22961 }
22962
22963
22964 SWIGINTERN PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22965 PyObject *resultobj = 0;
22966 wxBrushList *arg1 = (wxBrushList *) 0 ;
22967 wxColour *arg2 = 0 ;
22968 int arg3 = (int) wxSOLID ;
22969 wxBrush *result = 0 ;
22970 void *argp1 = 0 ;
22971 int res1 = 0 ;
22972 wxColour temp2 ;
22973 int val3 ;
22974 int ecode3 = 0 ;
22975 PyObject * obj0 = 0 ;
22976 PyObject * obj1 = 0 ;
22977 PyObject * obj2 = 0 ;
22978 char * kwnames[] = {
22979 (char *) "self",(char *) "colour",(char *) "style", NULL
22980 };
22981
22982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
22986 }
22987 arg1 = reinterpret_cast< wxBrushList * >(argp1);
22988 {
22989 arg2 = &temp2;
22990 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22991 }
22992 if (obj2) {
22993 ecode3 = SWIG_AsVal_int(obj2, &val3);
22994 if (!SWIG_IsOK(ecode3)) {
22995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "3"" of type '" "int""'");
22996 }
22997 arg3 = static_cast< int >(val3);
22998 }
22999 {
23000 PyThreadState* __tstate = wxPyBeginAllowThreads();
23001 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
23002 wxPyEndAllowThreads(__tstate);
23003 if (PyErr_Occurred()) SWIG_fail;
23004 }
23005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 SWIGINTERN PyObject *_wrap_BrushList_RemoveBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23013 PyObject *resultobj = 0;
23014 wxBrushList *arg1 = (wxBrushList *) 0 ;
23015 wxBrush *arg2 = (wxBrush *) 0 ;
23016 void *argp1 = 0 ;
23017 int res1 = 0 ;
23018 void *argp2 = 0 ;
23019 int res2 = 0 ;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022 char * kwnames[] = {
23023 (char *) "self",(char *) "brush", NULL
23024 };
23025
23026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) SWIG_fail;
23027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
23028 if (!SWIG_IsOK(res1)) {
23029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_RemoveBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
23030 }
23031 arg1 = reinterpret_cast< wxBrushList * >(argp1);
23032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
23033 if (!SWIG_IsOK(res2)) {
23034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_RemoveBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
23035 }
23036 arg2 = reinterpret_cast< wxBrush * >(argp2);
23037 {
23038 PyThreadState* __tstate = wxPyBeginAllowThreads();
23039 (arg1)->RemoveBrush(arg2);
23040 wxPyEndAllowThreads(__tstate);
23041 if (PyErr_Occurred()) SWIG_fail;
23042 }
23043 resultobj = SWIG_Py_Void();
23044 return resultobj;
23045 fail:
23046 return NULL;
23047 }
23048
23049
23050 SWIGINTERN PyObject *_wrap_BrushList_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23051 PyObject *resultobj = 0;
23052 wxBrushList *arg1 = (wxBrushList *) 0 ;
23053 int result;
23054 void *argp1 = 0 ;
23055 int res1 = 0 ;
23056 PyObject *swig_obj[1] ;
23057
23058 if (!args) SWIG_fail;
23059 swig_obj[0] = args;
23060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
23061 if (!SWIG_IsOK(res1)) {
23062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_GetCount" "', expected argument " "1"" of type '" "wxBrushList *""'");
23063 }
23064 arg1 = reinterpret_cast< wxBrushList * >(argp1);
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 result = (int)(arg1)->GetCount();
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 resultobj = SWIG_From_int(static_cast< int >(result));
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 SWIGINTERN PyObject *BrushList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 PyObject *obj;
23080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23081 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrushList, SWIG_NewClientData(obj));
23082 return SWIG_Py_Void();
23083 }
23084
23085 SWIGINTERN PyObject *_wrap_new_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23086 PyObject *resultobj = 0;
23087 wxColourDatabase *result = 0 ;
23088
23089 if (!SWIG_Python_UnpackTuple(args,"new_ColourDatabase",0,0,0)) SWIG_fail;
23090 {
23091 if (!wxPyCheckForApp()) SWIG_fail;
23092 PyThreadState* __tstate = wxPyBeginAllowThreads();
23093 result = (wxColourDatabase *)new wxColourDatabase();
23094 wxPyEndAllowThreads(__tstate);
23095 if (PyErr_Occurred()) SWIG_fail;
23096 }
23097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_NEW | 0 );
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 SWIGINTERN PyObject *_wrap_delete_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23105 PyObject *resultobj = 0;
23106 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23107 void *argp1 = 0 ;
23108 int res1 = 0 ;
23109 PyObject *swig_obj[1] ;
23110
23111 if (!args) SWIG_fail;
23112 swig_obj[0] = args;
23113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_DISOWN | 0 );
23114 if (!SWIG_IsOK(res1)) {
23115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDatabase" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
23116 }
23117 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 delete arg1;
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 resultobj = SWIG_Py_Void();
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 SWIGINTERN PyObject *_wrap_ColourDatabase_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj = 0;
23134 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23135 wxString *arg2 = 0 ;
23136 wxColour result;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 bool temp2 = false ;
23140 PyObject * obj0 = 0 ;
23141 PyObject * obj1 = 0 ;
23142 char * kwnames[] = {
23143 (char *) "self",(char *) "name", NULL
23144 };
23145
23146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) SWIG_fail;
23147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Find" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
23150 }
23151 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23152 {
23153 arg2 = wxString_in_helper(obj1);
23154 if (arg2 == NULL) SWIG_fail;
23155 temp2 = true;
23156 }
23157 {
23158 PyThreadState* __tstate = wxPyBeginAllowThreads();
23159 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23164 {
23165 if (temp2)
23166 delete arg2;
23167 }
23168 return resultobj;
23169 fail:
23170 {
23171 if (temp2)
23172 delete arg2;
23173 }
23174 return NULL;
23175 }
23176
23177
23178 SWIGINTERN PyObject *_wrap_ColourDatabase_FindName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj = 0;
23180 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23181 wxColour *arg2 = 0 ;
23182 wxString result;
23183 void *argp1 = 0 ;
23184 int res1 = 0 ;
23185 wxColour temp2 ;
23186 PyObject * obj0 = 0 ;
23187 PyObject * obj1 = 0 ;
23188 char * kwnames[] = {
23189 (char *) "self",(char *) "colour", NULL
23190 };
23191
23192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) SWIG_fail;
23193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23194 if (!SWIG_IsOK(res1)) {
23195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_FindName" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
23196 }
23197 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23198 {
23199 arg2 = &temp2;
23200 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23201 }
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
23205 wxPyEndAllowThreads(__tstate);
23206 if (PyErr_Occurred()) SWIG_fail;
23207 }
23208 {
23209 #if wxUSE_UNICODE
23210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23211 #else
23212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23213 #endif
23214 }
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_ColourDatabase_AddColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj = 0;
23223 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23224 wxString *arg2 = 0 ;
23225 wxColour *arg3 = 0 ;
23226 void *argp1 = 0 ;
23227 int res1 = 0 ;
23228 bool temp2 = false ;
23229 wxColour temp3 ;
23230 PyObject * obj0 = 0 ;
23231 PyObject * obj1 = 0 ;
23232 PyObject * obj2 = 0 ;
23233 char * kwnames[] = {
23234 (char *) "self",(char *) "name",(char *) "colour", NULL
23235 };
23236
23237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_AddColour" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
23241 }
23242 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23243 {
23244 arg2 = wxString_in_helper(obj1);
23245 if (arg2 == NULL) SWIG_fail;
23246 temp2 = true;
23247 }
23248 {
23249 arg3 = &temp3;
23250 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
23251 }
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 resultobj = SWIG_Py_Void();
23259 {
23260 if (temp2)
23261 delete arg2;
23262 }
23263 return resultobj;
23264 fail:
23265 {
23266 if (temp2)
23267 delete arg2;
23268 }
23269 return NULL;
23270 }
23271
23272
23273 SWIGINTERN PyObject *_wrap_ColourDatabase_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj = 0;
23275 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23276 wxString *arg2 = 0 ;
23277 int arg3 ;
23278 int arg4 ;
23279 int arg5 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 bool temp2 = false ;
23283 int val3 ;
23284 int ecode3 = 0 ;
23285 int val4 ;
23286 int ecode4 = 0 ;
23287 int val5 ;
23288 int ecode5 = 0 ;
23289 PyObject * obj0 = 0 ;
23290 PyObject * obj1 = 0 ;
23291 PyObject * obj2 = 0 ;
23292 PyObject * obj3 = 0 ;
23293 PyObject * obj4 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23300 if (!SWIG_IsOK(res1)) {
23301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Append" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
23302 }
23303 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23304 {
23305 arg2 = wxString_in_helper(obj1);
23306 if (arg2 == NULL) SWIG_fail;
23307 temp2 = true;
23308 }
23309 ecode3 = SWIG_AsVal_int(obj2, &val3);
23310 if (!SWIG_IsOK(ecode3)) {
23311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourDatabase_Append" "', expected argument " "3"" of type '" "int""'");
23312 }
23313 arg3 = static_cast< int >(val3);
23314 ecode4 = SWIG_AsVal_int(obj3, &val4);
23315 if (!SWIG_IsOK(ecode4)) {
23316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourDatabase_Append" "', expected argument " "4"" of type '" "int""'");
23317 }
23318 arg4 = static_cast< int >(val4);
23319 ecode5 = SWIG_AsVal_int(obj4, &val5);
23320 if (!SWIG_IsOK(ecode5)) {
23321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourDatabase_Append" "', expected argument " "5"" of type '" "int""'");
23322 }
23323 arg5 = static_cast< int >(val5);
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 resultobj = SWIG_Py_Void();
23331 {
23332 if (temp2)
23333 delete arg2;
23334 }
23335 return resultobj;
23336 fail:
23337 {
23338 if (temp2)
23339 delete arg2;
23340 }
23341 return NULL;
23342 }
23343
23344
23345 SWIGINTERN PyObject *ColourDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23346 PyObject *obj;
23347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23348 SWIG_TypeNewClientData(SWIGTYPE_p_wxColourDatabase, SWIG_NewClientData(obj));
23349 return SWIG_Py_Void();
23350 }
23351
23352 SWIGINTERN PyObject *ColourDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23353 return SWIG_Python_InitShadowInstance(args);
23354 }
23355
23356 SWIGINTERN PyObject *_wrap_FontList_AddFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23357 PyObject *resultobj = 0;
23358 wxFontList *arg1 = (wxFontList *) 0 ;
23359 wxFont *arg2 = (wxFont *) 0 ;
23360 void *argp1 = 0 ;
23361 int res1 = 0 ;
23362 void *argp2 = 0 ;
23363 int res2 = 0 ;
23364 PyObject * obj0 = 0 ;
23365 PyObject * obj1 = 0 ;
23366 char * kwnames[] = {
23367 (char *) "self",(char *) "font", NULL
23368 };
23369
23370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) SWIG_fail;
23371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
23372 if (!SWIG_IsOK(res1)) {
23373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_AddFont" "', expected argument " "1"" of type '" "wxFontList *""'");
23374 }
23375 arg1 = reinterpret_cast< wxFontList * >(argp1);
23376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
23377 if (!SWIG_IsOK(res2)) {
23378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_AddFont" "', expected argument " "2"" of type '" "wxFont *""'");
23379 }
23380 arg2 = reinterpret_cast< wxFont * >(argp2);
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 (arg1)->AddFont(arg2);
23384 wxPyEndAllowThreads(__tstate);
23385 if (PyErr_Occurred()) SWIG_fail;
23386 }
23387 resultobj = SWIG_Py_Void();
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 SWIGINTERN PyObject *_wrap_FontList_FindOrCreateFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj = 0;
23396 wxFontList *arg1 = (wxFontList *) 0 ;
23397 int arg2 ;
23398 int arg3 ;
23399 int arg4 ;
23400 int arg5 ;
23401 bool arg6 = (bool) false ;
23402 wxString const &arg7_defvalue = wxPyEmptyString ;
23403 wxString *arg7 = (wxString *) &arg7_defvalue ;
23404 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
23405 wxFont *result = 0 ;
23406 void *argp1 = 0 ;
23407 int res1 = 0 ;
23408 int val2 ;
23409 int ecode2 = 0 ;
23410 int val3 ;
23411 int ecode3 = 0 ;
23412 int val4 ;
23413 int ecode4 = 0 ;
23414 int val5 ;
23415 int ecode5 = 0 ;
23416 bool val6 ;
23417 int ecode6 = 0 ;
23418 bool temp7 = false ;
23419 int val8 ;
23420 int ecode8 = 0 ;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 PyObject * obj2 = 0 ;
23424 PyObject * obj3 = 0 ;
23425 PyObject * obj4 = 0 ;
23426 PyObject * obj5 = 0 ;
23427 PyObject * obj6 = 0 ;
23428 PyObject * obj7 = 0 ;
23429 char * kwnames[] = {
23430 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
23431 };
23432
23433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
23435 if (!SWIG_IsOK(res1)) {
23436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_FindOrCreateFont" "', expected argument " "1"" of type '" "wxFontList *""'");
23437 }
23438 arg1 = reinterpret_cast< wxFontList * >(argp1);
23439 ecode2 = SWIG_AsVal_int(obj1, &val2);
23440 if (!SWIG_IsOK(ecode2)) {
23441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontList_FindOrCreateFont" "', expected argument " "2"" of type '" "int""'");
23442 }
23443 arg2 = static_cast< int >(val2);
23444 ecode3 = SWIG_AsVal_int(obj2, &val3);
23445 if (!SWIG_IsOK(ecode3)) {
23446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontList_FindOrCreateFont" "', expected argument " "3"" of type '" "int""'");
23447 }
23448 arg3 = static_cast< int >(val3);
23449 ecode4 = SWIG_AsVal_int(obj3, &val4);
23450 if (!SWIG_IsOK(ecode4)) {
23451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontList_FindOrCreateFont" "', expected argument " "4"" of type '" "int""'");
23452 }
23453 arg4 = static_cast< int >(val4);
23454 ecode5 = SWIG_AsVal_int(obj4, &val5);
23455 if (!SWIG_IsOK(ecode5)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FontList_FindOrCreateFont" "', expected argument " "5"" of type '" "int""'");
23457 }
23458 arg5 = static_cast< int >(val5);
23459 if (obj5) {
23460 ecode6 = SWIG_AsVal_bool(obj5, &val6);
23461 if (!SWIG_IsOK(ecode6)) {
23462 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FontList_FindOrCreateFont" "', expected argument " "6"" of type '" "bool""'");
23463 }
23464 arg6 = static_cast< bool >(val6);
23465 }
23466 if (obj6) {
23467 {
23468 arg7 = wxString_in_helper(obj6);
23469 if (arg7 == NULL) SWIG_fail;
23470 temp7 = true;
23471 }
23472 }
23473 if (obj7) {
23474 ecode8 = SWIG_AsVal_int(obj7, &val8);
23475 if (!SWIG_IsOK(ecode8)) {
23476 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FontList_FindOrCreateFont" "', expected argument " "8"" of type '" "wxFontEncoding""'");
23477 }
23478 arg8 = static_cast< wxFontEncoding >(val8);
23479 }
23480 {
23481 PyThreadState* __tstate = wxPyBeginAllowThreads();
23482 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,arg8);
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
23487 {
23488 if (temp7)
23489 delete arg7;
23490 }
23491 return resultobj;
23492 fail:
23493 {
23494 if (temp7)
23495 delete arg7;
23496 }
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_FontList_RemoveFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj = 0;
23503 wxFontList *arg1 = (wxFontList *) 0 ;
23504 wxFont *arg2 = (wxFont *) 0 ;
23505 void *argp1 = 0 ;
23506 int res1 = 0 ;
23507 void *argp2 = 0 ;
23508 int res2 = 0 ;
23509 PyObject * obj0 = 0 ;
23510 PyObject * obj1 = 0 ;
23511 char * kwnames[] = {
23512 (char *) "self",(char *) "font", NULL
23513 };
23514
23515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) SWIG_fail;
23516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_RemoveFont" "', expected argument " "1"" of type '" "wxFontList *""'");
23519 }
23520 arg1 = reinterpret_cast< wxFontList * >(argp1);
23521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
23522 if (!SWIG_IsOK(res2)) {
23523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_RemoveFont" "', expected argument " "2"" of type '" "wxFont *""'");
23524 }
23525 arg2 = reinterpret_cast< wxFont * >(argp2);
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 (arg1)->RemoveFont(arg2);
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 resultobj = SWIG_Py_Void();
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *_wrap_FontList_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 PyObject *resultobj = 0;
23541 wxFontList *arg1 = (wxFontList *) 0 ;
23542 int result;
23543 void *argp1 = 0 ;
23544 int res1 = 0 ;
23545 PyObject *swig_obj[1] ;
23546
23547 if (!args) SWIG_fail;
23548 swig_obj[0] = args;
23549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
23550 if (!SWIG_IsOK(res1)) {
23551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_GetCount" "', expected argument " "1"" of type '" "wxFontList *""'");
23552 }
23553 arg1 = reinterpret_cast< wxFontList * >(argp1);
23554 {
23555 PyThreadState* __tstate = wxPyBeginAllowThreads();
23556 result = (int)(arg1)->GetCount();
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 resultobj = SWIG_From_int(static_cast< int >(result));
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 SWIGINTERN PyObject *FontList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23568 PyObject *obj;
23569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23570 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontList, SWIG_NewClientData(obj));
23571 return SWIG_Py_Void();
23572 }
23573
23574 SWIGINTERN int TheFontList_set(PyObject *) {
23575 SWIG_Error(SWIG_AttributeError,"Variable TheFontList is read-only.");
23576 return 1;
23577 }
23578
23579
23580 SWIGINTERN PyObject *TheFontList_get(void) {
23581 PyObject *pyobj = 0;
23582
23583 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheFontList), SWIGTYPE_p_wxFontList, 0 );
23584 return pyobj;
23585 }
23586
23587
23588 SWIGINTERN int ThePenList_set(PyObject *) {
23589 SWIG_Error(SWIG_AttributeError,"Variable ThePenList is read-only.");
23590 return 1;
23591 }
23592
23593
23594 SWIGINTERN PyObject *ThePenList_get(void) {
23595 PyObject *pyobj = 0;
23596
23597 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxThePenList), SWIGTYPE_p_wxPenList, 0 );
23598 return pyobj;
23599 }
23600
23601
23602 SWIGINTERN int TheBrushList_set(PyObject *) {
23603 SWIG_Error(SWIG_AttributeError,"Variable TheBrushList is read-only.");
23604 return 1;
23605 }
23606
23607
23608 SWIGINTERN PyObject *TheBrushList_get(void) {
23609 PyObject *pyobj = 0;
23610
23611 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0 );
23612 return pyobj;
23613 }
23614
23615
23616 SWIGINTERN int TheColourDatabase_set(PyObject *) {
23617 SWIG_Error(SWIG_AttributeError,"Variable TheColourDatabase is read-only.");
23618 return 1;
23619 }
23620
23621
23622 SWIGINTERN PyObject *TheColourDatabase_get(void) {
23623 PyObject *pyobj = 0;
23624
23625 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0 );
23626 return pyobj;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_new_Effects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23631 PyObject *resultobj = 0;
23632 wxEffects *result = 0 ;
23633
23634 if (!SWIG_Python_UnpackTuple(args,"new_Effects",0,0,0)) SWIG_fail;
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 result = (wxEffects *)new wxEffects();
23638 wxPyEndAllowThreads(__tstate);
23639 if (PyErr_Occurred()) SWIG_fail;
23640 }
23641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEffects, SWIG_POINTER_NEW | 0 );
23642 return resultobj;
23643 fail:
23644 return NULL;
23645 }
23646
23647
23648 SWIGINTERN PyObject *_wrap_Effects_GetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23649 PyObject *resultobj = 0;
23650 wxEffects *arg1 = (wxEffects *) 0 ;
23651 wxColour result;
23652 void *argp1 = 0 ;
23653 int res1 = 0 ;
23654 PyObject *swig_obj[1] ;
23655
23656 if (!args) SWIG_fail;
23657 swig_obj[0] = args;
23658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23659 if (!SWIG_IsOK(res1)) {
23660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetHighlightColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
23661 }
23662 arg1 = reinterpret_cast< wxEffects * >(argp1);
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = ((wxEffects const *)arg1)->GetHighlightColour();
23666 wxPyEndAllowThreads(__tstate);
23667 if (PyErr_Occurred()) SWIG_fail;
23668 }
23669 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 SWIGINTERN PyObject *_wrap_Effects_GetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23677 PyObject *resultobj = 0;
23678 wxEffects *arg1 = (wxEffects *) 0 ;
23679 wxColour result;
23680 void *argp1 = 0 ;
23681 int res1 = 0 ;
23682 PyObject *swig_obj[1] ;
23683
23684 if (!args) SWIG_fail;
23685 swig_obj[0] = args;
23686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23687 if (!SWIG_IsOK(res1)) {
23688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetLightShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23689 }
23690 arg1 = reinterpret_cast< wxEffects * >(argp1);
23691 {
23692 PyThreadState* __tstate = wxPyBeginAllowThreads();
23693 result = ((wxEffects const *)arg1)->GetLightShadow();
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 SWIGINTERN PyObject *_wrap_Effects_GetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23705 PyObject *resultobj = 0;
23706 wxEffects *arg1 = (wxEffects *) 0 ;
23707 wxColour result;
23708 void *argp1 = 0 ;
23709 int res1 = 0 ;
23710 PyObject *swig_obj[1] ;
23711
23712 if (!args) SWIG_fail;
23713 swig_obj[0] = args;
23714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23715 if (!SWIG_IsOK(res1)) {
23716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetFaceColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
23717 }
23718 arg1 = reinterpret_cast< wxEffects * >(argp1);
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = ((wxEffects const *)arg1)->GetFaceColour();
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 SWIGINTERN PyObject *_wrap_Effects_GetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23733 PyObject *resultobj = 0;
23734 wxEffects *arg1 = (wxEffects *) 0 ;
23735 wxColour result;
23736 void *argp1 = 0 ;
23737 int res1 = 0 ;
23738 PyObject *swig_obj[1] ;
23739
23740 if (!args) SWIG_fail;
23741 swig_obj[0] = args;
23742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetMediumShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23745 }
23746 arg1 = reinterpret_cast< wxEffects * >(argp1);
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 result = ((wxEffects const *)arg1)->GetMediumShadow();
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *_wrap_Effects_GetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 PyObject *resultobj = 0;
23762 wxEffects *arg1 = (wxEffects *) 0 ;
23763 wxColour result;
23764 void *argp1 = 0 ;
23765 int res1 = 0 ;
23766 PyObject *swig_obj[1] ;
23767
23768 if (!args) SWIG_fail;
23769 swig_obj[0] = args;
23770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23771 if (!SWIG_IsOK(res1)) {
23772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetDarkShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23773 }
23774 arg1 = reinterpret_cast< wxEffects * >(argp1);
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = ((wxEffects const *)arg1)->GetDarkShadow();
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 SWIGINTERN PyObject *_wrap_Effects_SetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj = 0;
23790 wxEffects *arg1 = (wxEffects *) 0 ;
23791 wxColour *arg2 = 0 ;
23792 void *argp1 = 0 ;
23793 int res1 = 0 ;
23794 wxColour temp2 ;
23795 PyObject * obj0 = 0 ;
23796 PyObject * obj1 = 0 ;
23797 char * kwnames[] = {
23798 (char *) "self",(char *) "c", NULL
23799 };
23800
23801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
23802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23803 if (!SWIG_IsOK(res1)) {
23804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetHighlightColour" "', expected argument " "1"" of type '" "wxEffects *""'");
23805 }
23806 arg1 = reinterpret_cast< wxEffects * >(argp1);
23807 {
23808 arg2 = &temp2;
23809 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23810 }
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 (arg1)->SetHighlightColour((wxColour const &)*arg2);
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_Py_Void();
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_Effects_SetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23825 PyObject *resultobj = 0;
23826 wxEffects *arg1 = (wxEffects *) 0 ;
23827 wxColour *arg2 = 0 ;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 wxColour temp2 ;
23831 PyObject * obj0 = 0 ;
23832 PyObject * obj1 = 0 ;
23833 char * kwnames[] = {
23834 (char *) "self",(char *) "c", NULL
23835 };
23836
23837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23839 if (!SWIG_IsOK(res1)) {
23840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetLightShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23841 }
23842 arg1 = reinterpret_cast< wxEffects * >(argp1);
23843 {
23844 arg2 = &temp2;
23845 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23846 }
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 (arg1)->SetLightShadow((wxColour const &)*arg2);
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 resultobj = SWIG_Py_Void();
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 SWIGINTERN PyObject *_wrap_Effects_SetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj = 0;
23862 wxEffects *arg1 = (wxEffects *) 0 ;
23863 wxColour *arg2 = 0 ;
23864 void *argp1 = 0 ;
23865 int res1 = 0 ;
23866 wxColour temp2 ;
23867 PyObject * obj0 = 0 ;
23868 PyObject * obj1 = 0 ;
23869 char * kwnames[] = {
23870 (char *) "self",(char *) "c", NULL
23871 };
23872
23873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) SWIG_fail;
23874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23875 if (!SWIG_IsOK(res1)) {
23876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetFaceColour" "', expected argument " "1"" of type '" "wxEffects *""'");
23877 }
23878 arg1 = reinterpret_cast< wxEffects * >(argp1);
23879 {
23880 arg2 = &temp2;
23881 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23882 }
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 (arg1)->SetFaceColour((wxColour const &)*arg2);
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 resultobj = SWIG_Py_Void();
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 SWIGINTERN PyObject *_wrap_Effects_SetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23897 PyObject *resultobj = 0;
23898 wxEffects *arg1 = (wxEffects *) 0 ;
23899 wxColour *arg2 = 0 ;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 wxColour temp2 ;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905 char * kwnames[] = {
23906 (char *) "self",(char *) "c", NULL
23907 };
23908
23909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23911 if (!SWIG_IsOK(res1)) {
23912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetMediumShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23913 }
23914 arg1 = reinterpret_cast< wxEffects * >(argp1);
23915 {
23916 arg2 = &temp2;
23917 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23918 }
23919 {
23920 PyThreadState* __tstate = wxPyBeginAllowThreads();
23921 (arg1)->SetMediumShadow((wxColour const &)*arg2);
23922 wxPyEndAllowThreads(__tstate);
23923 if (PyErr_Occurred()) SWIG_fail;
23924 }
23925 resultobj = SWIG_Py_Void();
23926 return resultobj;
23927 fail:
23928 return NULL;
23929 }
23930
23931
23932 SWIGINTERN PyObject *_wrap_Effects_SetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj = 0;
23934 wxEffects *arg1 = (wxEffects *) 0 ;
23935 wxColour *arg2 = 0 ;
23936 void *argp1 = 0 ;
23937 int res1 = 0 ;
23938 wxColour temp2 ;
23939 PyObject * obj0 = 0 ;
23940 PyObject * obj1 = 0 ;
23941 char * kwnames[] = {
23942 (char *) "self",(char *) "c", NULL
23943 };
23944
23945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23947 if (!SWIG_IsOK(res1)) {
23948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetDarkShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23949 }
23950 arg1 = reinterpret_cast< wxEffects * >(argp1);
23951 {
23952 arg2 = &temp2;
23953 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 (arg1)->SetDarkShadow((wxColour const &)*arg2);
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_Py_Void();
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_Effects_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 wxEffects *arg1 = (wxEffects *) 0 ;
23971 wxColour *arg2 = 0 ;
23972 wxColour *arg3 = 0 ;
23973 wxColour *arg4 = 0 ;
23974 wxColour *arg5 = 0 ;
23975 wxColour *arg6 = 0 ;
23976 void *argp1 = 0 ;
23977 int res1 = 0 ;
23978 wxColour temp2 ;
23979 wxColour temp3 ;
23980 wxColour temp4 ;
23981 wxColour temp5 ;
23982 wxColour temp6 ;
23983 PyObject * obj0 = 0 ;
23984 PyObject * obj1 = 0 ;
23985 PyObject * obj2 = 0 ;
23986 PyObject * obj3 = 0 ;
23987 PyObject * obj4 = 0 ;
23988 PyObject * obj5 = 0 ;
23989 char * kwnames[] = {
23990 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
23991 };
23992
23993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23995 if (!SWIG_IsOK(res1)) {
23996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_Set" "', expected argument " "1"" of type '" "wxEffects *""'");
23997 }
23998 arg1 = reinterpret_cast< wxEffects * >(argp1);
23999 {
24000 arg2 = &temp2;
24001 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24002 }
24003 {
24004 arg3 = &temp3;
24005 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
24006 }
24007 {
24008 arg4 = &temp4;
24009 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
24010 }
24011 {
24012 arg5 = &temp5;
24013 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
24014 }
24015 {
24016 arg6 = &temp6;
24017 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 resultobj = SWIG_Py_Void();
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 SWIGINTERN PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj = 0;
24034 wxEffects *arg1 = (wxEffects *) 0 ;
24035 wxDC *arg2 = 0 ;
24036 wxRect *arg3 = 0 ;
24037 int arg4 = (int) 1 ;
24038 void *argp1 = 0 ;
24039 int res1 = 0 ;
24040 void *argp2 = 0 ;
24041 int res2 = 0 ;
24042 wxRect temp3 ;
24043 int val4 ;
24044 int ecode4 = 0 ;
24045 PyObject * obj0 = 0 ;
24046 PyObject * obj1 = 0 ;
24047 PyObject * obj2 = 0 ;
24048 PyObject * obj3 = 0 ;
24049 char * kwnames[] = {
24050 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
24051 };
24052
24053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
24055 if (!SWIG_IsOK(res1)) {
24056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "1"" of type '" "wxEffects *""'");
24057 }
24058 arg1 = reinterpret_cast< wxEffects * >(argp1);
24059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
24060 if (!SWIG_IsOK(res2)) {
24061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
24062 }
24063 if (!argp2) {
24064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
24065 }
24066 arg2 = reinterpret_cast< wxDC * >(argp2);
24067 {
24068 arg3 = &temp3;
24069 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
24070 }
24071 if (obj3) {
24072 ecode4 = SWIG_AsVal_int(obj3, &val4);
24073 if (!SWIG_IsOK(ecode4)) {
24074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "4"" of type '" "int""'");
24075 }
24076 arg4 = static_cast< int >(val4);
24077 }
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 resultobj = SWIG_Py_Void();
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_Effects_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24092 PyObject *resultobj = 0;
24093 wxEffects *arg1 = (wxEffects *) 0 ;
24094 wxRect *arg2 = 0 ;
24095 wxDC *arg3 = 0 ;
24096 wxBitmap *arg4 = 0 ;
24097 bool result;
24098 void *argp1 = 0 ;
24099 int res1 = 0 ;
24100 wxRect temp2 ;
24101 void *argp3 = 0 ;
24102 int res3 = 0 ;
24103 void *argp4 = 0 ;
24104 int res4 = 0 ;
24105 PyObject * obj0 = 0 ;
24106 PyObject * obj1 = 0 ;
24107 PyObject * obj2 = 0 ;
24108 PyObject * obj3 = 0 ;
24109 char * kwnames[] = {
24110 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
24111 };
24112
24113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
24115 if (!SWIG_IsOK(res1)) {
24116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_TileBitmap" "', expected argument " "1"" of type '" "wxEffects *""'");
24117 }
24118 arg1 = reinterpret_cast< wxEffects * >(argp1);
24119 {
24120 arg2 = &temp2;
24121 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24122 }
24123 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24124 if (!SWIG_IsOK(res3)) {
24125 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
24126 }
24127 if (!argp3) {
24128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
24129 }
24130 arg3 = reinterpret_cast< wxDC * >(argp3);
24131 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 );
24132 if (!SWIG_IsOK(res4)) {
24133 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
24134 }
24135 if (!argp4) {
24136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
24137 }
24138 arg4 = reinterpret_cast< wxBitmap * >(argp4);
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 {
24146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *Effects_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *obj;
24156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24157 SWIG_TypeNewClientData(SWIGTYPE_p_wxEffects, SWIG_NewClientData(obj));
24158 return SWIG_Py_Void();
24159 }
24160
24161 SWIGINTERN PyObject *Effects_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24162 return SWIG_Python_InitShadowInstance(args);
24163 }
24164
24165 SWIGINTERN PyObject *_wrap_new_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj = 0;
24167 int arg1 ;
24168 int arg2 ;
24169 bool arg3 ;
24170 wxSplitterRenderParams *result = 0 ;
24171 int val1 ;
24172 int ecode1 = 0 ;
24173 int val2 ;
24174 int ecode2 = 0 ;
24175 bool val3 ;
24176 int ecode3 = 0 ;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 PyObject * obj2 = 0 ;
24180 char * kwnames[] = {
24181 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
24182 };
24183
24184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24185 ecode1 = SWIG_AsVal_int(obj0, &val1);
24186 if (!SWIG_IsOK(ecode1)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplitterRenderParams" "', expected argument " "1"" of type '" "int""'");
24188 }
24189 arg1 = static_cast< int >(val1);
24190 ecode2 = SWIG_AsVal_int(obj1, &val2);
24191 if (!SWIG_IsOK(ecode2)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SplitterRenderParams" "', expected argument " "2"" of type '" "int""'");
24193 }
24194 arg2 = static_cast< int >(val2);
24195 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24196 if (!SWIG_IsOK(ecode3)) {
24197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SplitterRenderParams" "', expected argument " "3"" of type '" "bool""'");
24198 }
24199 arg3 = static_cast< bool >(val3);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_NEW | 0 );
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_delete_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 PyObject *swig_obj[1] ;
24219
24220 if (!args) SWIG_fail;
24221 swig_obj[0] = args;
24222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_DISOWN | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplitterRenderParams" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
24225 }
24226 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
24227 {
24228 PyThreadState* __tstate = wxPyBeginAllowThreads();
24229 delete arg1;
24230
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 resultobj = SWIG_Py_Void();
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 SWIGINTERN PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24242 PyObject *resultobj = 0;
24243 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
24244 int result;
24245 void *argp1 = 0 ;
24246 int res1 = 0 ;
24247 PyObject *swig_obj[1] ;
24248
24249 if (!args) SWIG_fail;
24250 swig_obj[0] = args;
24251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
24252 if (!SWIG_IsOK(res1)) {
24253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_widthSash_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
24254 }
24255 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
24256 result = (int)(int) ((arg1)->widthSash);
24257 resultobj = SWIG_From_int(static_cast< int >(result));
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_SplitterRenderParams_border_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
24267 int result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_border_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
24277 }
24278 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
24279 result = (int)(int) ((arg1)->border);
24280 resultobj = SWIG_From_int(static_cast< int >(result));
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 SWIGINTERN PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 PyObject *resultobj = 0;
24289 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
24290 bool result;
24291 void *argp1 = 0 ;
24292 int res1 = 0 ;
24293 PyObject *swig_obj[1] ;
24294
24295 if (!args) SWIG_fail;
24296 swig_obj[0] = args;
24297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
24298 if (!SWIG_IsOK(res1)) {
24299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_isHotSensitive_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
24300 }
24301 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
24302 result = (bool)(bool) ((arg1)->isHotSensitive);
24303 resultobj = SWIG_From_bool(static_cast< bool >(result));
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *SplitterRenderParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *obj;
24312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24313 SWIG_TypeNewClientData(SWIGTYPE_p_wxSplitterRenderParams, SWIG_NewClientData(obj));
24314 return SWIG_Py_Void();
24315 }
24316
24317 SWIGINTERN PyObject *SplitterRenderParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24318 return SWIG_Python_InitShadowInstance(args);
24319 }
24320
24321 SWIGINTERN PyObject *_wrap_new_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24322 PyObject *resultobj = 0;
24323 int arg1 ;
24324 int arg2 ;
24325 wxRendererVersion *result = 0 ;
24326 int val1 ;
24327 int ecode1 = 0 ;
24328 int val2 ;
24329 int ecode2 = 0 ;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 char * kwnames[] = {
24333 (char *) "version_",(char *) "age_", NULL
24334 };
24335
24336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) SWIG_fail;
24337 ecode1 = SWIG_AsVal_int(obj0, &val1);
24338 if (!SWIG_IsOK(ecode1)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RendererVersion" "', expected argument " "1"" of type '" "int""'");
24340 }
24341 arg1 = static_cast< int >(val1);
24342 ecode2 = SWIG_AsVal_int(obj1, &val2);
24343 if (!SWIG_IsOK(ecode2)) {
24344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RendererVersion" "', expected argument " "2"" of type '" "int""'");
24345 }
24346 arg2 = static_cast< int >(val2);
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
24350 wxPyEndAllowThreads(__tstate);
24351 if (PyErr_Occurred()) SWIG_fail;
24352 }
24353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_NEW | 0 );
24354 return resultobj;
24355 fail:
24356 return NULL;
24357 }
24358
24359
24360 SWIGINTERN PyObject *_wrap_delete_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24361 PyObject *resultobj = 0;
24362 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
24363 void *argp1 = 0 ;
24364 int res1 = 0 ;
24365 PyObject *swig_obj[1] ;
24366
24367 if (!args) SWIG_fail;
24368 swig_obj[0] = args;
24369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_DISOWN | 0 );
24370 if (!SWIG_IsOK(res1)) {
24371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RendererVersion" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
24372 }
24373 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24374 {
24375 PyThreadState* __tstate = wxPyBeginAllowThreads();
24376 delete arg1;
24377
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_Py_Void();
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_RendererVersion_IsCompatible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24389 PyObject *resultobj = 0;
24390 wxRendererVersion *arg1 = 0 ;
24391 bool result;
24392 void *argp1 = 0 ;
24393 int res1 = 0 ;
24394 PyObject * obj0 = 0 ;
24395 char * kwnames[] = {
24396 (char *) "ver", NULL
24397 };
24398
24399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) SWIG_fail;
24400 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRendererVersion, 0 | 0);
24401 if (!SWIG_IsOK(res1)) {
24402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
24403 }
24404 if (!argp1) {
24405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
24406 }
24407 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
24411 wxPyEndAllowThreads(__tstate);
24412 if (PyErr_Occurred()) SWIG_fail;
24413 }
24414 {
24415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24416 }
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_RendererVersion_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24424 PyObject *resultobj = 0;
24425 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
24426 int result;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 PyObject *swig_obj[1] ;
24430
24431 if (!args) SWIG_fail;
24432 swig_obj[0] = args;
24433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
24434 if (!SWIG_IsOK(res1)) {
24435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_version_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
24436 }
24437 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24438 result = (int)(int) ((arg1)->version);
24439 resultobj = SWIG_From_int(static_cast< int >(result));
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *_wrap_RendererVersion_age_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *resultobj = 0;
24448 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
24449 int result;
24450 void *argp1 = 0 ;
24451 int res1 = 0 ;
24452 PyObject *swig_obj[1] ;
24453
24454 if (!args) SWIG_fail;
24455 swig_obj[0] = args;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_age_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
24459 }
24460 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24461 result = (int)(int) ((arg1)->age);
24462 resultobj = SWIG_From_int(static_cast< int >(result));
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 SWIGINTERN PyObject *RendererVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24470 PyObject *obj;
24471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24472 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererVersion, SWIG_NewClientData(obj));
24473 return SWIG_Py_Void();
24474 }
24475
24476 SWIGINTERN PyObject *RendererVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 return SWIG_Python_InitShadowInstance(args);
24478 }
24479
24480 SWIGINTERN PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj = 0;
24482 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24483 wxWindow *arg2 = (wxWindow *) 0 ;
24484 wxDC *arg3 = 0 ;
24485 wxRect *arg4 = 0 ;
24486 int arg5 = (int) 0 ;
24487 void *argp1 = 0 ;
24488 int res1 = 0 ;
24489 void *argp2 = 0 ;
24490 int res2 = 0 ;
24491 void *argp3 = 0 ;
24492 int res3 = 0 ;
24493 wxRect temp4 ;
24494 int val5 ;
24495 int ecode5 = 0 ;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 PyObject * obj2 = 0 ;
24499 PyObject * obj3 = 0 ;
24500 PyObject * obj4 = 0 ;
24501 char * kwnames[] = {
24502 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24503 };
24504
24505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24507 if (!SWIG_IsOK(res1)) {
24508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24509 }
24510 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24512 if (!SWIG_IsOK(res2)) {
24513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24514 }
24515 arg2 = reinterpret_cast< wxWindow * >(argp2);
24516 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24517 if (!SWIG_IsOK(res3)) {
24518 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
24519 }
24520 if (!argp3) {
24521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
24522 }
24523 arg3 = reinterpret_cast< wxDC * >(argp3);
24524 {
24525 arg4 = &temp4;
24526 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24527 }
24528 if (obj4) {
24529 ecode5 = SWIG_AsVal_int(obj4, &val5);
24530 if (!SWIG_IsOK(ecode5)) {
24531 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "5"" of type '" "int""'");
24532 }
24533 arg5 = static_cast< int >(val5);
24534 }
24535 {
24536 PyThreadState* __tstate = wxPyBeginAllowThreads();
24537 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_Py_Void();
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 SWIGINTERN PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj = 0;
24550 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24551 wxWindow *arg2 = (wxWindow *) 0 ;
24552 wxDC *arg3 = 0 ;
24553 wxRect *arg4 = 0 ;
24554 int arg5 = (int) 0 ;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 void *argp2 = 0 ;
24558 int res2 = 0 ;
24559 void *argp3 = 0 ;
24560 int res3 = 0 ;
24561 wxRect temp4 ;
24562 int val5 ;
24563 int ecode5 = 0 ;
24564 PyObject * obj0 = 0 ;
24565 PyObject * obj1 = 0 ;
24566 PyObject * obj2 = 0 ;
24567 PyObject * obj3 = 0 ;
24568 PyObject * obj4 = 0 ;
24569 char * kwnames[] = {
24570 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24571 };
24572
24573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24575 if (!SWIG_IsOK(res1)) {
24576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24577 }
24578 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24580 if (!SWIG_IsOK(res2)) {
24581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24582 }
24583 arg2 = reinterpret_cast< wxWindow * >(argp2);
24584 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24585 if (!SWIG_IsOK(res3)) {
24586 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
24587 }
24588 if (!argp3) {
24589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
24590 }
24591 arg3 = reinterpret_cast< wxDC * >(argp3);
24592 {
24593 arg4 = &temp4;
24594 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24595 }
24596 if (obj4) {
24597 ecode5 = SWIG_AsVal_int(obj4, &val5);
24598 if (!SWIG_IsOK(ecode5)) {
24599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "5"" of type '" "int""'");
24600 }
24601 arg5 = static_cast< int >(val5);
24602 }
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 resultobj = SWIG_Py_Void();
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj = 0;
24618 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24619 wxWindow *arg2 = (wxWindow *) 0 ;
24620 wxDC *arg3 = 0 ;
24621 wxRect *arg4 = 0 ;
24622 int arg5 = (int) 0 ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 void *argp2 = 0 ;
24626 int res2 = 0 ;
24627 void *argp3 = 0 ;
24628 int res3 = 0 ;
24629 wxRect temp4 ;
24630 int val5 ;
24631 int ecode5 = 0 ;
24632 PyObject * obj0 = 0 ;
24633 PyObject * obj1 = 0 ;
24634 PyObject * obj2 = 0 ;
24635 PyObject * obj3 = 0 ;
24636 PyObject * obj4 = 0 ;
24637 char * kwnames[] = {
24638 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24639 };
24640
24641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24643 if (!SWIG_IsOK(res1)) {
24644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24645 }
24646 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24648 if (!SWIG_IsOK(res2)) {
24649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "2"" of type '" "wxWindow *""'");
24650 }
24651 arg2 = reinterpret_cast< wxWindow * >(argp2);
24652 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24653 if (!SWIG_IsOK(res3)) {
24654 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
24655 }
24656 if (!argp3) {
24657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
24658 }
24659 arg3 = reinterpret_cast< wxDC * >(argp3);
24660 {
24661 arg4 = &temp4;
24662 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24663 }
24664 if (obj4) {
24665 ecode5 = SWIG_AsVal_int(obj4, &val5);
24666 if (!SWIG_IsOK(ecode5)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "5"" of type '" "int""'");
24668 }
24669 arg5 = static_cast< int >(val5);
24670 }
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 resultobj = SWIG_Py_Void();
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj = 0;
24686 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24687 wxWindow *arg2 = (wxWindow *) 0 ;
24688 wxDC *arg3 = 0 ;
24689 wxSize *arg4 = 0 ;
24690 int arg5 ;
24691 wxOrientation arg6 ;
24692 int arg7 = (int) 0 ;
24693 void *argp1 = 0 ;
24694 int res1 = 0 ;
24695 void *argp2 = 0 ;
24696 int res2 = 0 ;
24697 void *argp3 = 0 ;
24698 int res3 = 0 ;
24699 wxSize temp4 ;
24700 int val5 ;
24701 int ecode5 = 0 ;
24702 int val6 ;
24703 int ecode6 = 0 ;
24704 int val7 ;
24705 int ecode7 = 0 ;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 PyObject * obj2 = 0 ;
24709 PyObject * obj3 = 0 ;
24710 PyObject * obj4 = 0 ;
24711 PyObject * obj5 = 0 ;
24712 PyObject * obj6 = 0 ;
24713 char * kwnames[] = {
24714 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
24715 };
24716
24717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24721 }
24722 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24724 if (!SWIG_IsOK(res2)) {
24725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "2"" of type '" "wxWindow *""'");
24726 }
24727 arg2 = reinterpret_cast< wxWindow * >(argp2);
24728 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24729 if (!SWIG_IsOK(res3)) {
24730 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
24731 }
24732 if (!argp3) {
24733 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
24734 }
24735 arg3 = reinterpret_cast< wxDC * >(argp3);
24736 {
24737 arg4 = &temp4;
24738 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24739 }
24740 ecode5 = SWIG_AsVal_int(obj4, &val5);
24741 if (!SWIG_IsOK(ecode5)) {
24742 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "5"" of type '" "int""'");
24743 }
24744 arg5 = static_cast< int >(val5);
24745 ecode6 = SWIG_AsVal_int(obj5, &val6);
24746 if (!SWIG_IsOK(ecode6)) {
24747 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "6"" of type '" "wxOrientation""'");
24748 }
24749 arg6 = static_cast< wxOrientation >(val6);
24750 if (obj6) {
24751 ecode7 = SWIG_AsVal_int(obj6, &val7);
24752 if (!SWIG_IsOK(ecode7)) {
24753 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "7"" of type '" "int""'");
24754 }
24755 arg7 = static_cast< int >(val7);
24756 }
24757 {
24758 PyThreadState* __tstate = wxPyBeginAllowThreads();
24759 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,arg6,arg7);
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 resultobj = SWIG_Py_Void();
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj = 0;
24772 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24773 wxWindow *arg2 = (wxWindow *) 0 ;
24774 wxDC *arg3 = 0 ;
24775 wxRect *arg4 = 0 ;
24776 int arg5 = (int) 0 ;
24777 void *argp1 = 0 ;
24778 int res1 = 0 ;
24779 void *argp2 = 0 ;
24780 int res2 = 0 ;
24781 void *argp3 = 0 ;
24782 int res3 = 0 ;
24783 wxRect temp4 ;
24784 int val5 ;
24785 int ecode5 = 0 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 PyObject * obj2 = 0 ;
24789 PyObject * obj3 = 0 ;
24790 PyObject * obj4 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24799 }
24800 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24802 if (!SWIG_IsOK(res2)) {
24803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24804 }
24805 arg2 = reinterpret_cast< wxWindow * >(argp2);
24806 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24807 if (!SWIG_IsOK(res3)) {
24808 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
24809 }
24810 if (!argp3) {
24811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
24812 }
24813 arg3 = reinterpret_cast< wxDC * >(argp3);
24814 {
24815 arg4 = &temp4;
24816 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24817 }
24818 if (obj4) {
24819 ecode5 = SWIG_AsVal_int(obj4, &val5);
24820 if (!SWIG_IsOK(ecode5)) {
24821 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "5"" of type '" "int""'");
24822 }
24823 arg5 = static_cast< int >(val5);
24824 }
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 resultobj = SWIG_Py_Void();
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 SWIGINTERN PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj = 0;
24840 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24841 wxWindow *arg2 = (wxWindow *) 0 ;
24842 wxDC *arg3 = 0 ;
24843 wxRect *arg4 = 0 ;
24844 int arg5 = (int) 0 ;
24845 void *argp1 = 0 ;
24846 int res1 = 0 ;
24847 void *argp2 = 0 ;
24848 int res2 = 0 ;
24849 void *argp3 = 0 ;
24850 int res3 = 0 ;
24851 wxRect temp4 ;
24852 int val5 ;
24853 int ecode5 = 0 ;
24854 PyObject * obj0 = 0 ;
24855 PyObject * obj1 = 0 ;
24856 PyObject * obj2 = 0 ;
24857 PyObject * obj3 = 0 ;
24858 PyObject * obj4 = 0 ;
24859 char * kwnames[] = {
24860 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24861 };
24862
24863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24867 }
24868 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24870 if (!SWIG_IsOK(res2)) {
24871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "2"" of type '" "wxWindow *""'");
24872 }
24873 arg2 = reinterpret_cast< wxWindow * >(argp2);
24874 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24875 if (!SWIG_IsOK(res3)) {
24876 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
24877 }
24878 if (!argp3) {
24879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
24880 }
24881 arg3 = reinterpret_cast< wxDC * >(argp3);
24882 {
24883 arg4 = &temp4;
24884 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24885 }
24886 if (obj4) {
24887 ecode5 = SWIG_AsVal_int(obj4, &val5);
24888 if (!SWIG_IsOK(ecode5)) {
24889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "5"" of type '" "int""'");
24890 }
24891 arg5 = static_cast< int >(val5);
24892 }
24893 {
24894 PyThreadState* __tstate = wxPyBeginAllowThreads();
24895 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 resultobj = SWIG_Py_Void();
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj = 0;
24908 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24909 wxWindow *arg2 = (wxWindow *) 0 ;
24910 SwigValueWrapper<wxSplitterRenderParams > result;
24911 void *argp1 = 0 ;
24912 int res1 = 0 ;
24913 void *argp2 = 0 ;
24914 int res2 = 0 ;
24915 PyObject * obj0 = 0 ;
24916 PyObject * obj1 = 0 ;
24917 char * kwnames[] = {
24918 (char *) "self",(char *) "win", NULL
24919 };
24920
24921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) SWIG_fail;
24922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24923 if (!SWIG_IsOK(res1)) {
24924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24925 }
24926 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24928 if (!SWIG_IsOK(res2)) {
24929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "2"" of type '" "wxWindow const *""'");
24930 }
24931 arg2 = reinterpret_cast< wxWindow * >(argp2);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_NewPointerObj((new wxSplitterRenderParams(static_cast< const wxSplitterRenderParams& >(result))), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_OWN | 0 );
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_RendererNative_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxRendererNative *result = 0 ;
24948
24949 if (!SWIG_Python_UnpackTuple(args,"RendererNative_Get",0,0,0)) SWIG_fail;
24950 {
24951 PyThreadState* __tstate = wxPyBeginAllowThreads();
24952 {
24953 wxRendererNative &_result_ref = wxRendererNative::Get();
24954 result = (wxRendererNative *) &_result_ref;
24955 }
24956 wxPyEndAllowThreads(__tstate);
24957 if (PyErr_Occurred()) SWIG_fail;
24958 }
24959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_RendererNative_GetGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24967 PyObject *resultobj = 0;
24968 wxRendererNative *result = 0 ;
24969
24970 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetGeneric",0,0,0)) SWIG_fail;
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 {
24974 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
24975 result = (wxRendererNative *) &_result_ref;
24976 }
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_RendererNative_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 wxRendererNative *result = 0 ;
24990
24991 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetDefault",0,0,0)) SWIG_fail;
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 {
24995 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
24996 result = (wxRendererNative *) &_result_ref;
24997 }
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
25002 return resultobj;
25003 fail:
25004 return NULL;
25005 }
25006
25007
25008 SWIGINTERN PyObject *_wrap_RendererNative_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25009 PyObject *resultobj = 0;
25010 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
25011 wxRendererNative *result = 0 ;
25012 void *argp1 = 0 ;
25013 int res1 = 0 ;
25014 PyObject * obj0 = 0 ;
25015 char * kwnames[] = {
25016 (char *) "renderer", NULL
25017 };
25018
25019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) SWIG_fail;
25020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_Set" "', expected argument " "1"" of type '" "wxRendererNative *""'");
25023 }
25024 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (wxRendererNative *)wxRendererNative::Set(arg1);
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
25032 return resultobj;
25033 fail:
25034 return NULL;
25035 }
25036
25037
25038 SWIGINTERN PyObject *_wrap_RendererNative_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25039 PyObject *resultobj = 0;
25040 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
25041 SwigValueWrapper<wxRendererVersion > result;
25042 void *argp1 = 0 ;
25043 int res1 = 0 ;
25044 PyObject *swig_obj[1] ;
25045
25046 if (!args) SWIG_fail;
25047 swig_obj[0] = args;
25048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
25049 if (!SWIG_IsOK(res1)) {
25050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetVersion" "', expected argument " "1"" of type '" "wxRendererNative const *""'");
25051 }
25052 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 result = ((wxRendererNative const *)arg1)->GetVersion();
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 resultobj = SWIG_NewPointerObj((new wxRendererVersion(static_cast< const wxRendererVersion& >(result))), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_OWN | 0 );
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *RendererNative_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25067 PyObject *obj;
25068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25069 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererNative, SWIG_NewClientData(obj));
25070 return SWIG_Py_Void();
25071 }
25072
25073 static PyMethodDef SwigMethods[] = {
25074 { (char *)"new_GDIObject", (PyCFunction)_wrap_new_GDIObject, METH_NOARGS, NULL},
25075 { (char *)"delete_GDIObject", (PyCFunction)_wrap_delete_GDIObject, METH_O, NULL},
25076 { (char *)"GDIObject_GetVisible", (PyCFunction)_wrap_GDIObject_GetVisible, METH_O, NULL},
25077 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
25078 { (char *)"GDIObject_IsNull", (PyCFunction)_wrap_GDIObject_IsNull, METH_O, NULL},
25079 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
25080 { (char *)"GDIObject_swiginit", GDIObject_swiginit, METH_VARARGS, NULL},
25081 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
25082 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
25083 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
25084 { (char *)"delete_Colour", (PyCFunction)_wrap_delete_Colour, METH_O, NULL},
25085 { (char *)"Colour_Red", (PyCFunction)_wrap_Colour_Red, METH_O, NULL},
25086 { (char *)"Colour_Green", (PyCFunction)_wrap_Colour_Green, METH_O, NULL},
25087 { (char *)"Colour_Blue", (PyCFunction)_wrap_Colour_Blue, METH_O, NULL},
25088 { (char *)"Colour_Ok", (PyCFunction)_wrap_Colour_Ok, METH_O, NULL},
25089 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
25090 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
25091 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
25092 { (char *)"Colour_GetPixel", (PyCFunction)_wrap_Colour_GetPixel, METH_O, NULL},
25093 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
25094 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
25095 { (char *)"Colour_Get", (PyCFunction)_wrap_Colour_Get, METH_O, NULL},
25096 { (char *)"Colour_GetRGB", (PyCFunction)_wrap_Colour_GetRGB, METH_O, NULL},
25097 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
25098 { (char *)"Colour_swiginit", Colour_swiginit, METH_VARARGS, NULL},
25099 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
25100 { (char *)"delete_Palette", (PyCFunction)_wrap_delete_Palette, METH_O, NULL},
25101 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
25102 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
25103 { (char *)"Palette_GetColoursCount", (PyCFunction)_wrap_Palette_GetColoursCount, METH_O, NULL},
25104 { (char *)"Palette_Ok", (PyCFunction)_wrap_Palette_Ok, METH_O, NULL},
25105 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
25106 { (char *)"Palette_swiginit", Palette_swiginit, METH_VARARGS, NULL},
25107 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
25108 { (char *)"delete_Pen", (PyCFunction)_wrap_delete_Pen, METH_O, NULL},
25109 { (char *)"Pen_GetCap", (PyCFunction)_wrap_Pen_GetCap, METH_O, NULL},
25110 { (char *)"Pen_GetColour", (PyCFunction)_wrap_Pen_GetColour, METH_O, NULL},
25111 { (char *)"Pen_GetJoin", (PyCFunction)_wrap_Pen_GetJoin, METH_O, NULL},
25112 { (char *)"Pen_GetStyle", (PyCFunction)_wrap_Pen_GetStyle, METH_O, NULL},
25113 { (char *)"Pen_GetWidth", (PyCFunction)_wrap_Pen_GetWidth, METH_O, NULL},
25114 { (char *)"Pen_Ok", (PyCFunction)_wrap_Pen_Ok, METH_O, NULL},
25115 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
25116 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
25117 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
25118 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
25119 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
25120 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
25121 { (char *)"Pen_GetDashes", (PyCFunction)_wrap_Pen_GetDashes, METH_O, NULL},
25122 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
25123 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
25124 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
25125 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
25126 { (char *)"Pen_swiginit", Pen_swiginit, METH_VARARGS, NULL},
25127 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
25128 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25129 { (char *)"delete_Brush", (PyCFunction)_wrap_delete_Brush, METH_O, NULL},
25130 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
25131 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
25132 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
25133 { (char *)"Brush_GetColour", (PyCFunction)_wrap_Brush_GetColour, METH_O, NULL},
25134 { (char *)"Brush_GetStyle", (PyCFunction)_wrap_Brush_GetStyle, METH_O, NULL},
25135 { (char *)"Brush_GetStipple", (PyCFunction)_wrap_Brush_GetStipple, METH_O, NULL},
25136 { (char *)"Brush_IsHatch", (PyCFunction)_wrap_Brush_IsHatch, METH_O, NULL},
25137 { (char *)"Brush_Ok", (PyCFunction)_wrap_Brush_Ok, METH_O, NULL},
25138 { (char *)"Brush_MacGetTheme", (PyCFunction)_wrap_Brush_MacGetTheme, METH_O, NULL},
25139 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
25140 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
25141 { (char *)"Brush_swiginit", Brush_swiginit, METH_VARARGS, NULL},
25142 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25143 { (char *)"delete_Bitmap", (PyCFunction)_wrap_delete_Bitmap, METH_O, NULL},
25144 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25145 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25146 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
25147 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
25148 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
25149 { (char *)"Bitmap_Ok", (PyCFunction)_wrap_Bitmap_Ok, METH_O, NULL},
25150 { (char *)"Bitmap_GetWidth", (PyCFunction)_wrap_Bitmap_GetWidth, METH_O, NULL},
25151 { (char *)"Bitmap_GetHeight", (PyCFunction)_wrap_Bitmap_GetHeight, METH_O, NULL},
25152 { (char *)"Bitmap_GetDepth", (PyCFunction)_wrap_Bitmap_GetDepth, METH_O, NULL},
25153 { (char *)"Bitmap_GetSize", (PyCFunction)_wrap_Bitmap_GetSize, METH_O, NULL},
25154 { (char *)"Bitmap_ConvertToImage", (PyCFunction)_wrap_Bitmap_ConvertToImage, METH_O, NULL},
25155 { (char *)"Bitmap_GetMask", (PyCFunction)_wrap_Bitmap_GetMask, METH_O, NULL},
25156 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
25157 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
25158 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25159 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
25160 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
25161 { (char *)"Bitmap_GetPalette", (PyCFunction)_wrap_Bitmap_GetPalette, METH_O, NULL},
25162 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25163 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
25164 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
25165 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
25166 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
25167 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
25168 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
25169 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
25170 { (char *)"Bitmap_swiginit", Bitmap_swiginit, METH_VARARGS, NULL},
25171 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
25172 { (char *)"delete_Mask", (PyCFunction)_wrap_delete_Mask, METH_O, NULL},
25173 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
25174 { (char *)"Mask_swiginit", Mask_swiginit, METH_VARARGS, NULL},
25175 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
25176 { (char *)"delete_Icon", (PyCFunction)_wrap_delete_Icon, METH_O, NULL},
25177 { (char *)"new_EmptyIcon", (PyCFunction)_wrap_new_EmptyIcon, METH_NOARGS, NULL},
25178 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
25179 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25180 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
25181 { (char *)"Icon_Ok", (PyCFunction)_wrap_Icon_Ok, METH_O, NULL},
25182 { (char *)"Icon_GetWidth", (PyCFunction)_wrap_Icon_GetWidth, METH_O, NULL},
25183 { (char *)"Icon_GetHeight", (PyCFunction)_wrap_Icon_GetHeight, METH_O, NULL},
25184 { (char *)"Icon_GetDepth", (PyCFunction)_wrap_Icon_GetDepth, METH_O, NULL},
25185 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
25186 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
25187 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
25188 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25189 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
25190 { (char *)"Icon_swiginit", Icon_swiginit, METH_VARARGS, NULL},
25191 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
25192 { (char *)"delete_IconLocation", (PyCFunction)_wrap_delete_IconLocation, METH_O, NULL},
25193 { (char *)"IconLocation_IsOk", (PyCFunction)_wrap_IconLocation_IsOk, METH_O, NULL},
25194 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
25195 { (char *)"IconLocation_GetFileName", (PyCFunction)_wrap_IconLocation_GetFileName, METH_O, NULL},
25196 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
25197 { (char *)"IconLocation_GetIndex", (PyCFunction)_wrap_IconLocation_GetIndex, METH_O, NULL},
25198 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
25199 { (char *)"IconLocation_swiginit", IconLocation_swiginit, METH_VARARGS, NULL},
25200 { (char *)"new_IconBundle", (PyCFunction)_wrap_new_IconBundle, METH_NOARGS, NULL},
25201 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
25202 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25203 { (char *)"delete_IconBundle", (PyCFunction)_wrap_delete_IconBundle, METH_O, NULL},
25204 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25205 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
25206 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25207 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
25208 { (char *)"IconBundle_swiginit", IconBundle_swiginit, METH_VARARGS, NULL},
25209 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
25210 { (char *)"delete_Cursor", (PyCFunction)_wrap_delete_Cursor, METH_O, NULL},
25211 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
25212 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
25213 { (char *)"Cursor_Ok", (PyCFunction)_wrap_Cursor_Ok, METH_O, NULL},
25214 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
25215 { (char *)"Cursor_swiginit", Cursor_swiginit, METH_VARARGS, NULL},
25216 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
25217 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25218 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
25219 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
25220 { (char *)"delete_Region", (PyCFunction)_wrap_delete_Region, METH_O, NULL},
25221 { (char *)"Region_Clear", (PyCFunction)_wrap_Region_Clear, METH_O, NULL},
25222 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
25223 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
25224 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25225 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
25226 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
25227 { (char *)"Region_GetBox", (PyCFunction)_wrap_Region_GetBox, METH_O, NULL},
25228 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
25229 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
25230 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25231 { (char *)"Region_IsEmpty", (PyCFunction)_wrap_Region_IsEmpty, METH_O, NULL},
25232 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
25233 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
25234 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25235 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
25236 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
25237 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25238 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
25239 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
25240 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25241 { (char *)"Region_ConvertToBitmap", (PyCFunction)_wrap_Region_ConvertToBitmap, METH_O, NULL},
25242 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25243 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
25244 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
25245 { (char *)"Region_swiginit", Region_swiginit, METH_VARARGS, NULL},
25246 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
25247 { (char *)"delete_RegionIterator", (PyCFunction)_wrap_delete_RegionIterator, METH_O, NULL},
25248 { (char *)"RegionIterator_GetX", (PyCFunction)_wrap_RegionIterator_GetX, METH_O, NULL},
25249 { (char *)"RegionIterator_GetY", (PyCFunction)_wrap_RegionIterator_GetY, METH_O, NULL},
25250 { (char *)"RegionIterator_GetW", (PyCFunction)_wrap_RegionIterator_GetW, METH_O, NULL},
25251 { (char *)"RegionIterator_GetWidth", (PyCFunction)_wrap_RegionIterator_GetWidth, METH_O, NULL},
25252 { (char *)"RegionIterator_GetH", (PyCFunction)_wrap_RegionIterator_GetH, METH_O, NULL},
25253 { (char *)"RegionIterator_GetHeight", (PyCFunction)_wrap_RegionIterator_GetHeight, METH_O, NULL},
25254 { (char *)"RegionIterator_GetRect", (PyCFunction)_wrap_RegionIterator_GetRect, METH_O, NULL},
25255 { (char *)"RegionIterator_HaveRects", (PyCFunction)_wrap_RegionIterator_HaveRects, METH_O, NULL},
25256 { (char *)"RegionIterator_Reset", (PyCFunction)_wrap_RegionIterator_Reset, METH_O, NULL},
25257 { (char *)"RegionIterator_Next", (PyCFunction)_wrap_RegionIterator_Next, METH_O, NULL},
25258 { (char *)"RegionIterator___nonzero__", (PyCFunction)_wrap_RegionIterator___nonzero__, METH_O, NULL},
25259 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
25260 { (char *)"RegionIterator_swiginit", RegionIterator_swiginit, METH_VARARGS, NULL},
25261 { (char *)"new_NativeFontInfo", (PyCFunction)_wrap_new_NativeFontInfo, METH_NOARGS, NULL},
25262 { (char *)"delete_NativeFontInfo", (PyCFunction)_wrap_delete_NativeFontInfo, METH_O, NULL},
25263 { (char *)"NativeFontInfo_Init", (PyCFunction)_wrap_NativeFontInfo_Init, METH_O, NULL},
25264 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
25265 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction)_wrap_NativeFontInfo_GetPointSize, METH_O, NULL},
25266 { (char *)"NativeFontInfo_GetStyle", (PyCFunction)_wrap_NativeFontInfo_GetStyle, METH_O, NULL},
25267 { (char *)"NativeFontInfo_GetWeight", (PyCFunction)_wrap_NativeFontInfo_GetWeight, METH_O, NULL},
25268 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction)_wrap_NativeFontInfo_GetUnderlined, METH_O, NULL},
25269 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction)_wrap_NativeFontInfo_GetFaceName, METH_O, NULL},
25270 { (char *)"NativeFontInfo_GetFamily", (PyCFunction)_wrap_NativeFontInfo_GetFamily, METH_O, NULL},
25271 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction)_wrap_NativeFontInfo_GetEncoding, METH_O, NULL},
25272 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25273 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
25274 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
25275 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
25276 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
25277 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
25278 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25279 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
25280 { (char *)"NativeFontInfo_ToString", (PyCFunction)_wrap_NativeFontInfo_ToString, METH_O, NULL},
25281 { (char *)"NativeFontInfo___str__", (PyCFunction)_wrap_NativeFontInfo___str__, METH_O, NULL},
25282 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
25283 { (char *)"NativeFontInfo_ToUserString", (PyCFunction)_wrap_NativeFontInfo_ToUserString, METH_O, NULL},
25284 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
25285 { (char *)"NativeFontInfo_swiginit", NativeFontInfo_swiginit, METH_VARARGS, NULL},
25286 { (char *)"NativeEncodingInfo_facename_set", _wrap_NativeEncodingInfo_facename_set, METH_VARARGS, NULL},
25287 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction)_wrap_NativeEncodingInfo_facename_get, METH_O, NULL},
25288 { (char *)"NativeEncodingInfo_encoding_set", _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS, NULL},
25289 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction)_wrap_NativeEncodingInfo_encoding_get, METH_O, NULL},
25290 { (char *)"new_NativeEncodingInfo", (PyCFunction)_wrap_new_NativeEncodingInfo, METH_NOARGS, NULL},
25291 { (char *)"delete_NativeEncodingInfo", (PyCFunction)_wrap_delete_NativeEncodingInfo, METH_O, NULL},
25292 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
25293 { (char *)"NativeEncodingInfo_ToString", (PyCFunction)_wrap_NativeEncodingInfo_ToString, METH_O, NULL},
25294 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
25295 { (char *)"NativeEncodingInfo_swiginit", NativeEncodingInfo_swiginit, METH_VARARGS, NULL},
25296 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25297 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25298 { (char *)"new_FontMapper", (PyCFunction)_wrap_new_FontMapper, METH_NOARGS, NULL},
25299 { (char *)"delete_FontMapper", (PyCFunction)_wrap_delete_FontMapper, METH_O, NULL},
25300 { (char *)"FontMapper_Get", (PyCFunction)_wrap_FontMapper_Get, METH_NOARGS, NULL},
25301 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
25302 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25303 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction)_wrap_FontMapper_GetSupportedEncodingsCount, METH_NOARGS, NULL},
25304 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25305 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
25306 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
25307 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
25308 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
25309 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction)_wrap_FontMapper_GetDefaultConfigPath, METH_NOARGS, NULL},
25310 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25311 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
25312 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
25313 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
25314 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
25315 { (char *)"FontMapper_swiginit", FontMapper_swiginit, METH_VARARGS, NULL},
25316 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
25317 { (char *)"delete_Font", (PyCFunction)_wrap_delete_Font, METH_O, NULL},
25318 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
25319 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
25320 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
25321 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
25322 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
25323 { (char *)"Font_Ok", (PyCFunction)_wrap_Font_Ok, METH_O, NULL},
25324 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
25325 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
25326 { (char *)"Font_GetPointSize", (PyCFunction)_wrap_Font_GetPointSize, METH_O, NULL},
25327 { (char *)"Font_GetPixelSize", (PyCFunction)_wrap_Font_GetPixelSize, METH_O, NULL},
25328 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction)_wrap_Font_IsUsingSizeInPixels, METH_O, NULL},
25329 { (char *)"Font_GetFamily", (PyCFunction)_wrap_Font_GetFamily, METH_O, NULL},
25330 { (char *)"Font_GetStyle", (PyCFunction)_wrap_Font_GetStyle, METH_O, NULL},
25331 { (char *)"Font_GetWeight", (PyCFunction)_wrap_Font_GetWeight, METH_O, NULL},
25332 { (char *)"Font_GetUnderlined", (PyCFunction)_wrap_Font_GetUnderlined, METH_O, NULL},
25333 { (char *)"Font_GetFaceName", (PyCFunction)_wrap_Font_GetFaceName, METH_O, NULL},
25334 { (char *)"Font_GetEncoding", (PyCFunction)_wrap_Font_GetEncoding, METH_O, NULL},
25335 { (char *)"Font_GetNativeFontInfo", (PyCFunction)_wrap_Font_GetNativeFontInfo, METH_O, NULL},
25336 { (char *)"Font_IsFixedWidth", (PyCFunction)_wrap_Font_IsFixedWidth, METH_O, NULL},
25337 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoDesc, METH_O, NULL},
25338 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoUserDesc, METH_O, NULL},
25339 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25340 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
25341 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
25342 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
25343 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
25344 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
25345 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
25346 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25347 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
25348 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
25349 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
25350 { (char *)"Font_GetFamilyString", (PyCFunction)_wrap_Font_GetFamilyString, METH_O, NULL},
25351 { (char *)"Font_GetStyleString", (PyCFunction)_wrap_Font_GetStyleString, METH_O, NULL},
25352 { (char *)"Font_GetWeightString", (PyCFunction)_wrap_Font_GetWeightString, METH_O, NULL},
25353 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
25354 { (char *)"Font_GetNoAntiAliasing", (PyCFunction)_wrap_Font_GetNoAntiAliasing, METH_O, NULL},
25355 { (char *)"Font_GetDefaultEncoding", (PyCFunction)_wrap_Font_GetDefaultEncoding, METH_NOARGS, NULL},
25356 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
25357 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
25358 { (char *)"Font_swiginit", Font_swiginit, METH_VARARGS, NULL},
25359 { (char *)"new_FontEnumerator", (PyCFunction)_wrap_new_FontEnumerator, METH_NOARGS, NULL},
25360 { (char *)"delete_FontEnumerator", (PyCFunction)_wrap_delete_FontEnumerator, METH_O, NULL},
25361 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
25362 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
25363 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
25364 { (char *)"FontEnumerator_GetEncodings", (PyCFunction)_wrap_FontEnumerator_GetEncodings, METH_O, NULL},
25365 { (char *)"FontEnumerator_GetFacenames", (PyCFunction)_wrap_FontEnumerator_GetFacenames, METH_O, NULL},
25366 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
25367 { (char *)"FontEnumerator_swiginit", FontEnumerator_swiginit, METH_VARARGS, NULL},
25368 { (char *)"LanguageInfo_Language_set", _wrap_LanguageInfo_Language_set, METH_VARARGS, NULL},
25369 { (char *)"LanguageInfo_Language_get", (PyCFunction)_wrap_LanguageInfo_Language_get, METH_O, NULL},
25370 { (char *)"LanguageInfo_CanonicalName_set", _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS, NULL},
25371 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction)_wrap_LanguageInfo_CanonicalName_get, METH_O, NULL},
25372 { (char *)"LanguageInfo_Description_set", _wrap_LanguageInfo_Description_set, METH_VARARGS, NULL},
25373 { (char *)"LanguageInfo_Description_get", (PyCFunction)_wrap_LanguageInfo_Description_get, METH_O, NULL},
25374 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
25375 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
25376 { (char *)"delete_Locale", (PyCFunction)_wrap_delete_Locale, METH_O, NULL},
25377 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
25378 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
25379 { (char *)"Locale_GetSystemLanguage", (PyCFunction)_wrap_Locale_GetSystemLanguage, METH_NOARGS, NULL},
25380 { (char *)"Locale_GetSystemEncoding", (PyCFunction)_wrap_Locale_GetSystemEncoding, METH_NOARGS, NULL},
25381 { (char *)"Locale_GetSystemEncodingName", (PyCFunction)_wrap_Locale_GetSystemEncodingName, METH_NOARGS, NULL},
25382 { (char *)"Locale_IsOk", (PyCFunction)_wrap_Locale_IsOk, METH_O, NULL},
25383 { (char *)"Locale_GetLocale", (PyCFunction)_wrap_Locale_GetLocale, METH_O, NULL},
25384 { (char *)"Locale_GetLanguage", (PyCFunction)_wrap_Locale_GetLanguage, METH_O, NULL},
25385 { (char *)"Locale_GetSysName", (PyCFunction)_wrap_Locale_GetSysName, METH_O, NULL},
25386 { (char *)"Locale_GetCanonicalName", (PyCFunction)_wrap_Locale_GetCanonicalName, METH_O, NULL},
25387 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
25388 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
25389 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
25390 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
25391 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
25392 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
25393 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
25394 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
25395 { (char *)"Locale_GetName", (PyCFunction)_wrap_Locale_GetName, METH_O, NULL},
25396 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
25397 { (char *)"Locale_swiginit", Locale_swiginit, METH_VARARGS, NULL},
25398 { (char *)"GetLocale", (PyCFunction)_wrap_GetLocale, METH_NOARGS, NULL},
25399 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
25400 { (char *)"new_EncodingConverter", (PyCFunction)_wrap_new_EncodingConverter, METH_NOARGS, NULL},
25401 { (char *)"delete_EncodingConverter", (PyCFunction)_wrap_delete_EncodingConverter, METH_O, NULL},
25402 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
25403 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
25404 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
25405 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
25406 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
25407 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
25408 { (char *)"EncodingConverter_swiginit", EncodingConverter_swiginit, METH_VARARGS, NULL},
25409 { (char *)"delete_DC", (PyCFunction)_wrap_delete_DC, METH_O, NULL},
25410 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
25411 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25412 { (char *)"DC_GradientFillConcentric", (PyCFunction) _wrap_DC_GradientFillConcentric, METH_VARARGS | METH_KEYWORDS, NULL},
25413 { (char *)"DC_GradientFillLinear", (PyCFunction) _wrap_DC_GradientFillLinear, METH_VARARGS | METH_KEYWORDS, NULL},
25414 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
25415 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25416 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
25417 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
25418 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
25419 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25420 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
25421 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25422 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
25423 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
25424 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
25425 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25426 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25427 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25428 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
25429 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
25430 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25431 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
25432 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
25433 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25434 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
25435 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
25436 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
25437 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
25438 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25439 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25440 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25441 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25442 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25443 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
25444 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25445 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
25446 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25447 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
25448 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25449 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25450 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
25451 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
25452 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
25453 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
25454 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
25455 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
25456 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
25457 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
25458 { (char *)"DC_Clear", (PyCFunction)_wrap_DC_Clear, METH_O, NULL},
25459 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
25460 { (char *)"DC_EndDoc", (PyCFunction)_wrap_DC_EndDoc, METH_O, NULL},
25461 { (char *)"DC_StartPage", (PyCFunction)_wrap_DC_StartPage, METH_O, NULL},
25462 { (char *)"DC_EndPage", (PyCFunction)_wrap_DC_EndPage, METH_O, NULL},
25463 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
25464 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
25465 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
25466 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
25467 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
25468 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
25469 { (char *)"DC_DestroyClippingRegion", (PyCFunction)_wrap_DC_DestroyClippingRegion, METH_O, NULL},
25470 { (char *)"DC_GetClippingBox", (PyCFunction)_wrap_DC_GetClippingBox, METH_O, NULL},
25471 { (char *)"DC_GetClippingRect", (PyCFunction)_wrap_DC_GetClippingRect, METH_O, NULL},
25472 { (char *)"DC_GetCharHeight", (PyCFunction)_wrap_DC_GetCharHeight, METH_O, NULL},
25473 { (char *)"DC_GetCharWidth", (PyCFunction)_wrap_DC_GetCharWidth, METH_O, NULL},
25474 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
25475 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
25476 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
25477 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
25478 { (char *)"DC_GetSize", (PyCFunction)_wrap_DC_GetSize, METH_O, NULL},
25479 { (char *)"DC_GetSizeTuple", (PyCFunction)_wrap_DC_GetSizeTuple, METH_O, NULL},
25480 { (char *)"DC_GetSizeMM", (PyCFunction)_wrap_DC_GetSizeMM, METH_O, NULL},
25481 { (char *)"DC_GetSizeMMTuple", (PyCFunction)_wrap_DC_GetSizeMMTuple, METH_O, NULL},
25482 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
25483 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
25484 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
25485 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
25486 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
25487 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
25488 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
25489 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
25490 { (char *)"DC_CanDrawBitmap", (PyCFunction)_wrap_DC_CanDrawBitmap, METH_O, NULL},
25491 { (char *)"DC_CanGetTextExtent", (PyCFunction)_wrap_DC_CanGetTextExtent, METH_O, NULL},
25492 { (char *)"DC_GetDepth", (PyCFunction)_wrap_DC_GetDepth, METH_O, NULL},
25493 { (char *)"DC_GetPPI", (PyCFunction)_wrap_DC_GetPPI, METH_O, NULL},
25494 { (char *)"DC_Ok", (PyCFunction)_wrap_DC_Ok, METH_O, NULL},
25495 { (char *)"DC_GetBackgroundMode", (PyCFunction)_wrap_DC_GetBackgroundMode, METH_O, NULL},
25496 { (char *)"DC_GetBackground", (PyCFunction)_wrap_DC_GetBackground, METH_O, NULL},
25497 { (char *)"DC_GetBrush", (PyCFunction)_wrap_DC_GetBrush, METH_O, NULL},
25498 { (char *)"DC_GetFont", (PyCFunction)_wrap_DC_GetFont, METH_O, NULL},
25499 { (char *)"DC_GetPen", (PyCFunction)_wrap_DC_GetPen, METH_O, NULL},
25500 { (char *)"DC_GetTextBackground", (PyCFunction)_wrap_DC_GetTextBackground, METH_O, NULL},
25501 { (char *)"DC_GetTextForeground", (PyCFunction)_wrap_DC_GetTextForeground, METH_O, NULL},
25502 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
25503 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
25504 { (char *)"DC_GetMapMode", (PyCFunction)_wrap_DC_GetMapMode, METH_O, NULL},
25505 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
25506 { (char *)"DC_GetUserScale", (PyCFunction)_wrap_DC_GetUserScale, METH_O, NULL},
25507 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
25508 { (char *)"DC_GetLogicalScale", (PyCFunction)_wrap_DC_GetLogicalScale, METH_O, NULL},
25509 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
25510 { (char *)"DC_GetLogicalOrigin", (PyCFunction)_wrap_DC_GetLogicalOrigin, METH_O, NULL},
25511 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction)_wrap_DC_GetLogicalOriginTuple, METH_O, NULL},
25512 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
25513 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25514 { (char *)"DC_GetDeviceOrigin", (PyCFunction)_wrap_DC_GetDeviceOrigin, METH_O, NULL},
25515 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction)_wrap_DC_GetDeviceOriginTuple, METH_O, NULL},
25516 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
25517 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25518 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
25519 { (char *)"DC_GetLogicalFunction", (PyCFunction)_wrap_DC_GetLogicalFunction, METH_O, NULL},
25520 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
25521 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction)_wrap_DC_ComputeScaleAndOrigin, METH_O, NULL},
25522 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
25523 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
25524 { (char *)"DC_ResetBoundingBox", (PyCFunction)_wrap_DC_ResetBoundingBox, METH_O, NULL},
25525 { (char *)"DC_MinX", (PyCFunction)_wrap_DC_MinX, METH_O, NULL},
25526 { (char *)"DC_MaxX", (PyCFunction)_wrap_DC_MaxX, METH_O, NULL},
25527 { (char *)"DC_MinY", (PyCFunction)_wrap_DC_MinY, METH_O, NULL},
25528 { (char *)"DC_MaxY", (PyCFunction)_wrap_DC_MaxY, METH_O, NULL},
25529 { (char *)"DC_GetBoundingBox", (PyCFunction)_wrap_DC_GetBoundingBox, METH_O, NULL},
25530 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
25531 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
25532 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
25533 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
25534 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
25535 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
25536 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
25537 { (char *)"new_MemoryDC", (PyCFunction)_wrap_new_MemoryDC, METH_NOARGS, NULL},
25538 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
25539 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
25540 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
25541 { (char *)"MemoryDC_swiginit", MemoryDC_swiginit, METH_VARARGS, NULL},
25542 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
25543 { (char *)"delete_BufferedDC", (PyCFunction)_wrap_delete_BufferedDC, METH_O, NULL},
25544 { (char *)"BufferedDC_UnMask", (PyCFunction)_wrap_BufferedDC_UnMask, METH_O, NULL},
25545 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
25546 { (char *)"BufferedDC_swiginit", BufferedDC_swiginit, METH_VARARGS, NULL},
25547 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
25548 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
25549 { (char *)"BufferedPaintDC_swiginit", BufferedPaintDC_swiginit, METH_VARARGS, NULL},
25550 { (char *)"new_ScreenDC", (PyCFunction)_wrap_new_ScreenDC, METH_NOARGS, NULL},
25551 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
25552 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
25553 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction)_wrap_ScreenDC_EndDrawingOnTop, METH_O, NULL},
25554 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
25555 { (char *)"ScreenDC_swiginit", ScreenDC_swiginit, METH_VARARGS, NULL},
25556 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
25557 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
25558 { (char *)"ClientDC_swiginit", ClientDC_swiginit, METH_VARARGS, NULL},
25559 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
25560 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
25561 { (char *)"PaintDC_swiginit", PaintDC_swiginit, METH_VARARGS, NULL},
25562 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
25563 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
25564 { (char *)"WindowDC_swiginit", WindowDC_swiginit, METH_VARARGS, NULL},
25565 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
25566 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
25567 { (char *)"MirrorDC_swiginit", MirrorDC_swiginit, METH_VARARGS, NULL},
25568 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
25569 { (char *)"PostScriptDC_GetPrintData", (PyCFunction)_wrap_PostScriptDC_GetPrintData, METH_O, NULL},
25570 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
25571 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
25572 { (char *)"PostScriptDC_GetResolution", (PyCFunction)_wrap_PostScriptDC_GetResolution, METH_NOARGS, NULL},
25573 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
25574 { (char *)"PostScriptDC_swiginit", PostScriptDC_swiginit, METH_VARARGS, NULL},
25575 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
25576 { (char *)"delete_MetaFile", (PyCFunction)_wrap_delete_MetaFile, METH_O, NULL},
25577 { (char *)"MetaFile_Ok", (PyCFunction)_wrap_MetaFile_Ok, METH_O, NULL},
25578 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
25579 { (char *)"MetaFile_GetSize", (PyCFunction)_wrap_MetaFile_GetSize, METH_O, NULL},
25580 { (char *)"MetaFile_GetWidth", (PyCFunction)_wrap_MetaFile_GetWidth, METH_O, NULL},
25581 { (char *)"MetaFile_GetHeight", (PyCFunction)_wrap_MetaFile_GetHeight, METH_O, NULL},
25582 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
25583 { (char *)"MetaFile_swiginit", MetaFile_swiginit, METH_VARARGS, NULL},
25584 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
25585 { (char *)"MetaFileDC_Close", (PyCFunction)_wrap_MetaFileDC_Close, METH_O, NULL},
25586 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
25587 { (char *)"MetaFileDC_swiginit", MetaFileDC_swiginit, METH_VARARGS, NULL},
25588 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
25589 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
25590 { (char *)"PrinterDC_swiginit", PrinterDC_swiginit, METH_VARARGS, NULL},
25591 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
25592 { (char *)"delete_ImageList", (PyCFunction)_wrap_delete_ImageList, METH_O, NULL},
25593 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
25594 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
25595 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25596 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25597 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
25598 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
25599 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
25600 { (char *)"ImageList_GetImageCount", (PyCFunction)_wrap_ImageList_GetImageCount, METH_O, NULL},
25601 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
25602 { (char *)"ImageList_RemoveAll", (PyCFunction)_wrap_ImageList_RemoveAll, METH_O, NULL},
25603 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
25604 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
25605 { (char *)"ImageList_swiginit", ImageList_swiginit, METH_VARARGS, NULL},
25606 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
25607 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
25608 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
25609 { (char *)"PenList_GetCount", (PyCFunction)_wrap_PenList_GetCount, METH_O, NULL},
25610 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
25611 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
25612 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
25613 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
25614 { (char *)"BrushList_GetCount", (PyCFunction)_wrap_BrushList_GetCount, METH_O, NULL},
25615 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
25616 { (char *)"new_ColourDatabase", (PyCFunction)_wrap_new_ColourDatabase, METH_NOARGS, NULL},
25617 { (char *)"delete_ColourDatabase", (PyCFunction)_wrap_delete_ColourDatabase, METH_O, NULL},
25618 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
25619 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
25620 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
25621 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
25622 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
25623 { (char *)"ColourDatabase_swiginit", ColourDatabase_swiginit, METH_VARARGS, NULL},
25624 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
25625 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
25626 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
25627 { (char *)"FontList_GetCount", (PyCFunction)_wrap_FontList_GetCount, METH_O, NULL},
25628 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
25629 { (char *)"new_Effects", (PyCFunction)_wrap_new_Effects, METH_NOARGS, NULL},
25630 { (char *)"Effects_GetHighlightColour", (PyCFunction)_wrap_Effects_GetHighlightColour, METH_O, NULL},
25631 { (char *)"Effects_GetLightShadow", (PyCFunction)_wrap_Effects_GetLightShadow, METH_O, NULL},
25632 { (char *)"Effects_GetFaceColour", (PyCFunction)_wrap_Effects_GetFaceColour, METH_O, NULL},
25633 { (char *)"Effects_GetMediumShadow", (PyCFunction)_wrap_Effects_GetMediumShadow, METH_O, NULL},
25634 { (char *)"Effects_GetDarkShadow", (PyCFunction)_wrap_Effects_GetDarkShadow, METH_O, NULL},
25635 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
25636 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
25637 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
25638 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
25639 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
25640 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
25641 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
25642 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
25643 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
25644 { (char *)"Effects_swiginit", Effects_swiginit, METH_VARARGS, NULL},
25645 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
25646 { (char *)"delete_SplitterRenderParams", (PyCFunction)_wrap_delete_SplitterRenderParams, METH_O, NULL},
25647 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction)_wrap_SplitterRenderParams_widthSash_get, METH_O, NULL},
25648 { (char *)"SplitterRenderParams_border_get", (PyCFunction)_wrap_SplitterRenderParams_border_get, METH_O, NULL},
25649 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction)_wrap_SplitterRenderParams_isHotSensitive_get, METH_O, NULL},
25650 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
25651 { (char *)"SplitterRenderParams_swiginit", SplitterRenderParams_swiginit, METH_VARARGS, NULL},
25652 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
25653 { (char *)"delete_RendererVersion", (PyCFunction)_wrap_delete_RendererVersion, METH_O, NULL},
25654 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
25655 { (char *)"RendererVersion_version_get", (PyCFunction)_wrap_RendererVersion_version_get, METH_O, NULL},
25656 { (char *)"RendererVersion_age_get", (PyCFunction)_wrap_RendererVersion_age_get, METH_O, NULL},
25657 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
25658 { (char *)"RendererVersion_swiginit", RendererVersion_swiginit, METH_VARARGS, NULL},
25659 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
25660 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
25661 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
25662 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
25663 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
25664 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
25665 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
25666 { (char *)"RendererNative_Get", (PyCFunction)_wrap_RendererNative_Get, METH_NOARGS, NULL},
25667 { (char *)"RendererNative_GetGeneric", (PyCFunction)_wrap_RendererNative_GetGeneric, METH_NOARGS, NULL},
25668 { (char *)"RendererNative_GetDefault", (PyCFunction)_wrap_RendererNative_GetDefault, METH_NOARGS, NULL},
25669 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
25670 { (char *)"RendererNative_GetVersion", (PyCFunction)_wrap_RendererNative_GetVersion, METH_O, NULL},
25671 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
25672 { NULL, NULL, 0, NULL }
25673 };
25674
25675
25676 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
25677
25678 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
25679 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
25680 }
25681 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
25682 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
25683 }
25684 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
25685 return (void *)((wxGDIObject *) ((wxIcon *) x));
25686 }
25687 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
25688 return (void *)((wxGDIObject *) ((wxPalette *) x));
25689 }
25690 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
25691 return (void *)((wxGDIObject *) ((wxPen *) x));
25692 }
25693 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
25694 return (void *)((wxGDIObject *) ((wxFont *) x));
25695 }
25696 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
25697 return (void *)((wxGDIObject *) ((wxCursor *) x));
25698 }
25699 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
25700 return (void *)((wxGDIObject *) ((wxBitmap *) x));
25701 }
25702 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
25703 return (void *)((wxGDIObject *) ((wxRegion *) x));
25704 }
25705 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
25706 return (void *)((wxGDIObject *) ((wxBrush *) x));
25707 }
25708 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
25709 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
25710 }
25711 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
25712 return (void *)((wxDC *) ((wxScreenDC *) x));
25713 }
25714 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
25715 return (void *)((wxDC *) ((wxMirrorDC *) x));
25716 }
25717 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
25718 return (void *)((wxDC *) ((wxMemoryDC *) x));
25719 }
25720 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
25721 return (void *)((wxDC *) ((wxWindowDC *) x));
25722 }
25723 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
25724 return (void *)((wxDC *) ((wxMetaFileDC *) x));
25725 }
25726 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
25727 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
25728 }
25729 static void *_p_wxClientDCTo_p_wxDC(void *x) {
25730 return (void *)((wxDC *) ((wxClientDC *) x));
25731 }
25732 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
25733 return (void *)((wxDC *) ((wxPaintDC *) x));
25734 }
25735 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
25736 return (void *)((wxDC *) ((wxPostScriptDC *) x));
25737 }
25738 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
25739 return (void *)((wxDC *) ((wxPrinterDC *) x));
25740 }
25741 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
25742 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
25743 }
25744 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
25745 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
25746 }
25747 static void *_p_wxPenTo_p_wxObject(void *x) {
25748 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
25749 }
25750 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
25751 return (void *)((wxObject *) ((wxRegionIterator *) x));
25752 }
25753 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
25754 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
25755 }
25756 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
25757 return (void *)((wxObject *) ((wxSizerItem *) x));
25758 }
25759 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
25760 return (void *)((wxObject *) ((wxColourDatabase *) x));
25761 }
25762 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
25763 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
25764 }
25765 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
25766 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
25767 }
25768 static void *_p_wxIconTo_p_wxObject(void *x) {
25769 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
25770 }
25771 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
25772 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
25773 }
25774 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
25775 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
25776 }
25777 static void *_p_wxSizerTo_p_wxObject(void *x) {
25778 return (void *)((wxObject *) ((wxSizer *) x));
25779 }
25780 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
25781 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
25782 }
25783 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
25784 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
25785 }
25786 static void *_p_wxPenListTo_p_wxObject(void *x) {
25787 return (void *)((wxObject *) ((wxPenList *) x));
25788 }
25789 static void *_p_wxEventTo_p_wxObject(void *x) {
25790 return (void *)((wxObject *) ((wxEvent *) x));
25791 }
25792 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
25793 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
25794 }
25795 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
25796 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
25797 }
25798 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
25799 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
25800 }
25801 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
25802 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
25803 }
25804 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
25805 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
25806 }
25807 static void *_p_wxDCTo_p_wxObject(void *x) {
25808 return (void *)((wxObject *) ((wxDC *) x));
25809 }
25810 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
25811 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
25812 }
25813 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
25814 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
25815 }
25816 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
25817 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
25818 }
25819 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
25820 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
25821 }
25822 static void *_p_wxControlTo_p_wxObject(void *x) {
25823 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
25824 }
25825 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
25826 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
25827 }
25828 static void *_p_wxClientDCTo_p_wxObject(void *x) {
25829 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
25830 }
25831 static void *_p_wxFSFileTo_p_wxObject(void *x) {
25832 return (void *)((wxObject *) ((wxFSFile *) x));
25833 }
25834 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
25835 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
25836 }
25837 static void *_p_wxRegionTo_p_wxObject(void *x) {
25838 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
25839 }
25840 static void *_p_wxPySizerTo_p_wxObject(void *x) {
25841 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
25842 }
25843 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
25844 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
25845 }
25846 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
25847 return (void *)((wxObject *) ((wxGDIObject *) x));
25848 }
25849 static void *_p_wxEffectsTo_p_wxObject(void *x) {
25850 return (void *)((wxObject *) ((wxEffects *) x));
25851 }
25852 static void *_p_wxPyEventTo_p_wxObject(void *x) {
25853 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
25854 }
25855 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
25856 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
25857 }
25858 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
25859 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
25860 }
25861 static void *_p_wxShowEventTo_p_wxObject(void *x) {
25862 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
25863 }
25864 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
25865 return (void *)((wxObject *) ((wxMenuItem *) x));
25866 }
25867 static void *_p_wxDateEventTo_p_wxObject(void *x) {
25868 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
25869 }
25870 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
25871 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
25872 }
25873 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
25874 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
25875 }
25876 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
25877 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
25878 }
25879 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
25880 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
25881 }
25882 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
25883 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
25884 }
25885 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
25886 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
25887 }
25888 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
25889 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
25890 }
25891 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
25892 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
25893 }
25894 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
25895 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
25896 }
25897 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
25898 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
25899 }
25900 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
25901 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
25902 }
25903 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
25904 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
25905 }
25906 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
25907 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
25908 }
25909 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
25910 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
25911 }
25912 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
25913 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
25914 }
25915 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
25916 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
25917 }
25918 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
25919 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
25920 }
25921 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
25922 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
25923 }
25924 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
25925 return (void *)((wxObject *) ((wxImageHandler *) x));
25926 }
25927 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
25928 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
25929 }
25930 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
25931 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
25932 }
25933 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
25934 return (void *)((wxObject *) ((wxEvtHandler *) x));
25935 }
25936 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
25937 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
25938 }
25939 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
25940 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
25941 }
25942 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
25943 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
25944 }
25945 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
25946 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
25947 }
25948 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
25949 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
25950 }
25951 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
25952 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
25953 }
25954 static void *_p_wxImageTo_p_wxObject(void *x) {
25955 return (void *)((wxObject *) ((wxImage *) x));
25956 }
25957 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
25958 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
25959 }
25960 static void *_p_wxPaletteTo_p_wxObject(void *x) {
25961 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
25962 }
25963 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
25964 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
25965 }
25966 static void *_p_wxImageListTo_p_wxObject(void *x) {
25967 return (void *)((wxObject *) ((wxImageList *) x));
25968 }
25969 static void *_p_wxCursorTo_p_wxObject(void *x) {
25970 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
25971 }
25972 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
25973 return (void *)((wxObject *) ((wxEncodingConverter *) x));
25974 }
25975 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
25976 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
25977 }
25978 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
25979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
25980 }
25981 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
25982 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
25983 }
25984 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
25985 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
25986 }
25987 static void *_p_wxWindowTo_p_wxObject(void *x) {
25988 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
25989 }
25990 static void *_p_wxMenuTo_p_wxObject(void *x) {
25991 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
25992 }
25993 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
25994 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
25995 }
25996 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
25997 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
25998 }
25999 static void *_p_wxBrushListTo_p_wxObject(void *x) {
26000 return (void *)((wxObject *) ((wxBrushList *) x));
26001 }
26002 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
26003 return (void *)((wxObject *) ((wxFileSystem *) x));
26004 }
26005 static void *_p_wxBitmapTo_p_wxObject(void *x) {
26006 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
26007 }
26008 static void *_p_wxMaskTo_p_wxObject(void *x) {
26009 return (void *)((wxObject *) ((wxMask *) x));
26010 }
26011 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
26012 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
26013 }
26014 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
26015 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
26016 }
26017 static void *_p_wxPyAppTo_p_wxObject(void *x) {
26018 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
26019 }
26020 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
26021 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
26022 }
26023 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
26024 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
26025 }
26026 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
26027 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
26028 }
26029 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
26030 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
26031 }
26032 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
26033 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
26034 }
26035 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
26036 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
26037 }
26038 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
26039 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
26040 }
26041 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
26042 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
26043 }
26044 static void *_p_wxFontTo_p_wxObject(void *x) {
26045 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
26046 }
26047 static void *_p_wxBrushTo_p_wxObject(void *x) {
26048 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
26049 }
26050 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
26051 return (void *)((wxObject *) ((wxMetaFile *) x));
26052 }
26053 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
26054 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
26055 }
26056 static void *_p_wxColourTo_p_wxObject(void *x) {
26057 return (void *)((wxObject *) ((wxColour *) x));
26058 }
26059 static void *_p_wxFontListTo_p_wxObject(void *x) {
26060 return (void *)((wxObject *) ((wxFontList *) x));
26061 }
26062 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
26063 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
26064 }
26065 static void *_p_wxValidatorTo_p_wxObject(void *x) {
26066 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
26067 }
26068 static void *_p_wxControlTo_p_wxWindow(void *x) {
26069 return (void *)((wxWindow *) ((wxControl *) x));
26070 }
26071 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
26072 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
26073 }
26074 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
26075 return (void *)((wxWindow *) ((wxMenuBar *) x));
26076 }
26077 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26078 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
26079 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};
26080 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
26081 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
26082 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
26083 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
26084 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
26085 static swig_type_info _swigt__p_wxBrush = {"_p_wxBrush", "wxBrush *", 0, 0, (void*)0, 0};
26086 static swig_type_info _swigt__p_wxBrushList = {"_p_wxBrushList", "wxBrushList *", 0, 0, (void*)0, 0};
26087 static swig_type_info _swigt__p_wxBufferedDC = {"_p_wxBufferedDC", "wxBufferedDC *", 0, 0, (void*)0, 0};
26088 static swig_type_info _swigt__p_wxBufferedPaintDC = {"_p_wxBufferedPaintDC", "wxBufferedPaintDC *", 0, 0, (void*)0, 0};
26089 static swig_type_info _swigt__p_wxClientDC = {"_p_wxClientDC", "wxClientDC *", 0, 0, (void*)0, 0};
26090 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
26091 static swig_type_info _swigt__p_wxColourDatabase = {"_p_wxColourDatabase", "wxColourDatabase *", 0, 0, (void*)0, 0};
26092 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
26093 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
26094 static swig_type_info _swigt__p_wxDash = {"_p_wxDash", "wxDash *", 0, 0, (void*)0, 0};
26095 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
26096 static swig_type_info _swigt__p_wxEffects = {"_p_wxEffects", "wxEffects *", 0, 0, (void*)0, 0};
26097 static swig_type_info _swigt__p_wxEncodingConverter = {"_p_wxEncodingConverter", "wxEncodingConverter *", 0, 0, (void*)0, 0};
26098 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
26099 static swig_type_info _swigt__p_wxFontList = {"_p_wxFontList", "wxFontList *", 0, 0, (void*)0, 0};
26100 static swig_type_info _swigt__p_wxFontMapper = {"_p_wxFontMapper", "wxFontMapper *", 0, 0, (void*)0, 0};
26101 static swig_type_info _swigt__p_wxGDIObject = {"_p_wxGDIObject", "wxGDIObject *", 0, 0, (void*)0, 0};
26102 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
26103 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
26104 static swig_type_info _swigt__p_wxIconLocation = {"_p_wxIconLocation", "wxIconLocation *", 0, 0, (void*)0, 0};
26105 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
26106 static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
26107 static swig_type_info _swigt__p_wxLanguageInfo = {"_p_wxLanguageInfo", "wxLanguageInfo *", 0, 0, (void*)0, 0};
26108 static swig_type_info _swigt__p_wxLocale = {"_p_wxLocale", "wxLocale *", 0, 0, (void*)0, 0};
26109 static swig_type_info _swigt__p_wxMask = {"_p_wxMask", "wxMask *", 0, 0, (void*)0, 0};
26110 static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
26111 static swig_type_info _swigt__p_wxMetaFile = {"_p_wxMetaFile", "wxMetaFile *", 0, 0, (void*)0, 0};
26112 static swig_type_info _swigt__p_wxMetaFileDC = {"_p_wxMetaFileDC", "wxMetaFileDC *", 0, 0, (void*)0, 0};
26113 static swig_type_info _swigt__p_wxMirrorDC = {"_p_wxMirrorDC", "wxMirrorDC *", 0, 0, (void*)0, 0};
26114 static swig_type_info _swigt__p_wxNativeEncodingInfo = {"_p_wxNativeEncodingInfo", "wxNativeEncodingInfo *", 0, 0, (void*)0, 0};
26115 static swig_type_info _swigt__p_wxNativeFontInfo = {"_p_wxNativeFontInfo", "wxNativeFontInfo *", 0, 0, (void*)0, 0};
26116 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
26117 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
26118 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
26119 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
26120 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
26121 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
26122 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
26123 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
26124 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
26125 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
26126 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
26127 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
26128 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
26129 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
26130 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
26131 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
26132 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
26133 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
26134 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
26135 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
26136 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
26137 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
26138 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
26139 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
26140 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
26141 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
26142 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
26143 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
26144 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
26145 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
26146 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
26147 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
26148 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
26149 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
26150 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
26151 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
26152 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
26153 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
26154 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
26155 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
26156 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
26157 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
26158 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
26159 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
26160 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
26161 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
26162 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
26163 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
26164 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
26165 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
26166 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
26167 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
26168 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
26169 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
26170 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
26171 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
26172 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
26173 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
26174 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
26175 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
26176 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
26177 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
26178 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
26179 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
26180 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
26181 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
26182 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
26183 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
26184 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
26185 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
26186 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
26187 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
26188 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
26189 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
26190 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
26191 static swig_type_info _swigt__p_wxPaintDC = {"_p_wxPaintDC", "wxPaintDC *", 0, 0, (void*)0, 0};
26192 static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, (void*)0, 0};
26193 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
26194 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
26195 static swig_type_info _swigt__p_wxPenList = {"_p_wxPenList", "wxPenList *", 0, 0, (void*)0, 0};
26196 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
26197 static swig_type_info _swigt__p_wxPostScriptDC = {"_p_wxPostScriptDC", "wxPostScriptDC *", 0, 0, (void*)0, 0};
26198 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};
26199 static swig_type_info _swigt__p_wxPrinterDC = {"_p_wxPrinterDC", "wxPrinterDC *", 0, 0, (void*)0, 0};
26200 static swig_type_info _swigt__p_wxPyFontEnumerator = {"_p_wxPyFontEnumerator", "wxPyFontEnumerator *", 0, 0, (void*)0, 0};
26201 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
26202 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
26203 static swig_type_info _swigt__p_wxRegionIterator = {"_p_wxRegionIterator", "wxRegionIterator *", 0, 0, (void*)0, 0};
26204 static swig_type_info _swigt__p_wxRendererNative = {"_p_wxRendererNative", "wxRendererNative *", 0, 0, (void*)0, 0};
26205 static swig_type_info _swigt__p_wxRendererVersion = {"_p_wxRendererVersion", "wxRendererVersion *", 0, 0, (void*)0, 0};
26206 static swig_type_info _swigt__p_wxScreenDC = {"_p_wxScreenDC", "wxScreenDC *", 0, 0, (void*)0, 0};
26207 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
26208 static swig_type_info _swigt__p_wxSplitterRenderParams = {"_p_wxSplitterRenderParams", "wxSplitterRenderParams *", 0, 0, (void*)0, 0};
26209 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
26210 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
26211 static swig_type_info _swigt__p_wxWindowDC = {"_p_wxWindowDC", "wxWindowDC *", 0, 0, (void*)0, 0};
26212
26213 static swig_type_info *swig_type_initial[] = {
26214 &_swigt__p_char,
26215 &_swigt__p_double,
26216 &_swigt__p_form_ops_t,
26217 &_swigt__p_int,
26218 &_swigt__p_unsigned_char,
26219 &_swigt__p_unsigned_int,
26220 &_swigt__p_unsigned_long,
26221 &_swigt__p_wxANIHandler,
26222 &_swigt__p_wxAcceleratorTable,
26223 &_swigt__p_wxActivateEvent,
26224 &_swigt__p_wxBMPHandler,
26225 &_swigt__p_wxBitmap,
26226 &_swigt__p_wxBoxSizer,
26227 &_swigt__p_wxBrush,
26228 &_swigt__p_wxBrushList,
26229 &_swigt__p_wxBufferedDC,
26230 &_swigt__p_wxBufferedPaintDC,
26231 &_swigt__p_wxCURHandler,
26232 &_swigt__p_wxChildFocusEvent,
26233 &_swigt__p_wxClientDC,
26234 &_swigt__p_wxCloseEvent,
26235 &_swigt__p_wxColour,
26236 &_swigt__p_wxColourDatabase,
26237 &_swigt__p_wxCommandEvent,
26238 &_swigt__p_wxContextMenuEvent,
26239 &_swigt__p_wxControl,
26240 &_swigt__p_wxControlWithItems,
26241 &_swigt__p_wxCursor,
26242 &_swigt__p_wxDC,
26243 &_swigt__p_wxDash,
26244 &_swigt__p_wxDateEvent,
26245 &_swigt__p_wxDisplayChangedEvent,
26246 &_swigt__p_wxDropFilesEvent,
26247 &_swigt__p_wxDuplexMode,
26248 &_swigt__p_wxEffects,
26249 &_swigt__p_wxEncodingConverter,
26250 &_swigt__p_wxEraseEvent,
26251 &_swigt__p_wxEvent,
26252 &_swigt__p_wxEvtHandler,
26253 &_swigt__p_wxFSFile,
26254 &_swigt__p_wxFileSystem,
26255 &_swigt__p_wxFlexGridSizer,
26256 &_swigt__p_wxFocusEvent,
26257 &_swigt__p_wxFont,
26258 &_swigt__p_wxFontList,
26259 &_swigt__p_wxFontMapper,
26260 &_swigt__p_wxGBSizerItem,
26261 &_swigt__p_wxGDIObject,
26262 &_swigt__p_wxGIFHandler,
26263 &_swigt__p_wxGridBagSizer,
26264 &_swigt__p_wxGridSizer,
26265 &_swigt__p_wxICOHandler,
26266 &_swigt__p_wxIcon,
26267 &_swigt__p_wxIconBundle,
26268 &_swigt__p_wxIconLocation,
26269 &_swigt__p_wxIconizeEvent,
26270 &_swigt__p_wxIdleEvent,
26271 &_swigt__p_wxImage,
26272 &_swigt__p_wxImageHandler,
26273 &_swigt__p_wxImageList,
26274 &_swigt__p_wxIndividualLayoutConstraint,
26275 &_swigt__p_wxInitDialogEvent,
26276 &_swigt__p_wxJPEGHandler,
26277 &_swigt__p_wxKeyEvent,
26278 &_swigt__p_wxLanguageInfo,
26279 &_swigt__p_wxLayoutConstraints,
26280 &_swigt__p_wxLocale,
26281 &_swigt__p_wxMask,
26282 &_swigt__p_wxMaximizeEvent,
26283 &_swigt__p_wxMemoryDC,
26284 &_swigt__p_wxMenu,
26285 &_swigt__p_wxMenuBar,
26286 &_swigt__p_wxMenuEvent,
26287 &_swigt__p_wxMenuItem,
26288 &_swigt__p_wxMetaFile,
26289 &_swigt__p_wxMetaFileDC,
26290 &_swigt__p_wxMirrorDC,
26291 &_swigt__p_wxMouseCaptureChangedEvent,
26292 &_swigt__p_wxMouseEvent,
26293 &_swigt__p_wxMoveEvent,
26294 &_swigt__p_wxNativeEncodingInfo,
26295 &_swigt__p_wxNativeFontInfo,
26296 &_swigt__p_wxNavigationKeyEvent,
26297 &_swigt__p_wxNcPaintEvent,
26298 &_swigt__p_wxNotifyEvent,
26299 &_swigt__p_wxObject,
26300 &_swigt__p_wxPCXHandler,
26301 &_swigt__p_wxPNGHandler,
26302 &_swigt__p_wxPNMHandler,
26303 &_swigt__p_wxPaintDC,
26304 &_swigt__p_wxPaintEvent,
26305 &_swigt__p_wxPalette,
26306 &_swigt__p_wxPaletteChangedEvent,
26307 &_swigt__p_wxPaperSize,
26308 &_swigt__p_wxPen,
26309 &_swigt__p_wxPenList,
26310 &_swigt__p_wxPoint,
26311 &_swigt__p_wxPostScriptDC,
26312 &_swigt__p_wxPrintData,
26313 &_swigt__p_wxPrinterDC,
26314 &_swigt__p_wxPyApp,
26315 &_swigt__p_wxPyCommandEvent,
26316 &_swigt__p_wxPyEvent,
26317 &_swigt__p_wxPyFontEnumerator,
26318 &_swigt__p_wxPyImageHandler,
26319 &_swigt__p_wxPySizer,
26320 &_swigt__p_wxPyValidator,
26321 &_swigt__p_wxQueryNewPaletteEvent,
26322 &_swigt__p_wxRect,
26323 &_swigt__p_wxRegion,
26324 &_swigt__p_wxRegionIterator,
26325 &_swigt__p_wxRendererNative,
26326 &_swigt__p_wxRendererVersion,
26327 &_swigt__p_wxScreenDC,
26328 &_swigt__p_wxScrollEvent,
26329 &_swigt__p_wxScrollWinEvent,
26330 &_swigt__p_wxSetCursorEvent,
26331 &_swigt__p_wxShowEvent,
26332 &_swigt__p_wxSize,
26333 &_swigt__p_wxSizeEvent,
26334 &_swigt__p_wxSizer,
26335 &_swigt__p_wxSizerItem,
26336 &_swigt__p_wxSplitterRenderParams,
26337 &_swigt__p_wxStaticBoxSizer,
26338 &_swigt__p_wxStdDialogButtonSizer,
26339 &_swigt__p_wxString,
26340 &_swigt__p_wxSysColourChangedEvent,
26341 &_swigt__p_wxTIFFHandler,
26342 &_swigt__p_wxUpdateUIEvent,
26343 &_swigt__p_wxValidator,
26344 &_swigt__p_wxWindow,
26345 &_swigt__p_wxWindowCreateEvent,
26346 &_swigt__p_wxWindowDC,
26347 &_swigt__p_wxWindowDestroyEvent,
26348 &_swigt__p_wxXPMHandler,
26349 };
26350
26351 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26352 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26353 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
26354 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26355 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
26356 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26357 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
26358 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
26359 static swig_cast_info _swigc__p_wxBrush[] = { {&_swigt__p_wxBrush, 0, 0, 0},{0, 0, 0, 0}};
26360 static swig_cast_info _swigc__p_wxBrushList[] = { {&_swigt__p_wxBrushList, 0, 0, 0},{0, 0, 0, 0}};
26361 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}};
26362 static swig_cast_info _swigc__p_wxBufferedPaintDC[] = { {&_swigt__p_wxBufferedPaintDC, 0, 0, 0},{0, 0, 0, 0}};
26363 static swig_cast_info _swigc__p_wxClientDC[] = { {&_swigt__p_wxClientDC, 0, 0, 0},{0, 0, 0, 0}};
26364 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
26365 static swig_cast_info _swigc__p_wxColourDatabase[] = { {&_swigt__p_wxColourDatabase, 0, 0, 0},{0, 0, 0, 0}};
26366 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
26367 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}};
26368 static swig_cast_info _swigc__p_wxDash[] = { {&_swigt__p_wxDash, 0, 0, 0},{0, 0, 0, 0}};
26369 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
26370 static swig_cast_info _swigc__p_wxEffects[] = { {&_swigt__p_wxEffects, 0, 0, 0},{0, 0, 0, 0}};
26371 static swig_cast_info _swigc__p_wxEncodingConverter[] = { {&_swigt__p_wxEncodingConverter, 0, 0, 0},{0, 0, 0, 0}};
26372 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
26373 static swig_cast_info _swigc__p_wxFontList[] = { {&_swigt__p_wxFontList, 0, 0, 0},{0, 0, 0, 0}};
26374 static swig_cast_info _swigc__p_wxFontMapper[] = { {&_swigt__p_wxFontMapper, 0, 0, 0},{0, 0, 0, 0}};
26375 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}};
26376 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
26377 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
26378 static swig_cast_info _swigc__p_wxIconLocation[] = { {&_swigt__p_wxIconLocation, 0, 0, 0},{0, 0, 0, 0}};
26379 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
26380 static swig_cast_info _swigc__p_wxImageList[] = { {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
26381 static swig_cast_info _swigc__p_wxLanguageInfo[] = { {&_swigt__p_wxLanguageInfo, 0, 0, 0},{0, 0, 0, 0}};
26382 static swig_cast_info _swigc__p_wxLocale[] = { {&_swigt__p_wxLocale, 0, 0, 0},{0, 0, 0, 0}};
26383 static swig_cast_info _swigc__p_wxMask[] = { {&_swigt__p_wxMask, 0, 0, 0},{0, 0, 0, 0}};
26384 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}};
26385 static swig_cast_info _swigc__p_wxMetaFile[] = { {&_swigt__p_wxMetaFile, 0, 0, 0},{0, 0, 0, 0}};
26386 static swig_cast_info _swigc__p_wxMetaFileDC[] = { {&_swigt__p_wxMetaFileDC, 0, 0, 0},{0, 0, 0, 0}};
26387 static swig_cast_info _swigc__p_wxMirrorDC[] = { {&_swigt__p_wxMirrorDC, 0, 0, 0},{0, 0, 0, 0}};
26388 static swig_cast_info _swigc__p_wxNativeEncodingInfo[] = { {&_swigt__p_wxNativeEncodingInfo, 0, 0, 0},{0, 0, 0, 0}};
26389 static swig_cast_info _swigc__p_wxNativeFontInfo[] = { {&_swigt__p_wxNativeFontInfo, 0, 0, 0},{0, 0, 0, 0}};
26390 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
26391 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
26392 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
26393 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
26394 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
26395 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
26396 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
26397 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
26398 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
26399 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
26400 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
26401 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
26402 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
26403 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
26404 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
26405 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
26406 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
26407 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
26408 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
26409 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
26410 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
26411 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
26412 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
26413 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
26414 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
26415 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
26416 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
26417 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
26418 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
26419 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
26420 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
26421 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
26422 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
26423 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
26424 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
26425 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
26426 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
26427 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
26428 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
26429 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
26430 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
26431 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
26432 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
26433 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
26434 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
26435 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
26436 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
26437 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
26438 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
26439 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
26440 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
26441 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
26442 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
26443 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
26444 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
26445 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
26446 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
26447 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
26448 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
26449 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
26450 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
26451 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
26452 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
26453 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
26454 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
26455 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
26456 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
26457 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
26458 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
26459 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
26460 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
26461 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
26462 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
26463 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
26464 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_wxColourDatabase, _p_wxColourDatabaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPenList, _p_wxPenListTo_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_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_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_wxBrushList, _p_wxBrushListTo_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_wxFontList, _p_wxFontListTo_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}};
26465 static swig_cast_info _swigc__p_wxPaintDC[] = { {&_swigt__p_wxPaintDC, 0, 0, 0},{0, 0, 0, 0}};
26466 static swig_cast_info _swigc__p_wxPalette[] = { {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
26467 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
26468 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
26469 static swig_cast_info _swigc__p_wxPenList[] = { {&_swigt__p_wxPenList, 0, 0, 0},{0, 0, 0, 0}};
26470 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
26471 static swig_cast_info _swigc__p_wxPostScriptDC[] = { {&_swigt__p_wxPostScriptDC, 0, 0, 0},{0, 0, 0, 0}};
26472 static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
26473 static swig_cast_info _swigc__p_wxPrinterDC[] = { {&_swigt__p_wxPrinterDC, 0, 0, 0},{0, 0, 0, 0}};
26474 static swig_cast_info _swigc__p_wxPyFontEnumerator[] = { {&_swigt__p_wxPyFontEnumerator, 0, 0, 0},{0, 0, 0, 0}};
26475 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
26476 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
26477 static swig_cast_info _swigc__p_wxRegionIterator[] = { {&_swigt__p_wxRegionIterator, 0, 0, 0},{0, 0, 0, 0}};
26478 static swig_cast_info _swigc__p_wxRendererNative[] = { {&_swigt__p_wxRendererNative, 0, 0, 0},{0, 0, 0, 0}};
26479 static swig_cast_info _swigc__p_wxRendererVersion[] = { {&_swigt__p_wxRendererVersion, 0, 0, 0},{0, 0, 0, 0}};
26480 static swig_cast_info _swigc__p_wxScreenDC[] = { {&_swigt__p_wxScreenDC, 0, 0, 0},{0, 0, 0, 0}};
26481 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
26482 static swig_cast_info _swigc__p_wxSplitterRenderParams[] = { {&_swigt__p_wxSplitterRenderParams, 0, 0, 0},{0, 0, 0, 0}};
26483 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
26484 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}};
26485 static swig_cast_info _swigc__p_wxWindowDC[] = { {&_swigt__p_wxWindowDC, 0, 0, 0},{0, 0, 0, 0}};
26486
26487 static swig_cast_info *swig_cast_initial[] = {
26488 _swigc__p_char,
26489 _swigc__p_double,
26490 _swigc__p_form_ops_t,
26491 _swigc__p_int,
26492 _swigc__p_unsigned_char,
26493 _swigc__p_unsigned_int,
26494 _swigc__p_unsigned_long,
26495 _swigc__p_wxANIHandler,
26496 _swigc__p_wxAcceleratorTable,
26497 _swigc__p_wxActivateEvent,
26498 _swigc__p_wxBMPHandler,
26499 _swigc__p_wxBitmap,
26500 _swigc__p_wxBoxSizer,
26501 _swigc__p_wxBrush,
26502 _swigc__p_wxBrushList,
26503 _swigc__p_wxBufferedDC,
26504 _swigc__p_wxBufferedPaintDC,
26505 _swigc__p_wxCURHandler,
26506 _swigc__p_wxChildFocusEvent,
26507 _swigc__p_wxClientDC,
26508 _swigc__p_wxCloseEvent,
26509 _swigc__p_wxColour,
26510 _swigc__p_wxColourDatabase,
26511 _swigc__p_wxCommandEvent,
26512 _swigc__p_wxContextMenuEvent,
26513 _swigc__p_wxControl,
26514 _swigc__p_wxControlWithItems,
26515 _swigc__p_wxCursor,
26516 _swigc__p_wxDC,
26517 _swigc__p_wxDash,
26518 _swigc__p_wxDateEvent,
26519 _swigc__p_wxDisplayChangedEvent,
26520 _swigc__p_wxDropFilesEvent,
26521 _swigc__p_wxDuplexMode,
26522 _swigc__p_wxEffects,
26523 _swigc__p_wxEncodingConverter,
26524 _swigc__p_wxEraseEvent,
26525 _swigc__p_wxEvent,
26526 _swigc__p_wxEvtHandler,
26527 _swigc__p_wxFSFile,
26528 _swigc__p_wxFileSystem,
26529 _swigc__p_wxFlexGridSizer,
26530 _swigc__p_wxFocusEvent,
26531 _swigc__p_wxFont,
26532 _swigc__p_wxFontList,
26533 _swigc__p_wxFontMapper,
26534 _swigc__p_wxGBSizerItem,
26535 _swigc__p_wxGDIObject,
26536 _swigc__p_wxGIFHandler,
26537 _swigc__p_wxGridBagSizer,
26538 _swigc__p_wxGridSizer,
26539 _swigc__p_wxICOHandler,
26540 _swigc__p_wxIcon,
26541 _swigc__p_wxIconBundle,
26542 _swigc__p_wxIconLocation,
26543 _swigc__p_wxIconizeEvent,
26544 _swigc__p_wxIdleEvent,
26545 _swigc__p_wxImage,
26546 _swigc__p_wxImageHandler,
26547 _swigc__p_wxImageList,
26548 _swigc__p_wxIndividualLayoutConstraint,
26549 _swigc__p_wxInitDialogEvent,
26550 _swigc__p_wxJPEGHandler,
26551 _swigc__p_wxKeyEvent,
26552 _swigc__p_wxLanguageInfo,
26553 _swigc__p_wxLayoutConstraints,
26554 _swigc__p_wxLocale,
26555 _swigc__p_wxMask,
26556 _swigc__p_wxMaximizeEvent,
26557 _swigc__p_wxMemoryDC,
26558 _swigc__p_wxMenu,
26559 _swigc__p_wxMenuBar,
26560 _swigc__p_wxMenuEvent,
26561 _swigc__p_wxMenuItem,
26562 _swigc__p_wxMetaFile,
26563 _swigc__p_wxMetaFileDC,
26564 _swigc__p_wxMirrorDC,
26565 _swigc__p_wxMouseCaptureChangedEvent,
26566 _swigc__p_wxMouseEvent,
26567 _swigc__p_wxMoveEvent,
26568 _swigc__p_wxNativeEncodingInfo,
26569 _swigc__p_wxNativeFontInfo,
26570 _swigc__p_wxNavigationKeyEvent,
26571 _swigc__p_wxNcPaintEvent,
26572 _swigc__p_wxNotifyEvent,
26573 _swigc__p_wxObject,
26574 _swigc__p_wxPCXHandler,
26575 _swigc__p_wxPNGHandler,
26576 _swigc__p_wxPNMHandler,
26577 _swigc__p_wxPaintDC,
26578 _swigc__p_wxPaintEvent,
26579 _swigc__p_wxPalette,
26580 _swigc__p_wxPaletteChangedEvent,
26581 _swigc__p_wxPaperSize,
26582 _swigc__p_wxPen,
26583 _swigc__p_wxPenList,
26584 _swigc__p_wxPoint,
26585 _swigc__p_wxPostScriptDC,
26586 _swigc__p_wxPrintData,
26587 _swigc__p_wxPrinterDC,
26588 _swigc__p_wxPyApp,
26589 _swigc__p_wxPyCommandEvent,
26590 _swigc__p_wxPyEvent,
26591 _swigc__p_wxPyFontEnumerator,
26592 _swigc__p_wxPyImageHandler,
26593 _swigc__p_wxPySizer,
26594 _swigc__p_wxPyValidator,
26595 _swigc__p_wxQueryNewPaletteEvent,
26596 _swigc__p_wxRect,
26597 _swigc__p_wxRegion,
26598 _swigc__p_wxRegionIterator,
26599 _swigc__p_wxRendererNative,
26600 _swigc__p_wxRendererVersion,
26601 _swigc__p_wxScreenDC,
26602 _swigc__p_wxScrollEvent,
26603 _swigc__p_wxScrollWinEvent,
26604 _swigc__p_wxSetCursorEvent,
26605 _swigc__p_wxShowEvent,
26606 _swigc__p_wxSize,
26607 _swigc__p_wxSizeEvent,
26608 _swigc__p_wxSizer,
26609 _swigc__p_wxSizerItem,
26610 _swigc__p_wxSplitterRenderParams,
26611 _swigc__p_wxStaticBoxSizer,
26612 _swigc__p_wxStdDialogButtonSizer,
26613 _swigc__p_wxString,
26614 _swigc__p_wxSysColourChangedEvent,
26615 _swigc__p_wxTIFFHandler,
26616 _swigc__p_wxUpdateUIEvent,
26617 _swigc__p_wxValidator,
26618 _swigc__p_wxWindow,
26619 _swigc__p_wxWindowCreateEvent,
26620 _swigc__p_wxWindowDC,
26621 _swigc__p_wxWindowDestroyEvent,
26622 _swigc__p_wxXPMHandler,
26623 };
26624
26625
26626 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26627
26628 static swig_const_info swig_const_table[] = {
26629 {0, 0, 0, 0.0, 0, 0}};
26630
26631 #ifdef __cplusplus
26632 }
26633 #endif
26634 /* -----------------------------------------------------------------------------
26635 * Type initialization:
26636 * This problem is tough by the requirement that no dynamic
26637 * memory is used. Also, since swig_type_info structures store pointers to
26638 * swig_cast_info structures and swig_cast_info structures store pointers back
26639 * to swig_type_info structures, we need some lookup code at initialization.
26640 * The idea is that swig generates all the structures that are needed.
26641 * The runtime then collects these partially filled structures.
26642 * The SWIG_InitializeModule function takes these initial arrays out of
26643 * swig_module, and does all the lookup, filling in the swig_module.types
26644 * array with the correct data and linking the correct swig_cast_info
26645 * structures together.
26646 *
26647 * The generated swig_type_info structures are assigned staticly to an initial
26648 * array. We just loop though that array, and handle each type individually.
26649 * First we lookup if this type has been already loaded, and if so, use the
26650 * loaded structure instead of the generated one. Then we have to fill in the
26651 * cast linked list. The cast data is initially stored in something like a
26652 * two-dimensional array. Each row corresponds to a type (there are the same
26653 * number of rows as there are in the swig_type_initial array). Each entry in
26654 * a column is one of the swig_cast_info structures for that type.
26655 * The cast_initial array is actually an array of arrays, because each row has
26656 * a variable number of columns. So to actually build the cast linked list,
26657 * we find the array of casts associated with the type, and loop through it
26658 * adding the casts to the list. The one last trick we need to do is making
26659 * sure the type pointer in the swig_cast_info struct is correct.
26660 *
26661 * First off, we lookup the cast->type name to see if it is already loaded.
26662 * There are three cases to handle:
26663 * 1) If the cast->type has already been loaded AND the type we are adding
26664 * casting info to has not been loaded (it is in this module), THEN we
26665 * replace the cast->type pointer with the type pointer that has already
26666 * been loaded.
26667 * 2) If BOTH types (the one we are adding casting info to, and the
26668 * cast->type) are loaded, THEN the cast info has already been loaded by
26669 * the previous module so we just ignore it.
26670 * 3) Finally, if cast->type has not already been loaded, then we add that
26671 * swig_cast_info to the linked list (because the cast->type) pointer will
26672 * be correct.
26673 * ----------------------------------------------------------------------------- */
26674
26675 #ifdef __cplusplus
26676 extern "C" {
26677 #if 0
26678 } /* c-mode */
26679 #endif
26680 #endif
26681
26682 #if 0
26683 #define SWIGRUNTIME_DEBUG
26684 #endif
26685
26686 SWIGRUNTIME void
26687 SWIG_InitializeModule(void *clientdata) {
26688 size_t i;
26689 swig_module_info *module_head;
26690 static int init_run = 0;
26691
26692 clientdata = clientdata;
26693
26694 if (init_run) return;
26695 init_run = 1;
26696
26697 /* Initialize the swig_module */
26698 swig_module.type_initial = swig_type_initial;
26699 swig_module.cast_initial = swig_cast_initial;
26700
26701 /* Try and load any already created modules */
26702 module_head = SWIG_GetModule(clientdata);
26703 if (module_head) {
26704 swig_module.next = module_head->next;
26705 module_head->next = &swig_module;
26706 } else {
26707 /* This is the first module loaded */
26708 swig_module.next = &swig_module;
26709 SWIG_SetModule(clientdata, &swig_module);
26710 }
26711
26712 /* Now work on filling in swig_module.types */
26713 #ifdef SWIGRUNTIME_DEBUG
26714 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
26715 #endif
26716 for (i = 0; i < swig_module.size; ++i) {
26717 swig_type_info *type = 0;
26718 swig_type_info *ret;
26719 swig_cast_info *cast;
26720
26721 #ifdef SWIGRUNTIME_DEBUG
26722 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
26723 #endif
26724
26725 /* if there is another module already loaded */
26726 if (swig_module.next != &swig_module) {
26727 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
26728 }
26729 if (type) {
26730 /* Overwrite clientdata field */
26731 #ifdef SWIGRUNTIME_DEBUG
26732 printf("SWIG_InitializeModule: found type %s\n", type->name);
26733 #endif
26734 if (swig_module.type_initial[i]->clientdata) {
26735 type->clientdata = swig_module.type_initial[i]->clientdata;
26736 #ifdef SWIGRUNTIME_DEBUG
26737 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
26738 #endif
26739 }
26740 } else {
26741 type = swig_module.type_initial[i];
26742 }
26743
26744 /* Insert casting types */
26745 cast = swig_module.cast_initial[i];
26746 while (cast->type) {
26747 /* Don't need to add information already in the list */
26748 ret = 0;
26749 #ifdef SWIGRUNTIME_DEBUG
26750 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
26751 #endif
26752 if (swig_module.next != &swig_module) {
26753 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
26754 #ifdef SWIGRUNTIME_DEBUG
26755 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
26756 #endif
26757 }
26758 if (ret) {
26759 if (type == swig_module.type_initial[i]) {
26760 #ifdef SWIGRUNTIME_DEBUG
26761 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
26762 #endif
26763 cast->type = ret;
26764 ret = 0;
26765 } else {
26766 /* Check for casting already in the list */
26767 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
26768 #ifdef SWIGRUNTIME_DEBUG
26769 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
26770 #endif
26771 if (!ocast) ret = 0;
26772 }
26773 }
26774
26775 if (!ret) {
26776 #ifdef SWIGRUNTIME_DEBUG
26777 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
26778 #endif
26779 if (type->cast) {
26780 type->cast->prev = cast;
26781 cast->next = type->cast;
26782 }
26783 type->cast = cast;
26784 }
26785 cast++;
26786 }
26787 /* Set entry in modules->types array equal to the type */
26788 swig_module.types[i] = type;
26789 }
26790 swig_module.types[i] = 0;
26791
26792 #ifdef SWIGRUNTIME_DEBUG
26793 printf("**** SWIG_InitializeModule: Cast List ******\n");
26794 for (i = 0; i < swig_module.size; ++i) {
26795 int j = 0;
26796 swig_cast_info *cast = swig_module.cast_initial[i];
26797 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
26798 while (cast->type) {
26799 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
26800 cast++;
26801 ++j;
26802 }
26803 printf("---- Total casts: %d\n",j);
26804 }
26805 printf("**** SWIG_InitializeModule: Cast List ******\n");
26806 #endif
26807 }
26808
26809 /* This function will propagate the clientdata field of type to
26810 * any new swig_type_info structures that have been added into the list
26811 * of equivalent types. It is like calling
26812 * SWIG_TypeClientData(type, clientdata) a second time.
26813 */
26814 SWIGRUNTIME void
26815 SWIG_PropagateClientData(void) {
26816 size_t i;
26817 swig_cast_info *equiv;
26818 static int init_run = 0;
26819
26820 if (init_run) return;
26821 init_run = 1;
26822
26823 for (i = 0; i < swig_module.size; i++) {
26824 if (swig_module.types[i]->clientdata) {
26825 equiv = swig_module.types[i]->cast;
26826 while (equiv) {
26827 if (!equiv->converter) {
26828 if (equiv->type && !equiv->type->clientdata)
26829 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
26830 }
26831 equiv = equiv->next;
26832 }
26833 }
26834 }
26835 }
26836
26837 #ifdef __cplusplus
26838 #if 0
26839 {
26840 /* c-mode */
26841 #endif
26842 }
26843 #endif
26844
26845
26846
26847 #ifdef __cplusplus
26848 extern "C" {
26849 #endif
26850
26851 /* Python-specific SWIG API */
26852 #define SWIG_newvarlink() SWIG_Python_newvarlink()
26853 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
26854 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
26855
26856 /* -----------------------------------------------------------------------------
26857 * global variable support code.
26858 * ----------------------------------------------------------------------------- */
26859
26860 typedef struct swig_globalvar {
26861 char *name; /* Name of global variable */
26862 PyObject *(*get_attr)(void); /* Return the current value */
26863 int (*set_attr)(PyObject *); /* Set the value */
26864 struct swig_globalvar *next;
26865 } swig_globalvar;
26866
26867 typedef struct swig_varlinkobject {
26868 PyObject_HEAD
26869 swig_globalvar *vars;
26870 } swig_varlinkobject;
26871
26872 SWIGINTERN PyObject *
26873 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
26874 return PyString_FromString("<Swig global variables>");
26875 }
26876
26877 SWIGINTERN PyObject *
26878 swig_varlink_str(swig_varlinkobject *v) {
26879 PyObject *str = PyString_FromString("(");
26880 swig_globalvar *var;
26881 for (var = v->vars; var; var=var->next) {
26882 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
26883 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
26884 }
26885 PyString_ConcatAndDel(&str,PyString_FromString(")"));
26886 return str;
26887 }
26888
26889 SWIGINTERN int
26890 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
26891 PyObject *str = swig_varlink_str(v);
26892 fprintf(fp,"Swig global variables ");
26893 fprintf(fp,"%s\n", PyString_AsString(str));
26894 Py_DECREF(str);
26895 return 0;
26896 }
26897
26898 SWIGINTERN void
26899 swig_varlink_dealloc(swig_varlinkobject *v) {
26900 swig_globalvar *var = v->vars;
26901 while (var) {
26902 swig_globalvar *n = var->next;
26903 free(var->name);
26904 free(var);
26905 var = n;
26906 }
26907 }
26908
26909 SWIGINTERN PyObject *
26910 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
26911 PyObject *res = NULL;
26912 swig_globalvar *var = v->vars;
26913 while (var) {
26914 if (strcmp(var->name,n) == 0) {
26915 res = (*var->get_attr)();
26916 break;
26917 }
26918 var = var->next;
26919 }
26920 if (res == NULL && !PyErr_Occurred()) {
26921 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
26922 }
26923 return res;
26924 }
26925
26926 SWIGINTERN int
26927 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
26928 int res = 1;
26929 swig_globalvar *var = v->vars;
26930 while (var) {
26931 if (strcmp(var->name,n) == 0) {
26932 res = (*var->set_attr)(p);
26933 break;
26934 }
26935 var = var->next;
26936 }
26937 if (res == 1 && !PyErr_Occurred()) {
26938 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
26939 }
26940 return res;
26941 }
26942
26943 SWIGINTERN PyTypeObject*
26944 swig_varlink_type(void) {
26945 static char varlink__doc__[] = "Swig var link object";
26946 static PyTypeObject varlink_type;
26947 static int type_init = 0;
26948 if (!type_init) {
26949 const PyTypeObject tmp
26950 = {
26951 PyObject_HEAD_INIT(NULL)
26952 0, /* Number of items in variable part (ob_size) */
26953 (char *)"swigvarlink", /* Type name (tp_name) */
26954 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
26955 0, /* Itemsize (tp_itemsize) */
26956 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
26957 (printfunc) swig_varlink_print, /* Print (tp_print) */
26958 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
26959 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
26960 0, /* tp_compare */
26961 (reprfunc) swig_varlink_repr, /* tp_repr */
26962 0, /* tp_as_number */
26963 0, /* tp_as_sequence */
26964 0, /* tp_as_mapping */
26965 0, /* tp_hash */
26966 0, /* tp_call */
26967 (reprfunc)swig_varlink_str, /* tp_str */
26968 0, /* tp_getattro */
26969 0, /* tp_setattro */
26970 0, /* tp_as_buffer */
26971 0, /* tp_flags */
26972 varlink__doc__, /* tp_doc */
26973 0, /* tp_traverse */
26974 0, /* tp_clear */
26975 0, /* tp_richcompare */
26976 0, /* tp_weaklistoffset */
26977 #if PY_VERSION_HEX >= 0x02020000
26978 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
26979 #endif
26980 #if PY_VERSION_HEX >= 0x02030000
26981 0, /* tp_del */
26982 #endif
26983 #ifdef COUNT_ALLOCS
26984 0,0,0,0 /* tp_alloc -> tp_next */
26985 #endif
26986 };
26987 varlink_type = tmp;
26988 varlink_type.ob_type = &PyType_Type;
26989 type_init = 1;
26990 }
26991 return &varlink_type;
26992 }
26993
26994 /* Create a variable linking object for use later */
26995 SWIGINTERN PyObject *
26996 SWIG_Python_newvarlink(void) {
26997 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
26998 if (result) {
26999 result->vars = 0;
27000 }
27001 return ((PyObject*) result);
27002 }
27003
27004 SWIGINTERN void
27005 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
27006 swig_varlinkobject *v = (swig_varlinkobject *) p;
27007 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
27008 if (gv) {
27009 size_t size = strlen(name)+1;
27010 gv->name = (char *)malloc(size);
27011 if (gv->name) {
27012 strncpy(gv->name,name,size);
27013 gv->get_attr = get_attr;
27014 gv->set_attr = set_attr;
27015 gv->next = v->vars;
27016 }
27017 }
27018 v->vars = gv;
27019 }
27020
27021 SWIGINTERN PyObject *
27022 SWIG_globals() {
27023 static PyObject *_SWIG_globals = 0;
27024 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
27025 return _SWIG_globals;
27026 }
27027
27028 /* -----------------------------------------------------------------------------
27029 * constants/methods manipulation
27030 * ----------------------------------------------------------------------------- */
27031
27032 /* Install Constants */
27033 SWIGINTERN void
27034 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
27035 PyObject *obj = 0;
27036 size_t i;
27037 for (i = 0; constants[i].type; ++i) {
27038 switch(constants[i].type) {
27039 case SWIG_PY_POINTER:
27040 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
27041 break;
27042 case SWIG_PY_BINARY:
27043 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
27044 break;
27045 default:
27046 obj = 0;
27047 break;
27048 }
27049 if (obj) {
27050 PyDict_SetItemString(d, constants[i].name, obj);
27051 Py_DECREF(obj);
27052 }
27053 }
27054 }
27055
27056 /* -----------------------------------------------------------------------------*/
27057 /* Fix SwigMethods to carry the callback ptrs when needed */
27058 /* -----------------------------------------------------------------------------*/
27059
27060 SWIGINTERN void
27061 SWIG_Python_FixMethods(PyMethodDef *methods,
27062 swig_const_info *const_table,
27063 swig_type_info **types,
27064 swig_type_info **types_initial) {
27065 size_t i;
27066 for (i = 0; methods[i].ml_name; ++i) {
27067 char *c = methods[i].ml_doc;
27068 if (c && (c = strstr(c, "swig_ptr: "))) {
27069 int j;
27070 swig_const_info *ci = 0;
27071 char *name = c + 10;
27072 for (j = 0; const_table[j].type; ++j) {
27073 if (strncmp(const_table[j].name, name,
27074 strlen(const_table[j].name)) == 0) {
27075 ci = &(const_table[j]);
27076 break;
27077 }
27078 }
27079 if (ci) {
27080 size_t shift = (ci->ptype) - types;
27081 swig_type_info *ty = types_initial[shift];
27082 size_t ldoc = (c - methods[i].ml_doc);
27083 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
27084 char *ndoc = (char*)malloc(ldoc + lptr + 10);
27085 if (ndoc) {
27086 char *buff = ndoc;
27087 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
27088 if (ptr) {
27089 strncpy(buff, methods[i].ml_doc, ldoc);
27090 buff += ldoc;
27091 strncpy(buff, "swig_ptr: ", 10);
27092 buff += 10;
27093 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
27094 methods[i].ml_doc = ndoc;
27095 }
27096 }
27097 }
27098 }
27099 }
27100 }
27101
27102 #ifdef __cplusplus
27103 }
27104 #endif
27105
27106 /* -----------------------------------------------------------------------------*
27107 * Partial Init method
27108 * -----------------------------------------------------------------------------*/
27109
27110 #ifdef __cplusplus
27111 extern "C"
27112 #endif
27113 SWIGEXPORT void SWIG_init(void) {
27114 PyObject *m, *d;
27115
27116 /* Fix SwigMethods to carry the callback ptrs when needed */
27117 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
27118
27119 m = Py_InitModule((char *) SWIG_name, SwigMethods);
27120 d = PyModule_GetDict(m);
27121
27122 SWIG_InitializeModule(0);
27123 SWIG_InstallConstants(d,swig_const_table);
27124
27125
27126 SWIG_Python_SetConstant(d, "OutRegion",SWIG_From_int(static_cast< int >(wxOutRegion)));
27127 SWIG_Python_SetConstant(d, "PartRegion",SWIG_From_int(static_cast< int >(wxPartRegion)));
27128 SWIG_Python_SetConstant(d, "InRegion",SWIG_From_int(static_cast< int >(wxInRegion)));
27129 SWIG_Python_SetConstant(d, "FONTFAMILY_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DEFAULT)));
27130 SWIG_Python_SetConstant(d, "FONTFAMILY_DECORATIVE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DECORATIVE)));
27131 SWIG_Python_SetConstant(d, "FONTFAMILY_ROMAN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_ROMAN)));
27132 SWIG_Python_SetConstant(d, "FONTFAMILY_SCRIPT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SCRIPT)));
27133 SWIG_Python_SetConstant(d, "FONTFAMILY_SWISS",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SWISS)));
27134 SWIG_Python_SetConstant(d, "FONTFAMILY_MODERN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MODERN)));
27135 SWIG_Python_SetConstant(d, "FONTFAMILY_TELETYPE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_TELETYPE)));
27136 SWIG_Python_SetConstant(d, "FONTFAMILY_MAX",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MAX)));
27137 SWIG_Python_SetConstant(d, "FONTFAMILY_UNKNOWN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_UNKNOWN)));
27138 SWIG_Python_SetConstant(d, "FONTSTYLE_NORMAL",SWIG_From_int(static_cast< int >(wxFONTSTYLE_NORMAL)));
27139 SWIG_Python_SetConstant(d, "FONTSTYLE_ITALIC",SWIG_From_int(static_cast< int >(wxFONTSTYLE_ITALIC)));
27140 SWIG_Python_SetConstant(d, "FONTSTYLE_SLANT",SWIG_From_int(static_cast< int >(wxFONTSTYLE_SLANT)));
27141 SWIG_Python_SetConstant(d, "FONTSTYLE_MAX",SWIG_From_int(static_cast< int >(wxFONTSTYLE_MAX)));
27142 SWIG_Python_SetConstant(d, "FONTWEIGHT_NORMAL",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_NORMAL)));
27143 SWIG_Python_SetConstant(d, "FONTWEIGHT_LIGHT",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_LIGHT)));
27144 SWIG_Python_SetConstant(d, "FONTWEIGHT_BOLD",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_BOLD)));
27145 SWIG_Python_SetConstant(d, "FONTWEIGHT_MAX",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_MAX)));
27146 SWIG_Python_SetConstant(d, "FONTFLAG_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFLAG_DEFAULT)));
27147 SWIG_Python_SetConstant(d, "FONTFLAG_ITALIC",SWIG_From_int(static_cast< int >(wxFONTFLAG_ITALIC)));
27148 SWIG_Python_SetConstant(d, "FONTFLAG_SLANT",SWIG_From_int(static_cast< int >(wxFONTFLAG_SLANT)));
27149 SWIG_Python_SetConstant(d, "FONTFLAG_LIGHT",SWIG_From_int(static_cast< int >(wxFONTFLAG_LIGHT)));
27150 SWIG_Python_SetConstant(d, "FONTFLAG_BOLD",SWIG_From_int(static_cast< int >(wxFONTFLAG_BOLD)));
27151 SWIG_Python_SetConstant(d, "FONTFLAG_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_ANTIALIASED)));
27152 SWIG_Python_SetConstant(d, "FONTFLAG_NOT_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_NOT_ANTIALIASED)));
27153 SWIG_Python_SetConstant(d, "FONTFLAG_UNDERLINED",SWIG_From_int(static_cast< int >(wxFONTFLAG_UNDERLINED)));
27154 SWIG_Python_SetConstant(d, "FONTFLAG_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxFONTFLAG_STRIKETHROUGH)));
27155 SWIG_Python_SetConstant(d, "FONTFLAG_MASK",SWIG_From_int(static_cast< int >(wxFONTFLAG_MASK)));
27156 SWIG_Python_SetConstant(d, "FONTENCODING_SYSTEM",SWIG_From_int(static_cast< int >(wxFONTENCODING_SYSTEM)));
27157 SWIG_Python_SetConstant(d, "FONTENCODING_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTENCODING_DEFAULT)));
27158 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_1",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_1)));
27159 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_2",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_2)));
27160 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_3",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_3)));
27161 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_4",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_4)));
27162 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_5",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_5)));
27163 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_6",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_6)));
27164 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_7",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_7)));
27165 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_8",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_8)));
27166 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_9",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_9)));
27167 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_10",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_10)));
27168 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_11",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_11)));
27169 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_12",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_12)));
27170 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_13",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_13)));
27171 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_14",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_14)));
27172 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_15",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_15)));
27173 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_MAX)));
27174 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8)));
27175 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8_U",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8_U)));
27176 SWIG_Python_SetConstant(d, "FONTENCODING_ALTERNATIVE",SWIG_From_int(static_cast< int >(wxFONTENCODING_ALTERNATIVE)));
27177 SWIG_Python_SetConstant(d, "FONTENCODING_BULGARIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_BULGARIAN)));
27178 SWIG_Python_SetConstant(d, "FONTENCODING_CP437",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP437)));
27179 SWIG_Python_SetConstant(d, "FONTENCODING_CP850",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP850)));
27180 SWIG_Python_SetConstant(d, "FONTENCODING_CP852",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP852)));
27181 SWIG_Python_SetConstant(d, "FONTENCODING_CP855",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP855)));
27182 SWIG_Python_SetConstant(d, "FONTENCODING_CP866",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP866)));
27183 SWIG_Python_SetConstant(d, "FONTENCODING_CP874",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP874)));
27184 SWIG_Python_SetConstant(d, "FONTENCODING_CP932",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP932)));
27185 SWIG_Python_SetConstant(d, "FONTENCODING_CP936",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP936)));
27186 SWIG_Python_SetConstant(d, "FONTENCODING_CP949",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP949)));
27187 SWIG_Python_SetConstant(d, "FONTENCODING_CP950",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP950)));
27188 SWIG_Python_SetConstant(d, "FONTENCODING_CP1250",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1250)));
27189 SWIG_Python_SetConstant(d, "FONTENCODING_CP1251",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1251)));
27190 SWIG_Python_SetConstant(d, "FONTENCODING_CP1252",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1252)));
27191 SWIG_Python_SetConstant(d, "FONTENCODING_CP1253",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1253)));
27192 SWIG_Python_SetConstant(d, "FONTENCODING_CP1254",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1254)));
27193 SWIG_Python_SetConstant(d, "FONTENCODING_CP1255",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1255)));
27194 SWIG_Python_SetConstant(d, "FONTENCODING_CP1256",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1256)));
27195 SWIG_Python_SetConstant(d, "FONTENCODING_CP1257",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1257)));
27196 SWIG_Python_SetConstant(d, "FONTENCODING_CP12_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP12_MAX)));
27197 SWIG_Python_SetConstant(d, "FONTENCODING_UTF7",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF7)));
27198 SWIG_Python_SetConstant(d, "FONTENCODING_UTF8",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF8)));
27199 SWIG_Python_SetConstant(d, "FONTENCODING_EUC_JP",SWIG_From_int(static_cast< int >(wxFONTENCODING_EUC_JP)));
27200 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16BE)));
27201 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16LE)));
27202 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32BE)));
27203 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32LE)));
27204 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMAN)));
27205 SWIG_Python_SetConstant(d, "FONTENCODING_MACJAPANESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACJAPANESE)));
27206 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESETRAD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESETRAD)));
27207 SWIG_Python_SetConstant(d, "FONTENCODING_MACKOREAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKOREAN)));
27208 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABIC)));
27209 SWIG_Python_SetConstant(d, "FONTENCODING_MACHEBREW",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACHEBREW)));
27210 SWIG_Python_SetConstant(d, "FONTENCODING_MACGREEK",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGREEK)));
27211 SWIG_Python_SetConstant(d, "FONTENCODING_MACCYRILLIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCYRILLIC)));
27212 SWIG_Python_SetConstant(d, "FONTENCODING_MACDEVANAGARI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDEVANAGARI)));
27213 SWIG_Python_SetConstant(d, "FONTENCODING_MACGURMUKHI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGURMUKHI)));
27214 SWIG_Python_SetConstant(d, "FONTENCODING_MACGUJARATI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGUJARATI)));
27215 SWIG_Python_SetConstant(d, "FONTENCODING_MACORIYA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACORIYA)));
27216 SWIG_Python_SetConstant(d, "FONTENCODING_MACBENGALI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBENGALI)));
27217 SWIG_Python_SetConstant(d, "FONTENCODING_MACTAMIL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTAMIL)));
27218 SWIG_Python_SetConstant(d, "FONTENCODING_MACTELUGU",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTELUGU)));
27219 SWIG_Python_SetConstant(d, "FONTENCODING_MACKANNADA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKANNADA)));
27220 SWIG_Python_SetConstant(d, "FONTENCODING_MACMALAJALAM",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMALAJALAM)));
27221 SWIG_Python_SetConstant(d, "FONTENCODING_MACSINHALESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSINHALESE)));
27222 SWIG_Python_SetConstant(d, "FONTENCODING_MACBURMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBURMESE)));
27223 SWIG_Python_SetConstant(d, "FONTENCODING_MACKHMER",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKHMER)));
27224 SWIG_Python_SetConstant(d, "FONTENCODING_MACTHAI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTHAI)));
27225 SWIG_Python_SetConstant(d, "FONTENCODING_MACLAOTIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACLAOTIAN)));
27226 SWIG_Python_SetConstant(d, "FONTENCODING_MACGEORGIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGEORGIAN)));
27227 SWIG_Python_SetConstant(d, "FONTENCODING_MACARMENIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARMENIAN)));
27228 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESESIMP",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESESIMP)));
27229 SWIG_Python_SetConstant(d, "FONTENCODING_MACTIBETAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTIBETAN)));
27230 SWIG_Python_SetConstant(d, "FONTENCODING_MACMONGOLIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMONGOLIAN)));
27231 SWIG_Python_SetConstant(d, "FONTENCODING_MACETHIOPIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACETHIOPIC)));
27232 SWIG_Python_SetConstant(d, "FONTENCODING_MACCENTRALEUR",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCENTRALEUR)));
27233 SWIG_Python_SetConstant(d, "FONTENCODING_MACVIATNAMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACVIATNAMESE)));
27234 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABICEXT",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABICEXT)));
27235 SWIG_Python_SetConstant(d, "FONTENCODING_MACSYMBOL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSYMBOL)));
27236 SWIG_Python_SetConstant(d, "FONTENCODING_MACDINGBATS",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDINGBATS)));
27237 SWIG_Python_SetConstant(d, "FONTENCODING_MACTURKISH",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTURKISH)));
27238 SWIG_Python_SetConstant(d, "FONTENCODING_MACCROATIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCROATIAN)));
27239 SWIG_Python_SetConstant(d, "FONTENCODING_MACICELANDIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACICELANDIC)));
27240 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMANIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMANIAN)));
27241 SWIG_Python_SetConstant(d, "FONTENCODING_MACCELTIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCELTIC)));
27242 SWIG_Python_SetConstant(d, "FONTENCODING_MACGAELIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGAELIC)));
27243 SWIG_Python_SetConstant(d, "FONTENCODING_MACKEYBOARD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKEYBOARD)));
27244 SWIG_Python_SetConstant(d, "FONTENCODING_MACMIN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMIN)));
27245 SWIG_Python_SetConstant(d, "FONTENCODING_MACMAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMAX)));
27246 SWIG_Python_SetConstant(d, "FONTENCODING_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MAX)));
27247 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16)));
27248 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32)));
27249 SWIG_Python_SetConstant(d, "FONTENCODING_UNICODE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UNICODE)));
27250 SWIG_Python_SetConstant(d, "FONTENCODING_GB2312",SWIG_From_int(static_cast< int >(wxFONTENCODING_GB2312)));
27251 SWIG_Python_SetConstant(d, "FONTENCODING_BIG5",SWIG_From_int(static_cast< int >(wxFONTENCODING_BIG5)));
27252 SWIG_Python_SetConstant(d, "FONTENCODING_SHIFT_JIS",SWIG_From_int(static_cast< int >(wxFONTENCODING_SHIFT_JIS)));
27253
27254 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
27255
27256 SWIG_Python_SetConstant(d, "LANGUAGE_DEFAULT",SWIG_From_int(static_cast< int >(wxLANGUAGE_DEFAULT)));
27257 SWIG_Python_SetConstant(d, "LANGUAGE_UNKNOWN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UNKNOWN)));
27258 SWIG_Python_SetConstant(d, "LANGUAGE_ABKHAZIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ABKHAZIAN)));
27259 SWIG_Python_SetConstant(d, "LANGUAGE_AFAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFAR)));
27260 SWIG_Python_SetConstant(d, "LANGUAGE_AFRIKAANS",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFRIKAANS)));
27261 SWIG_Python_SetConstant(d, "LANGUAGE_ALBANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ALBANIAN)));
27262 SWIG_Python_SetConstant(d, "LANGUAGE_AMHARIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AMHARIC)));
27263 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC)));
27264 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_ALGERIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_ALGERIA)));
27265 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_BAHRAIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_BAHRAIN)));
27266 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_EGYPT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_EGYPT)));
27267 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_IRAQ",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_IRAQ)));
27268 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_JORDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_JORDAN)));
27269 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_KUWAIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_KUWAIT)));
27270 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LEBANON",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LEBANON)));
27271 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LIBYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LIBYA)));
27272 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_MOROCCO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_MOROCCO)));
27273 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_OMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_OMAN)));
27274 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_QATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_QATAR)));
27275 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SAUDI_ARABIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
27276 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SUDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SUDAN)));
27277 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SYRIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SYRIA)));
27278 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_TUNISIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_TUNISIA)));
27279 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_UAE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_UAE)));
27280 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_YEMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_YEMEN)));
27281 SWIG_Python_SetConstant(d, "LANGUAGE_ARMENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARMENIAN)));
27282 SWIG_Python_SetConstant(d, "LANGUAGE_ASSAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ASSAMESE)));
27283 SWIG_Python_SetConstant(d, "LANGUAGE_AYMARA",SWIG_From_int(static_cast< int >(wxLANGUAGE_AYMARA)));
27284 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI)));
27285 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_CYRILLIC)));
27286 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_LATIN)));
27287 SWIG_Python_SetConstant(d, "LANGUAGE_BASHKIR",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASHKIR)));
27288 SWIG_Python_SetConstant(d, "LANGUAGE_BASQUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASQUE)));
27289 SWIG_Python_SetConstant(d, "LANGUAGE_BELARUSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BELARUSIAN)));
27290 SWIG_Python_SetConstant(d, "LANGUAGE_BENGALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BENGALI)));
27291 SWIG_Python_SetConstant(d, "LANGUAGE_BHUTANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BHUTANI)));
27292 SWIG_Python_SetConstant(d, "LANGUAGE_BIHARI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BIHARI)));
27293 SWIG_Python_SetConstant(d, "LANGUAGE_BISLAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_BISLAMA)));
27294 SWIG_Python_SetConstant(d, "LANGUAGE_BRETON",SWIG_From_int(static_cast< int >(wxLANGUAGE_BRETON)));
27295 SWIG_Python_SetConstant(d, "LANGUAGE_BULGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BULGARIAN)));
27296 SWIG_Python_SetConstant(d, "LANGUAGE_BURMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BURMESE)));
27297 SWIG_Python_SetConstant(d, "LANGUAGE_CAMBODIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CAMBODIAN)));
27298 SWIG_Python_SetConstant(d, "LANGUAGE_CATALAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CATALAN)));
27299 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE)));
27300 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SIMPLIFIED",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SIMPLIFIED)));
27301 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TRADITIONAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TRADITIONAL)));
27302 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_HONGKONG",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_HONGKONG)));
27303 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_MACAU",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_MACAU)));
27304 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SINGAPORE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SINGAPORE)));
27305 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TAIWAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TAIWAN)));
27306 SWIG_Python_SetConstant(d, "LANGUAGE_CORSICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CORSICAN)));
27307 SWIG_Python_SetConstant(d, "LANGUAGE_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CROATIAN)));
27308 SWIG_Python_SetConstant(d, "LANGUAGE_CZECH",SWIG_From_int(static_cast< int >(wxLANGUAGE_CZECH)));
27309 SWIG_Python_SetConstant(d, "LANGUAGE_DANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DANISH)));
27310 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH)));
27311 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH_BELGIAN)));
27312 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH)));
27313 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_UK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_UK)));
27314 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_US)));
27315 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_AUSTRALIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_AUSTRALIA)));
27316 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BELIZE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BELIZE)));
27317 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BOTSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BOTSWANA)));
27318 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CANADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CANADA)));
27319 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CARIBBEAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CARIBBEAN)));
27320 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_DENMARK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_DENMARK)));
27321 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_EIRE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_EIRE)));
27322 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_JAMAICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_JAMAICA)));
27323 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_NEW_ZEALAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
27324 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_PHILIPPINES",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_PHILIPPINES)));
27325 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_SOUTH_AFRICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
27326 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_TRINIDAD",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_TRINIDAD)));
27327 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_ZIMBABWE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_ZIMBABWE)));
27328 SWIG_Python_SetConstant(d, "LANGUAGE_ESPERANTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESPERANTO)));
27329 SWIG_Python_SetConstant(d, "LANGUAGE_ESTONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESTONIAN)));
27330 SWIG_Python_SetConstant(d, "LANGUAGE_FAEROESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_FAEROESE)));
27331 SWIG_Python_SetConstant(d, "LANGUAGE_FARSI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FARSI)));
27332 SWIG_Python_SetConstant(d, "LANGUAGE_FIJI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FIJI)));
27333 SWIG_Python_SetConstant(d, "LANGUAGE_FINNISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FINNISH)));
27334 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH)));
27335 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_BELGIAN)));
27336 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_CANADIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_CANADIAN)));
27337 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_LUXEMBOURG)));
27338 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_MONACO",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_MONACO)));
27339 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_SWISS)));
27340 SWIG_Python_SetConstant(d, "LANGUAGE_FRISIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRISIAN)));
27341 SWIG_Python_SetConstant(d, "LANGUAGE_GALICIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GALICIAN)));
27342 SWIG_Python_SetConstant(d, "LANGUAGE_GEORGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GEORGIAN)));
27343 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN)));
27344 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_AUSTRIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_AUSTRIAN)));
27345 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_BELGIUM",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_BELGIUM)));
27346 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LIECHTENSTEIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
27347 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LUXEMBOURG)));
27348 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_SWISS)));
27349 SWIG_Python_SetConstant(d, "LANGUAGE_GREEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREEK)));
27350 SWIG_Python_SetConstant(d, "LANGUAGE_GREENLANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREENLANDIC)));
27351 SWIG_Python_SetConstant(d, "LANGUAGE_GUARANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUARANI)));
27352 SWIG_Python_SetConstant(d, "LANGUAGE_GUJARATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUJARATI)));
27353 SWIG_Python_SetConstant(d, "LANGUAGE_HAUSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_HAUSA)));
27354 SWIG_Python_SetConstant(d, "LANGUAGE_HEBREW",SWIG_From_int(static_cast< int >(wxLANGUAGE_HEBREW)));
27355 SWIG_Python_SetConstant(d, "LANGUAGE_HINDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_HINDI)));
27356 SWIG_Python_SetConstant(d, "LANGUAGE_HUNGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_HUNGARIAN)));
27357 SWIG_Python_SetConstant(d, "LANGUAGE_ICELANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ICELANDIC)));
27358 SWIG_Python_SetConstant(d, "LANGUAGE_INDONESIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_INDONESIAN)));
27359 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUA)));
27360 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUE)));
27361 SWIG_Python_SetConstant(d, "LANGUAGE_INUKTITUT",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUKTITUT)));
27362 SWIG_Python_SetConstant(d, "LANGUAGE_INUPIAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUPIAK)));
27363 SWIG_Python_SetConstant(d, "LANGUAGE_IRISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_IRISH)));
27364 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN)));
27365 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN_SWISS)));
27366 SWIG_Python_SetConstant(d, "LANGUAGE_JAPANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAPANESE)));
27367 SWIG_Python_SetConstant(d, "LANGUAGE_JAVANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAVANESE)));
27368 SWIG_Python_SetConstant(d, "LANGUAGE_KANNADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KANNADA)));
27369 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI)));
27370 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI_INDIA)));
27371 SWIG_Python_SetConstant(d, "LANGUAGE_KAZAKH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KAZAKH)));
27372 SWIG_Python_SetConstant(d, "LANGUAGE_KERNEWEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_KERNEWEK)));
27373 SWIG_Python_SetConstant(d, "LANGUAGE_KINYARWANDA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KINYARWANDA)));
27374 SWIG_Python_SetConstant(d, "LANGUAGE_KIRGHIZ",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRGHIZ)));
27375 SWIG_Python_SetConstant(d, "LANGUAGE_KIRUNDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRUNDI)));
27376 SWIG_Python_SetConstant(d, "LANGUAGE_KONKANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KONKANI)));
27377 SWIG_Python_SetConstant(d, "LANGUAGE_KOREAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_KOREAN)));
27378 SWIG_Python_SetConstant(d, "LANGUAGE_KURDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KURDISH)));
27379 SWIG_Python_SetConstant(d, "LANGUAGE_LAOTHIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LAOTHIAN)));
27380 SWIG_Python_SetConstant(d, "LANGUAGE_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATIN)));
27381 SWIG_Python_SetConstant(d, "LANGUAGE_LATVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATVIAN)));
27382 SWIG_Python_SetConstant(d, "LANGUAGE_LINGALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_LINGALA)));
27383 SWIG_Python_SetConstant(d, "LANGUAGE_LITHUANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LITHUANIAN)));
27384 SWIG_Python_SetConstant(d, "LANGUAGE_MACEDONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MACEDONIAN)));
27385 SWIG_Python_SetConstant(d, "LANGUAGE_MALAGASY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAGASY)));
27386 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY)));
27387 SWIG_Python_SetConstant(d, "LANGUAGE_MALAYALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAYALAM)));
27388 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_BRUNEI_DARUSSALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
27389 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_MALAYSIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_MALAYSIA)));
27390 SWIG_Python_SetConstant(d, "LANGUAGE_MALTESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALTESE)));
27391 SWIG_Python_SetConstant(d, "LANGUAGE_MANIPURI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MANIPURI)));
27392 SWIG_Python_SetConstant(d, "LANGUAGE_MAORI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MAORI)));
27393 SWIG_Python_SetConstant(d, "LANGUAGE_MARATHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MARATHI)));
27394 SWIG_Python_SetConstant(d, "LANGUAGE_MOLDAVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MOLDAVIAN)));
27395 SWIG_Python_SetConstant(d, "LANGUAGE_MONGOLIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MONGOLIAN)));
27396 SWIG_Python_SetConstant(d, "LANGUAGE_NAURU",SWIG_From_int(static_cast< int >(wxLANGUAGE_NAURU)));
27397 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI)));
27398 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI_INDIA)));
27399 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_BOKMAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_BOKMAL)));
27400 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_NYNORSK",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_NYNORSK)));
27401 SWIG_Python_SetConstant(d, "LANGUAGE_OCCITAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_OCCITAN)));
27402 SWIG_Python_SetConstant(d, "LANGUAGE_ORIYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ORIYA)));
27403 SWIG_Python_SetConstant(d, "LANGUAGE_OROMO",SWIG_From_int(static_cast< int >(wxLANGUAGE_OROMO)));
27404 SWIG_Python_SetConstant(d, "LANGUAGE_PASHTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_PASHTO)));
27405 SWIG_Python_SetConstant(d, "LANGUAGE_POLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_POLISH)));
27406 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE)));
27407 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE_BRAZILIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
27408 SWIG_Python_SetConstant(d, "LANGUAGE_PUNJABI",SWIG_From_int(static_cast< int >(wxLANGUAGE_PUNJABI)));
27409 SWIG_Python_SetConstant(d, "LANGUAGE_QUECHUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_QUECHUA)));
27410 SWIG_Python_SetConstant(d, "LANGUAGE_RHAETO_ROMANCE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RHAETO_ROMANCE)));
27411 SWIG_Python_SetConstant(d, "LANGUAGE_ROMANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ROMANIAN)));
27412 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN)));
27413 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN_UKRAINE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN_UKRAINE)));
27414 SWIG_Python_SetConstant(d, "LANGUAGE_SAMOAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SAMOAN)));
27415 SWIG_Python_SetConstant(d, "LANGUAGE_SANGHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANGHO)));
27416 SWIG_Python_SetConstant(d, "LANGUAGE_SANSKRIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANSKRIT)));
27417 SWIG_Python_SetConstant(d, "LANGUAGE_SCOTS_GAELIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SCOTS_GAELIC)));
27418 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN)));
27419 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_CYRILLIC)));
27420 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_LATIN)));
27421 SWIG_Python_SetConstant(d, "LANGUAGE_SERBO_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBO_CROATIAN)));
27422 SWIG_Python_SetConstant(d, "LANGUAGE_SESOTHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SESOTHO)));
27423 SWIG_Python_SetConstant(d, "LANGUAGE_SETSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SETSWANA)));
27424 SWIG_Python_SetConstant(d, "LANGUAGE_SHONA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SHONA)));
27425 SWIG_Python_SetConstant(d, "LANGUAGE_SINDHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINDHI)));
27426 SWIG_Python_SetConstant(d, "LANGUAGE_SINHALESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINHALESE)));
27427 SWIG_Python_SetConstant(d, "LANGUAGE_SISWATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SISWATI)));
27428 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVAK)));
27429 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVENIAN)));
27430 SWIG_Python_SetConstant(d, "LANGUAGE_SOMALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SOMALI)));
27431 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH)));
27432 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ARGENTINA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ARGENTINA)));
27433 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_BOLIVIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_BOLIVIA)));
27434 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_CHILE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_CHILE)));
27435 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COLOMBIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COLOMBIA)));
27436 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COSTA_RICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COSTA_RICA)));
27437 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_DOMINICAN_REPUBLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
27438 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ECUADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ECUADOR)));
27439 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_EL_SALVADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_EL_SALVADOR)));
27440 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_GUATEMALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_GUATEMALA)));
27441 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_HONDURAS",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_HONDURAS)));
27442 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MEXICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MEXICAN)));
27443 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MODERN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MODERN)));
27444 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_NICARAGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_NICARAGUA)));
27445 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PANAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PANAMA)));
27446 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PARAGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PARAGUAY)));
27447 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PERU",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PERU)));
27448 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PUERTO_RICO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PUERTO_RICO)));
27449 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_URUGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_URUGUAY)));
27450 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_US)));
27451 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_VENEZUELA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_VENEZUELA)));
27452 SWIG_Python_SetConstant(d, "LANGUAGE_SUNDANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SUNDANESE)));
27453 SWIG_Python_SetConstant(d, "LANGUAGE_SWAHILI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWAHILI)));
27454 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH)));
27455 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH_FINLAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH_FINLAND)));
27456 SWIG_Python_SetConstant(d, "LANGUAGE_TAGALOG",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAGALOG)));
27457 SWIG_Python_SetConstant(d, "LANGUAGE_TAJIK",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAJIK)));
27458 SWIG_Python_SetConstant(d, "LANGUAGE_TAMIL",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAMIL)));
27459 SWIG_Python_SetConstant(d, "LANGUAGE_TATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_TATAR)));
27460 SWIG_Python_SetConstant(d, "LANGUAGE_TELUGU",SWIG_From_int(static_cast< int >(wxLANGUAGE_TELUGU)));
27461 SWIG_Python_SetConstant(d, "LANGUAGE_THAI",SWIG_From_int(static_cast< int >(wxLANGUAGE_THAI)));
27462 SWIG_Python_SetConstant(d, "LANGUAGE_TIBETAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIBETAN)));
27463 SWIG_Python_SetConstant(d, "LANGUAGE_TIGRINYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIGRINYA)));
27464 SWIG_Python_SetConstant(d, "LANGUAGE_TONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TONGA)));
27465 SWIG_Python_SetConstant(d, "LANGUAGE_TSONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TSONGA)));
27466 SWIG_Python_SetConstant(d, "LANGUAGE_TURKISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKISH)));
27467 SWIG_Python_SetConstant(d, "LANGUAGE_TURKMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKMEN)));
27468 SWIG_Python_SetConstant(d, "LANGUAGE_TWI",SWIG_From_int(static_cast< int >(wxLANGUAGE_TWI)));
27469 SWIG_Python_SetConstant(d, "LANGUAGE_UIGHUR",SWIG_From_int(static_cast< int >(wxLANGUAGE_UIGHUR)));
27470 SWIG_Python_SetConstant(d, "LANGUAGE_UKRAINIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UKRAINIAN)));
27471 SWIG_Python_SetConstant(d, "LANGUAGE_URDU",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU)));
27472 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_INDIA)));
27473 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_PAKISTAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_PAKISTAN)));
27474 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK)));
27475 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_CYRILLIC)));
27476 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_LATIN)));
27477 SWIG_Python_SetConstant(d, "LANGUAGE_VIETNAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_VIETNAMESE)));
27478 SWIG_Python_SetConstant(d, "LANGUAGE_VOLAPUK",SWIG_From_int(static_cast< int >(wxLANGUAGE_VOLAPUK)));
27479 SWIG_Python_SetConstant(d, "LANGUAGE_WELSH",SWIG_From_int(static_cast< int >(wxLANGUAGE_WELSH)));
27480 SWIG_Python_SetConstant(d, "LANGUAGE_WOLOF",SWIG_From_int(static_cast< int >(wxLANGUAGE_WOLOF)));
27481 SWIG_Python_SetConstant(d, "LANGUAGE_XHOSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_XHOSA)));
27482 SWIG_Python_SetConstant(d, "LANGUAGE_YIDDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_YIDDISH)));
27483 SWIG_Python_SetConstant(d, "LANGUAGE_YORUBA",SWIG_From_int(static_cast< int >(wxLANGUAGE_YORUBA)));
27484 SWIG_Python_SetConstant(d, "LANGUAGE_ZHUANG",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZHUANG)));
27485 SWIG_Python_SetConstant(d, "LANGUAGE_ZULU",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZULU)));
27486 SWIG_Python_SetConstant(d, "LANGUAGE_USER_DEFINED",SWIG_From_int(static_cast< int >(wxLANGUAGE_USER_DEFINED)));
27487 SWIG_Python_SetConstant(d, "LOCALE_CAT_NUMBER",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_NUMBER)));
27488 SWIG_Python_SetConstant(d, "LOCALE_CAT_DATE",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_DATE)));
27489 SWIG_Python_SetConstant(d, "LOCALE_CAT_MONEY",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MONEY)));
27490 SWIG_Python_SetConstant(d, "LOCALE_CAT_MAX",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MAX)));
27491 SWIG_Python_SetConstant(d, "LOCALE_THOUSANDS_SEP",SWIG_From_int(static_cast< int >(wxLOCALE_THOUSANDS_SEP)));
27492 SWIG_Python_SetConstant(d, "LOCALE_DECIMAL_POINT",SWIG_From_int(static_cast< int >(wxLOCALE_DECIMAL_POINT)));
27493 SWIG_Python_SetConstant(d, "LOCALE_LOAD_DEFAULT",SWIG_From_int(static_cast< int >(wxLOCALE_LOAD_DEFAULT)));
27494 SWIG_Python_SetConstant(d, "LOCALE_CONV_ENCODING",SWIG_From_int(static_cast< int >(wxLOCALE_CONV_ENCODING)));
27495 SWIG_Python_SetConstant(d, "CONVERT_STRICT",SWIG_From_int(static_cast< int >(wxCONVERT_STRICT)));
27496 SWIG_Python_SetConstant(d, "CONVERT_SUBSTITUTE",SWIG_From_int(static_cast< int >(wxCONVERT_SUBSTITUTE)));
27497 SWIG_Python_SetConstant(d, "PLATFORM_CURRENT",SWIG_From_int(static_cast< int >(wxPLATFORM_CURRENT)));
27498 SWIG_Python_SetConstant(d, "PLATFORM_UNIX",SWIG_From_int(static_cast< int >(wxPLATFORM_UNIX)));
27499 SWIG_Python_SetConstant(d, "PLATFORM_WINDOWS",SWIG_From_int(static_cast< int >(wxPLATFORM_WINDOWS)));
27500 SWIG_Python_SetConstant(d, "PLATFORM_OS2",SWIG_From_int(static_cast< int >(wxPLATFORM_OS2)));
27501 SWIG_Python_SetConstant(d, "PLATFORM_MAC",SWIG_From_int(static_cast< int >(wxPLATFORM_MAC)));
27502 SWIG_Python_SetConstant(d, "BUFFER_VIRTUAL_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_VIRTUAL_AREA)));
27503 SWIG_Python_SetConstant(d, "BUFFER_CLIENT_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_CLIENT_AREA)));
27504 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_NORMAL)));
27505 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_TRANSPARENT)));
27506 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_SELECTED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_SELECTED)));
27507 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_FOCUSED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_FOCUSED)));
27508 SWIG_Python_SetConstant(d, "IMAGE_LIST_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_NORMAL)));
27509 SWIG_Python_SetConstant(d, "IMAGE_LIST_SMALL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_SMALL)));
27510 SWIG_Python_SetConstant(d, "IMAGE_LIST_STATE",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_STATE)));
27511 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
27512 SWIG_addvarlink(SWIG_globals(),(char*)"NORMAL_FONT",NORMAL_FONT_get, NORMAL_FONT_set);
27513 SWIG_addvarlink(SWIG_globals(),(char*)"SMALL_FONT",SMALL_FONT_get, SMALL_FONT_set);
27514 SWIG_addvarlink(SWIG_globals(),(char*)"ITALIC_FONT",ITALIC_FONT_get, ITALIC_FONT_set);
27515 SWIG_addvarlink(SWIG_globals(),(char*)"SWISS_FONT",SWISS_FONT_get, SWISS_FONT_set);
27516 SWIG_addvarlink(SWIG_globals(),(char*)"RED_PEN",RED_PEN_get, RED_PEN_set);
27517 SWIG_addvarlink(SWIG_globals(),(char*)"CYAN_PEN",CYAN_PEN_get, CYAN_PEN_set);
27518 SWIG_addvarlink(SWIG_globals(),(char*)"GREEN_PEN",GREEN_PEN_get, GREEN_PEN_set);
27519 SWIG_addvarlink(SWIG_globals(),(char*)"BLACK_PEN",BLACK_PEN_get, BLACK_PEN_set);
27520 SWIG_addvarlink(SWIG_globals(),(char*)"WHITE_PEN",WHITE_PEN_get, WHITE_PEN_set);
27521 SWIG_addvarlink(SWIG_globals(),(char*)"TRANSPARENT_PEN",TRANSPARENT_PEN_get, TRANSPARENT_PEN_set);
27522 SWIG_addvarlink(SWIG_globals(),(char*)"BLACK_DASHED_PEN",BLACK_DASHED_PEN_get, BLACK_DASHED_PEN_set);
27523 SWIG_addvarlink(SWIG_globals(),(char*)"GREY_PEN",GREY_PEN_get, GREY_PEN_set);
27524 SWIG_addvarlink(SWIG_globals(),(char*)"MEDIUM_GREY_PEN",MEDIUM_GREY_PEN_get, MEDIUM_GREY_PEN_set);
27525 SWIG_addvarlink(SWIG_globals(),(char*)"LIGHT_GREY_PEN",LIGHT_GREY_PEN_get, LIGHT_GREY_PEN_set);
27526 SWIG_addvarlink(SWIG_globals(),(char*)"BLUE_BRUSH",BLUE_BRUSH_get, BLUE_BRUSH_set);
27527 SWIG_addvarlink(SWIG_globals(),(char*)"GREEN_BRUSH",GREEN_BRUSH_get, GREEN_BRUSH_set);
27528 SWIG_addvarlink(SWIG_globals(),(char*)"WHITE_BRUSH",WHITE_BRUSH_get, WHITE_BRUSH_set);
27529 SWIG_addvarlink(SWIG_globals(),(char*)"BLACK_BRUSH",BLACK_BRUSH_get, BLACK_BRUSH_set);
27530 SWIG_addvarlink(SWIG_globals(),(char*)"TRANSPARENT_BRUSH",TRANSPARENT_BRUSH_get, TRANSPARENT_BRUSH_set);
27531 SWIG_addvarlink(SWIG_globals(),(char*)"CYAN_BRUSH",CYAN_BRUSH_get, CYAN_BRUSH_set);
27532 SWIG_addvarlink(SWIG_globals(),(char*)"RED_BRUSH",RED_BRUSH_get, RED_BRUSH_set);
27533 SWIG_addvarlink(SWIG_globals(),(char*)"GREY_BRUSH",GREY_BRUSH_get, GREY_BRUSH_set);
27534 SWIG_addvarlink(SWIG_globals(),(char*)"MEDIUM_GREY_BRUSH",MEDIUM_GREY_BRUSH_get, MEDIUM_GREY_BRUSH_set);
27535 SWIG_addvarlink(SWIG_globals(),(char*)"LIGHT_GREY_BRUSH",LIGHT_GREY_BRUSH_get, LIGHT_GREY_BRUSH_set);
27536 SWIG_addvarlink(SWIG_globals(),(char*)"BLACK",BLACK_get, BLACK_set);
27537 SWIG_addvarlink(SWIG_globals(),(char*)"WHITE",WHITE_get, WHITE_set);
27538 SWIG_addvarlink(SWIG_globals(),(char*)"RED",RED_get, RED_set);
27539 SWIG_addvarlink(SWIG_globals(),(char*)"BLUE",BLUE_get, BLUE_set);
27540 SWIG_addvarlink(SWIG_globals(),(char*)"GREEN",GREEN_get, GREEN_set);
27541 SWIG_addvarlink(SWIG_globals(),(char*)"CYAN",CYAN_get, CYAN_set);
27542 SWIG_addvarlink(SWIG_globals(),(char*)"LIGHT_GREY",LIGHT_GREY_get, LIGHT_GREY_set);
27543 SWIG_addvarlink(SWIG_globals(),(char*)"STANDARD_CURSOR",STANDARD_CURSOR_get, STANDARD_CURSOR_set);
27544 SWIG_addvarlink(SWIG_globals(),(char*)"HOURGLASS_CURSOR",HOURGLASS_CURSOR_get, HOURGLASS_CURSOR_set);
27545 SWIG_addvarlink(SWIG_globals(),(char*)"CROSS_CURSOR",CROSS_CURSOR_get, CROSS_CURSOR_set);
27546 SWIG_addvarlink(SWIG_globals(),(char*)"NullBitmap",NullBitmap_get, NullBitmap_set);
27547 SWIG_addvarlink(SWIG_globals(),(char*)"NullIcon",NullIcon_get, NullIcon_set);
27548 SWIG_addvarlink(SWIG_globals(),(char*)"NullCursor",NullCursor_get, NullCursor_set);
27549 SWIG_addvarlink(SWIG_globals(),(char*)"NullPen",NullPen_get, NullPen_set);
27550 SWIG_addvarlink(SWIG_globals(),(char*)"NullBrush",NullBrush_get, NullBrush_set);
27551 SWIG_addvarlink(SWIG_globals(),(char*)"NullPalette",NullPalette_get, NullPalette_set);
27552 SWIG_addvarlink(SWIG_globals(),(char*)"NullFont",NullFont_get, NullFont_set);
27553 SWIG_addvarlink(SWIG_globals(),(char*)"NullColour",NullColour_get, NullColour_set);
27554 SWIG_addvarlink(SWIG_globals(),(char*)"TheFontList",TheFontList_get, TheFontList_set);
27555 SWIG_addvarlink(SWIG_globals(),(char*)"ThePenList",ThePenList_get, ThePenList_set);
27556 SWIG_addvarlink(SWIG_globals(),(char*)"TheBrushList",TheBrushList_get, TheBrushList_set);
27557 SWIG_addvarlink(SWIG_globals(),(char*)"TheColourDatabase",TheColourDatabase_get, TheColourDatabase_set);
27558 SWIG_Python_SetConstant(d, "CONTROL_DISABLED",SWIG_From_int(static_cast< int >(wxCONTROL_DISABLED)));
27559 SWIG_Python_SetConstant(d, "CONTROL_FOCUSED",SWIG_From_int(static_cast< int >(wxCONTROL_FOCUSED)));
27560 SWIG_Python_SetConstant(d, "CONTROL_PRESSED",SWIG_From_int(static_cast< int >(wxCONTROL_PRESSED)));
27561 SWIG_Python_SetConstant(d, "CONTROL_ISDEFAULT",SWIG_From_int(static_cast< int >(wxCONTROL_ISDEFAULT)));
27562 SWIG_Python_SetConstant(d, "CONTROL_ISSUBMENU",SWIG_From_int(static_cast< int >(wxCONTROL_ISSUBMENU)));
27563 SWIG_Python_SetConstant(d, "CONTROL_EXPANDED",SWIG_From_int(static_cast< int >(wxCONTROL_EXPANDED)));
27564 SWIG_Python_SetConstant(d, "CONTROL_CURRENT",SWIG_From_int(static_cast< int >(wxCONTROL_CURRENT)));
27565 SWIG_Python_SetConstant(d, "CONTROL_SELECTED",SWIG_From_int(static_cast< int >(wxCONTROL_SELECTED)));
27566 SWIG_Python_SetConstant(d, "CONTROL_CHECKED",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKED)));
27567 SWIG_Python_SetConstant(d, "CONTROL_CHECKABLE",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKABLE)));
27568 SWIG_Python_SetConstant(d, "CONTROL_UNDETERMINED",SWIG_From_int(static_cast< int >(wxCONTROL_UNDETERMINED)));
27569 SWIG_Python_SetConstant(d, "CONTROL_FLAGS_MASK",SWIG_From_int(static_cast< int >(wxCONTROL_FLAGS_MASK)));
27570 SWIG_Python_SetConstant(d, "CONTROL_DIRTY",SWIG_From_int(static_cast< int >(wxCONTROL_DIRTY)));
27571 SWIG_Python_SetConstant(d, "RendererVersion_Current_Version",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Version)));
27572 SWIG_Python_SetConstant(d, "RendererVersion_Current_Age",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Age)));
27573
27574 // Work around a chicken/egg problem in drawlist.cpp
27575 wxPyDrawList_SetAPIPtr();
27576
27577 }
27578
wxWidgets (Impactor)