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


996a0cc2cfecc75bbbdc667ff6a18b390b30daea
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_double swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[10]
2477 #define SWIGTYPE_p_wxBitmap swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxBrush swig_types[13]
2480 #define SWIGTYPE_p_wxBrushList swig_types[14]
2481 #define SWIGTYPE_p_wxBufferedDC swig_types[15]
2482 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxChildFocusEvent swig_types[18]
2485 #define SWIGTYPE_p_wxClientDC swig_types[19]
2486 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[20]
2487 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2488 #define SWIGTYPE_p_wxColour swig_types[22]
2489 #define SWIGTYPE_p_wxColourDatabase swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDash swig_types[30]
2497 #define SWIGTYPE_p_wxDateEvent swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEffects swig_types[35]
2502 #define SWIGTYPE_p_wxEncodingConverter swig_types[36]
2503 #define SWIGTYPE_p_wxEraseEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEvent swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2509 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2510 #define SWIGTYPE_p_wxFont swig_types[44]
2511 #define SWIGTYPE_p_wxFontList swig_types[45]
2512 #define SWIGTYPE_p_wxFontMapper swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGDIObjListBase swig_types[48]
2515 #define SWIGTYPE_p_wxGDIObject swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2520 #define SWIGTYPE_p_wxIcon swig_types[54]
2521 #define SWIGTYPE_p_wxIconBundle swig_types[55]
2522 #define SWIGTYPE_p_wxIconLocation swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageList swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
2531 #define SWIGTYPE_p_wxKeyEvent swig_types[65]
2532 #define SWIGTYPE_p_wxLanguageInfo swig_types[66]
2533 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2534 #define SWIGTYPE_p_wxLocale swig_types[68]
2535 #define SWIGTYPE_p_wxMask swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryDC swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2541 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2542 #define SWIGTYPE_p_wxMetaFile swig_types[76]
2543 #define SWIGTYPE_p_wxMetaFileDC swig_types[77]
2544 #define SWIGTYPE_p_wxMirrorDC swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[82]
2549 #define SWIGTYPE_p_wxNativeFontInfo swig_types[83]
2550 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNcPaintEvent swig_types[85]
2552 #define SWIGTYPE_p_wxNotifyEvent swig_types[86]
2553 #define SWIGTYPE_p_wxObject swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintDC swig_types[91]
2558 #define SWIGTYPE_p_wxPaintEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPalette swig_types[93]
2560 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[94]
2561 #define SWIGTYPE_p_wxPaperSize swig_types[95]
2562 #define SWIGTYPE_p_wxPen swig_types[96]
2563 #define SWIGTYPE_p_wxPenList swig_types[97]
2564 #define SWIGTYPE_p_wxPoint swig_types[98]
2565 #define SWIGTYPE_p_wxPostScriptDC swig_types[99]
2566 #define SWIGTYPE_p_wxPrintData swig_types[100]
2567 #define SWIGTYPE_p_wxPrinterDC swig_types[101]
2568 #define SWIGTYPE_p_wxPseudoDC swig_types[102]
2569 #define SWIGTYPE_p_wxPyApp swig_types[103]
2570 #define SWIGTYPE_p_wxPyCommandEvent swig_types[104]
2571 #define SWIGTYPE_p_wxPyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[106]
2573 #define SWIGTYPE_p_wxPyImageHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPySizer swig_types[108]
2575 #define SWIGTYPE_p_wxPyValidator swig_types[109]
2576 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxRegionIterator swig_types[113]
2580 #define SWIGTYPE_p_wxRendererNative swig_types[114]
2581 #define SWIGTYPE_p_wxRendererVersion swig_types[115]
2582 #define SWIGTYPE_p_wxScreenDC swig_types[116]
2583 #define SWIGTYPE_p_wxScrollEvent swig_types[117]
2584 #define SWIGTYPE_p_wxScrollWinEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSetCursorEvent swig_types[119]
2586 #define SWIGTYPE_p_wxShowEvent swig_types[120]
2587 #define SWIGTYPE_p_wxSize swig_types[121]
2588 #define SWIGTYPE_p_wxSizeEvent swig_types[122]
2589 #define SWIGTYPE_p_wxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxSizerItem swig_types[124]
2591 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[125]
2592 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[126]
2593 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[127]
2594 #define SWIGTYPE_p_wxStockGDI swig_types[128]
2595 #define SWIGTYPE_p_wxString swig_types[129]
2596 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[130]
2597 #define SWIGTYPE_p_wxTIFFHandler swig_types[131]
2598 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[132]
2599 #define SWIGTYPE_p_wxValidator swig_types[133]
2600 #define SWIGTYPE_p_wxWindow swig_types[134]
2601 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[135]
2602 #define SWIGTYPE_p_wxWindowDC swig_types[136]
2603 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[137]
2604 #define SWIGTYPE_p_wxXPMHandler swig_types[138]
2605 static swig_type_info *swig_types[140];
2606 static swig_module_info swig_module = {swig_types, 139, 0, 0, 0, 0};
2607 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2608 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2609
2610 /* -------- TYPES TABLE (END) -------- */
2611
2612 #if (PY_VERSION_HEX <= 0x02000000)
2613 # if !defined(SWIG_PYTHON_CLASSIC)
2614 # error "This python version requires to use swig with the '-classic' option"
2615 # endif
2616 #endif
2617 #if (PY_VERSION_HEX <= 0x02020000)
2618 # error "This python version requires to use swig with the '-nomodern' option"
2619 #endif
2620 #if (PY_VERSION_HEX <= 0x02020000)
2621 # error "This python version requires to use swig with the '-nomodernargs' option"
2622 #endif
2623 #ifndef METH_O
2624 # error "This python version requires to use swig with the '-nofastunpack' option"
2625 #endif
2626
2627 /*-----------------------------------------------
2628 @(target):= _gdi_.so
2629 ------------------------------------------------*/
2630 #define SWIG_init init_gdi_
2631
2632 #define SWIG_name "_gdi_"
2633
2634 #define SWIGVERSION 0x010329
2635
2636
2637 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2638 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2639
2640
2641 #include <stdexcept>
2642
2643
2644 namespace swig {
2645 class PyObject_ptr {
2646 protected:
2647 PyObject *_obj;
2648
2649 public:
2650 PyObject_ptr() :_obj(0)
2651 {
2652 }
2653
2654 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2655 {
2656 Py_XINCREF(_obj);
2657 }
2658
2659 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2660 {
2661 if (initial_ref) Py_XINCREF(_obj);
2662 }
2663
2664 PyObject_ptr & operator=(const PyObject_ptr& item)
2665 {
2666 Py_XINCREF(item._obj);
2667 Py_XDECREF(_obj);
2668 _obj = item._obj;
2669 return *this;
2670 }
2671
2672 ~PyObject_ptr()
2673 {
2674 Py_XDECREF(_obj);
2675 }
2676
2677 operator PyObject *() const
2678 {
2679 return _obj;
2680 }
2681
2682 PyObject *operator->() const
2683 {
2684 return _obj;
2685 }
2686 };
2687 }
2688
2689
2690 namespace swig {
2691 struct PyObject_var : PyObject_ptr {
2692 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2693
2694 PyObject_var & operator = (PyObject* obj)
2695 {
2696 Py_XDECREF(_obj);
2697 _obj = obj;
2698 return *this;
2699 }
2700 };
2701 }
2702
2703
2704 #include "wx/wxPython/wxPython.h"
2705 #include "wx/wxPython/pyclasses.h"
2706
2707
2708 static const wxString wxPyEmptyString(wxEmptyString);
2709
2710 #define SWIG_From_long PyInt_FromLong
2711
2712
2713 SWIGINTERNINLINE PyObject *
2714 SWIG_From_int (int value)
2715 {
2716 return SWIG_From_long (value);
2717 }
2718
2719
2720 #include <limits.h>
2721 #ifndef LLONG_MIN
2722 # define LLONG_MIN LONG_LONG_MIN
2723 #endif
2724 #ifndef LLONG_MAX
2725 # define LLONG_MAX LONG_LONG_MAX
2726 #endif
2727 #ifndef ULLONG_MAX
2728 # define ULLONG_MAX ULONG_LONG_MAX
2729 #endif
2730
2731
2732 SWIGINTERN int
2733 SWIG_AsVal_long (PyObject* obj, long* val)
2734 {
2735 if (PyNumber_Check(obj)) {
2736 if (val) *val = PyInt_AsLong(obj);
2737 return SWIG_OK;
2738 }
2739 return SWIG_TypeError;
2740 }
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 SWIGINTERNINLINE PyObject*
2773 SWIG_From_unsigned_SS_long (unsigned long value)
2774 {
2775 return (value > LONG_MAX) ?
2776 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2777 }
2778
2779
2780 SWIGINTERNINLINE PyObject *
2781 SWIG_From_unsigned_SS_char (unsigned char value)
2782 {
2783 return SWIG_From_unsigned_SS_long (value);
2784 }
2785
2786 SWIGINTERN bool wxColour___eq__(wxColour *self,PyObject *other){
2787 wxColour temp, *obj = &temp;
2788 if ( other == Py_None ) return false;
2789 if ( ! wxColour_helper(other, &obj) ) {
2790 PyErr_Clear();
2791 return false;
2792 }
2793 return self->operator==(*obj);
2794 }
2795 SWIGINTERN bool wxColour___ne__(wxColour *self,PyObject *other){
2796 wxColour temp, *obj = &temp;
2797 if ( other == Py_None ) return true;
2798 if ( ! wxColour_helper(other, &obj)) {
2799 PyErr_Clear();
2800 return true;
2801 }
2802 return self->operator!=(*obj);
2803 }
2804 SWIGINTERN PyObject *wxColour_Get(wxColour *self){
2805 PyObject* rv = PyTuple_New(3);
2806 int red = -1;
2807 int green = -1;
2808 int blue = -1;
2809 if (self->Ok()) {
2810 red = self->Red();
2811 green = self->Green();
2812 blue = self->Blue();
2813 }
2814 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
2815 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
2816 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
2817 return rv;
2818 }
2819 SWIGINTERN unsigned long wxColour_GetRGB(wxColour *self){
2820 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
2821 }
2822
2823 SWIGINTERN int
2824 SWIG_AsVal_int (PyObject * obj, int *val)
2825 {
2826 long v;
2827 int res = SWIG_AsVal_long (obj, &v);
2828 if (SWIG_IsOK(res)) {
2829 if ((v < INT_MIN || v > INT_MAX)) {
2830 return SWIG_OverflowError;
2831 } else {
2832 if (val) *val = static_cast< int >(v);
2833 }
2834 }
2835 return res;
2836 }
2837
2838 SWIGINTERN PyObject *wxPen_GetDashes(wxPen *self){
2839 wxDash* dashes;
2840 int count = self->GetDashes(&dashes);
2841 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2842 PyObject* retval = PyList_New(0);
2843 for (int x=0; x<count; x++) {
2844 PyObject* pyint = PyInt_FromLong(dashes[x]);
2845 PyList_Append(retval, pyint);
2846 Py_DECREF(pyint);
2847 }
2848 wxPyEndBlockThreads(blocked);
2849 return retval;
2850 }
2851 SWIGINTERN void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
2852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2853 int size = PyList_Size(pyDashes);
2854 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
2855
2856 // black magic warning! The array of wxDashes needs to exist as
2857 // long as the pen does because wxPen does not copy the array. So
2858 // stick a copy in a Python string object and attach it to _self,
2859 // and then call SetDashes with a pointer to that array. Then
2860 // when the Python pen object is destroyed the array will be
2861 // cleaned up too.
2862 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
2863 PyObject_SetAttrString(_self, "_dashes", strDashes);
2864
2865 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
2866 delete [] dashes;
2867 Py_DECREF(strDashes);
2868 wxPyEndBlockThreads(blocked);
2869 }
2870 SWIGINTERN bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
2871 SWIGINTERN bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
2872
2873 #include <wx/image.h>
2874
2875 static char** ConvertListOfStrings(PyObject* listOfStrings) {
2876 char** cArray = NULL;
2877 int count;
2878
2879 if (!PyList_Check(listOfStrings)) {
2880 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2881 return NULL;
2882 }
2883 count = PyList_Size(listOfStrings);
2884 cArray = new char*[count];
2885
2886 for(int x=0; x<count; x++) {
2887 // TODO: Need some validation and error checking here
2888 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
2889 }
2890 return cArray;
2891 }
2892
2893
2894 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *listOfStrings){
2895 char** cArray = NULL;
2896 wxBitmap* bmp;
2897
2898 cArray = ConvertListOfStrings(listOfStrings);
2899 if (! cArray)
2900 return NULL;
2901 bmp = new wxBitmap(cArray);
2902 delete [] cArray;
2903 return bmp;
2904 }
2905 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
2906 char* buf;
2907 Py_ssize_t length;
2908 PyString_AsStringAndSize(bits, &buf, &length);
2909 return new wxBitmap(buf, width, height, depth);
2910 }
2911 SWIGINTERN wxSize wxBitmap_GetSize(wxBitmap *self){
2912 wxSize size(self->GetWidth(), self->GetHeight());
2913 return size;
2914 }
2915 SWIGINTERN void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
2916 wxMask *mask = new wxMask(*self, colour);
2917 self->SetMask(mask);
2918 }
2919 SWIGINTERN void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
2920 self->SetWidth(size.x);
2921 self->SetHeight(size.y);
2922 }
2923 SWIGINTERN bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
2924 SWIGINTERN bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
2925 SWIGINTERN wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
2926 if ( !colour.Ok() )
2927 return new wxMask(bitmap, *wxBLACK);
2928 else
2929 return new wxMask(bitmap, colour);
2930 }
2931
2932 #include <wx/iconbndl.h>
2933
2934 SWIGINTERN wxIcon *new_wxIcon(wxBitmap const &bmp){
2935 wxIcon* icon = new wxIcon();
2936 icon->CopyFromBitmap(bmp);
2937 return icon;
2938 }
2939 SWIGINTERN wxIcon *new_wxIcon(PyObject *listOfStrings){
2940 char** cArray = NULL;
2941 wxIcon* icon;
2942
2943 cArray = ConvertListOfStrings(listOfStrings);
2944 if (! cArray)
2945 return NULL;
2946 icon = new wxIcon(cArray);
2947 delete [] cArray;
2948 return icon;
2949 }
2950 SWIGINTERN wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
2951
2952
2953
2954 return new wxIconLocation(*filename);
2955
2956 }
2957 SWIGINTERN void wxIconLocation_SetIndex(wxIconLocation *self,int num){
2958
2959
2960
2961 // do nothing
2962
2963 }
2964 SWIGINTERN int wxIconLocation_GetIndex(wxIconLocation *self){
2965
2966
2967
2968 return -1;
2969
2970 }
2971 SWIGINTERN wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
2972 #ifdef __WXGTK__
2973 wxImage img(cursorName, type);
2974 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
2975 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
2976 return new wxCursor(img);
2977 #else
2978 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
2979 #endif
2980 }
2981
2982
2983 SWIGINTERN void wxRegionIterator_Next(wxRegionIterator *self){
2984 (*self) ++;
2985 }
2986 SWIGINTERN bool wxRegionIterator___nonzero__(wxRegionIterator *self){
2987 return self->operator bool();
2988 }
2989
2990 #include <wx/fontutil.h>
2991 #include <wx/fontmap.h>
2992 #include <wx/fontenum.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_bool (PyObject *obj, bool *val)
2997 {
2998 if (obj == Py_True) {
2999 if (val) *val = true;
3000 return SWIG_OK;
3001 } else if (obj == Py_False) {
3002 if (val) *val = false;
3003 return SWIG_OK;
3004 } else {
3005 long v = 0;
3006 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3007 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3008 return res;
3009 }
3010 }
3011
3012 SWIGINTERN wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
3013 return self->ToString();
3014 }
3015
3016 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
3017 static wxNativeEncodingInfo info;
3018 if ( wxGetNativeFontEncoding(encoding, &info) )
3019 return &info;
3020 else
3021 return NULL;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_From_size_t (size_t value)
3027 {
3028 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3029 }
3030
3031
3032 SWIGINTERNINLINE int
3033 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3034 {
3035 unsigned long v;
3036 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3037 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3038 return res;
3039 }
3040
3041 SWIGINTERN PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
3042 wxFontEncoding alt_enc;
3043 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
3044 return PyInt_FromLong(alt_enc);
3045 else {
3046 Py_INCREF(Py_None);
3047 return Py_None;
3048 }
3049 }
3050 SWIGINTERN wxFont *new_wxFont(wxString const &info){
3051 wxNativeFontInfo nfi;
3052 nfi.FromString(info);
3053 return new wxFont(nfi);
3054 }
3055 SWIGINTERN wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3056 return wxFont::New(pointSize, family, flags, face, encoding);
3057 }
3058 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3059 return wxFontBase::New(pixelSize, family,
3060 style, weight, underlined,
3061 face, encoding);
3062 }
3063 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3064 return wxFontBase::New(pixelSize, family, flags, face, encoding);
3065 }
3066 SWIGINTERN bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
3067 SWIGINTERN bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
3068
3069 class wxPyFontEnumerator : public wxFontEnumerator {
3070 public:
3071 wxPyFontEnumerator() {}
3072 ~wxPyFontEnumerator() {}
3073
3074 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
3075 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
3076
3077 PYPRIVATE;
3078 };
3079
3080 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
3081 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
3082
3083
3084 SWIGINTERN PyObject *wxPyFontEnumerator_GetEncodings(){
3085 PyObject* ret;
3086 wxArrayString arr = wxFontEnumerator::GetEncodings();
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 ret = wxArrayString2PyList_helper(arr);
3089 wxPyEndBlockThreads(blocked);
3090 return ret;
3091 }
3092 SWIGINTERN PyObject *wxPyFontEnumerator_GetFacenames(){
3093 PyObject* ret;
3094 wxArrayString arr = wxFontEnumerator::GetFacenames();
3095 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3096 ret = wxArrayString2PyList_helper(arr);
3097 wxPyEndBlockThreads(blocked);
3098 return ret;
3099 }
3100
3101 #include <locale.h>
3102
3103 SWIGINTERN wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3104 wxLocale* loc;
3105 if (language == -1)
3106 loc = new wxLocale();
3107 else
3108 loc = new wxLocale(language, flags);
3109 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3110 // for the floating point conversions and such to work right.
3111 #if PY_VERSION_HEX < 0x02040000
3112 setlocale(LC_NUMERIC, "C");
3113 #endif
3114 return loc;
3115 }
3116 SWIGINTERN bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
3117 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
3118 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3119 // for the floating point conversions and such to work right.
3120 #if PY_VERSION_HEX < 0x02040000
3121 setlocale(LC_NUMERIC, "C");
3122 #endif
3123 return rc;
3124 }
3125 SWIGINTERN bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3126 bool rc = self->Init(language, flags);
3127 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3128 // for the floating point conversions and such to work right.
3129 #if PY_VERSION_HEX < 0x02040000
3130 setlocale(LC_NUMERIC, "C");
3131 #endif
3132 return rc;
3133 }
3134
3135 #include "wx/wxPython/pydrawxxx.h"
3136
3137 SWIGINTERN wxColour wxDC_GetPixel(wxDC *self,int x,int y){
3138 wxColour col;
3139 self->GetPixel(x, y, &col);
3140 return col;
3141 }
3142 SWIGINTERN wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
3143 wxColour col;
3144 self->GetPixel(pt, &col);
3145 return col;
3146 }
3147
3148 SWIGINTERN int
3149 SWIG_AsVal_double (PyObject *obj, double* val)
3150 {
3151 if (PyNumber_Check(obj)) {
3152 if (val) *val = PyFloat_AsDouble(obj);
3153 return SWIG_OK;
3154 }
3155 return SWIG_TypeError;
3156 }
3157
3158 SWIGINTERN wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
3159 wxRect rv;
3160 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
3161 return rv;
3162 }
3163 SWIGINTERN wxRect wxDC_GetClippingRect(wxDC *self){
3164 wxRect rect;
3165 self->GetClippingBox(rect);
3166 return rect;
3167 }
3168 SWIGINTERN wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
3169 wxArrayInt widths;
3170 self->GetPartialTextExtents(text, widths);
3171 return widths;
3172 }
3173
3174 #define SWIG_From_double PyFloat_FromDouble
3175
3176 SWIGINTERN void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
3177 self->SetLogicalOrigin(point.x, point.y);
3178 }
3179 SWIGINTERN void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
3180 self->SetDeviceOrigin(point.x, point.y);
3181 }
3182 SWIGINTERN void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
3183 self->CalcBoundingBox(point.x, point.y);
3184 }
3185 SWIGINTERN PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3186 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
3187 }
3188 SWIGINTERN PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3189 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
3190 }
3191 SWIGINTERN PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3192 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
3193 }
3194 SWIGINTERN PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3195 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
3196 }
3197 SWIGINTERN PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3198 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
3199 }
3200 SWIGINTERN PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
3201 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
3202 }
3203
3204 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
3205 *x1 = dc->MinX();
3206 *y1 = dc->MinY();
3207 *x2 = dc->MaxX();
3208 *y2 = dc->MaxY();
3209 }
3210
3211
3212 #include <wx/dcbuffer.h>
3213
3214
3215 #include <wx/dcps.h>
3216
3217
3218 class wxMetaFile : public wxObject {
3219 public:
3220 wxMetaFile(const wxString&)
3221 { wxPyRaiseNotImplemented(); }
3222 };
3223
3224 class wxMetaFileDC : public wxClientDC {
3225 public:
3226 wxMetaFileDC(const wxString&, int, int, const wxString&)
3227 { wxPyRaiseNotImplemented(); }
3228 };
3229
3230
3231
3232 class wxPrinterDC : public wxClientDC {
3233 public:
3234 wxPrinterDC(const wxPrintData&)
3235 { wxPyRaiseNotImplemented(); }
3236
3237 };
3238
3239
3240
3241 SWIGINTERN void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
3242 self->AddColour(name, wxColour(red, green, blue));
3243 }
3244
3245 wxFontList* _wxPyInitTheFontList() { return wxTheFontList; }
3246 wxPenList* _wxPyInitThePenList() { return wxThePenList; }
3247 wxBrushList* _wxPyInitTheBrushList() { return wxTheBrushList; }
3248 wxColourDatabase* _wxPyInitTheColourDatabase() { return wxTheColourDatabase; }
3249
3250
3251 #include <wx/effects.h>
3252
3253
3254 #include "wx/renderer.h"
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_bool (bool value)
3259 {
3260 return PyBool_FromLong(value ? 1 : 0);
3261 }
3262
3263
3264 #include "wx/wxPython/pseudodc.h"
3265
3266 SWIGINTERN wxRect wxPseudoDC_GetIdBounds(wxPseudoDC *self,int id){
3267 wxRect rect;
3268 self->GetIdBounds(id, rect);
3269 return rect;
3270 }
3271 #ifdef __cplusplus
3272 extern "C" {
3273 #endif
3274 SWIGINTERN PyObject *_wrap_new_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3275 PyObject *resultobj = 0;
3276 wxGDIObject *result = 0 ;
3277
3278 if (!SWIG_Python_UnpackTuple(args,"new_GDIObject",0,0,0)) SWIG_fail;
3279 {
3280 if (!wxPyCheckForApp()) SWIG_fail;
3281 PyThreadState* __tstate = wxPyBeginAllowThreads();
3282 result = (wxGDIObject *)new wxGDIObject();
3283 wxPyEndAllowThreads(__tstate);
3284 if (PyErr_Occurred()) SWIG_fail;
3285 }
3286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObject, SWIG_POINTER_NEW | 0 );
3287 return resultobj;
3288 fail:
3289 return NULL;
3290 }
3291
3292
3293 SWIGINTERN PyObject *_wrap_delete_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3294 PyObject *resultobj = 0;
3295 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3296 void *argp1 = 0 ;
3297 int res1 = 0 ;
3298 PyObject *swig_obj[1] ;
3299
3300 if (!args) SWIG_fail;
3301 swig_obj[0] = args;
3302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, SWIG_POINTER_DISOWN | 0 );
3303 if (!SWIG_IsOK(res1)) {
3304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObject" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3305 }
3306 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3307 {
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 delete arg1;
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 resultobj = SWIG_Py_Void();
3315 return resultobj;
3316 fail:
3317 return NULL;
3318 }
3319
3320
3321 SWIGINTERN PyObject *_wrap_GDIObject_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3322 PyObject *resultobj = 0;
3323 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3324 bool result;
3325 void *argp1 = 0 ;
3326 int res1 = 0 ;
3327 PyObject *swig_obj[1] ;
3328
3329 if (!args) SWIG_fail;
3330 swig_obj[0] = args;
3331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3332 if (!SWIG_IsOK(res1)) {
3333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_IsNull" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3334 }
3335 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3336 {
3337 PyThreadState* __tstate = wxPyBeginAllowThreads();
3338 result = (bool)(arg1)->IsNull();
3339 wxPyEndAllowThreads(__tstate);
3340 if (PyErr_Occurred()) SWIG_fail;
3341 }
3342 {
3343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3344 }
3345 return resultobj;
3346 fail:
3347 return NULL;
3348 }
3349
3350
3351 SWIGINTERN PyObject *GDIObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3352 PyObject *obj;
3353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3354 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObject, SWIG_NewClientData(obj));
3355 return SWIG_Py_Void();
3356 }
3357
3358 SWIGINTERN PyObject *GDIObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3359 return SWIG_Python_InitShadowInstance(args);
3360 }
3361
3362 SWIGINTERN PyObject *_wrap_new_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3363 PyObject *resultobj = 0;
3364 byte arg1 = (byte) 0 ;
3365 byte arg2 = (byte) 0 ;
3366 byte arg3 = (byte) 0 ;
3367 wxColour *result = 0 ;
3368 unsigned char val1 ;
3369 int ecode1 = 0 ;
3370 unsigned char val2 ;
3371 int ecode2 = 0 ;
3372 unsigned char val3 ;
3373 int ecode3 = 0 ;
3374 PyObject * obj0 = 0 ;
3375 PyObject * obj1 = 0 ;
3376 PyObject * obj2 = 0 ;
3377 char * kwnames[] = {
3378 (char *) "red",(char *) "green",(char *) "blue", NULL
3379 };
3380
3381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3382 if (obj0) {
3383 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
3384 if (!SWIG_IsOK(ecode1)) {
3385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Colour" "', expected argument " "1"" of type '" "byte""'");
3386 }
3387 arg1 = static_cast< byte >(val1);
3388 }
3389 if (obj1) {
3390 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3391 if (!SWIG_IsOK(ecode2)) {
3392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Colour" "', expected argument " "2"" of type '" "byte""'");
3393 }
3394 arg2 = static_cast< byte >(val2);
3395 }
3396 if (obj2) {
3397 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3398 if (!SWIG_IsOK(ecode3)) {
3399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Colour" "', expected argument " "3"" of type '" "byte""'");
3400 }
3401 arg3 = static_cast< byte >(val3);
3402 }
3403 {
3404 PyThreadState* __tstate = wxPyBeginAllowThreads();
3405 result = (wxColour *)new wxColour(arg1,arg2,arg3);
3406 wxPyEndAllowThreads(__tstate);
3407 if (PyErr_Occurred()) SWIG_fail;
3408 }
3409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_NEW | 0 );
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 SWIGINTERN PyObject *_wrap_new_NamedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj = 0;
3418 wxString *arg1 = 0 ;
3419 wxColour *result = 0 ;
3420 bool temp1 = false ;
3421 PyObject * obj0 = 0 ;
3422 char * kwnames[] = {
3423 (char *) "colorName", NULL
3424 };
3425
3426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) SWIG_fail;
3427 {
3428 arg1 = wxString_in_helper(obj0);
3429 if (arg1 == NULL) SWIG_fail;
3430 temp1 = true;
3431 }
3432 {
3433 if (!wxPyCheckForApp()) SWIG_fail;
3434 PyThreadState* __tstate = wxPyBeginAllowThreads();
3435 result = (wxColour *)new wxColour((wxString const &)*arg1);
3436 wxPyEndAllowThreads(__tstate);
3437 if (PyErr_Occurred()) SWIG_fail;
3438 }
3439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3440 {
3441 if (temp1)
3442 delete arg1;
3443 }
3444 return resultobj;
3445 fail:
3446 {
3447 if (temp1)
3448 delete arg1;
3449 }
3450 return NULL;
3451 }
3452
3453
3454 SWIGINTERN PyObject *_wrap_new_ColourRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj = 0;
3456 unsigned long arg1 ;
3457 wxColour *result = 0 ;
3458 unsigned long val1 ;
3459 int ecode1 = 0 ;
3460 PyObject * obj0 = 0 ;
3461 char * kwnames[] = {
3462 (char *) "colRGB", NULL
3463 };
3464
3465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) SWIG_fail;
3466 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
3467 if (!SWIG_IsOK(ecode1)) {
3468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourRGB" "', expected argument " "1"" of type '" "unsigned long""'");
3469 }
3470 arg1 = static_cast< unsigned long >(val1);
3471 {
3472 PyThreadState* __tstate = wxPyBeginAllowThreads();
3473 result = (wxColour *)new wxColour(arg1);
3474 wxPyEndAllowThreads(__tstate);
3475 if (PyErr_Occurred()) SWIG_fail;
3476 }
3477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3478 return resultobj;
3479 fail:
3480 return NULL;
3481 }
3482
3483
3484 SWIGINTERN PyObject *_wrap_delete_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3485 PyObject *resultobj = 0;
3486 wxColour *arg1 = (wxColour *) 0 ;
3487 void *argp1 = 0 ;
3488 int res1 = 0 ;
3489 PyObject *swig_obj[1] ;
3490
3491 if (!args) SWIG_fail;
3492 swig_obj[0] = args;
3493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, SWIG_POINTER_DISOWN | 0 );
3494 if (!SWIG_IsOK(res1)) {
3495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Colour" "', expected argument " "1"" of type '" "wxColour *""'");
3496 }
3497 arg1 = reinterpret_cast< wxColour * >(argp1);
3498 {
3499 PyThreadState* __tstate = wxPyBeginAllowThreads();
3500 delete arg1;
3501
3502 wxPyEndAllowThreads(__tstate);
3503 if (PyErr_Occurred()) SWIG_fail;
3504 }
3505 resultobj = SWIG_Py_Void();
3506 return resultobj;
3507 fail:
3508 return NULL;
3509 }
3510
3511
3512 SWIGINTERN PyObject *_wrap_Colour_Red(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3513 PyObject *resultobj = 0;
3514 wxColour *arg1 = (wxColour *) 0 ;
3515 byte result;
3516 void *argp1 = 0 ;
3517 int res1 = 0 ;
3518 PyObject *swig_obj[1] ;
3519
3520 if (!args) SWIG_fail;
3521 swig_obj[0] = args;
3522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3523 if (!SWIG_IsOK(res1)) {
3524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Red" "', expected argument " "1"" of type '" "wxColour *""'");
3525 }
3526 arg1 = reinterpret_cast< wxColour * >(argp1);
3527 {
3528 PyThreadState* __tstate = wxPyBeginAllowThreads();
3529 result = (byte)(arg1)->Red();
3530 wxPyEndAllowThreads(__tstate);
3531 if (PyErr_Occurred()) SWIG_fail;
3532 }
3533 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3534 return resultobj;
3535 fail:
3536 return NULL;
3537 }
3538
3539
3540 SWIGINTERN PyObject *_wrap_Colour_Green(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3541 PyObject *resultobj = 0;
3542 wxColour *arg1 = (wxColour *) 0 ;
3543 byte result;
3544 void *argp1 = 0 ;
3545 int res1 = 0 ;
3546 PyObject *swig_obj[1] ;
3547
3548 if (!args) SWIG_fail;
3549 swig_obj[0] = args;
3550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3551 if (!SWIG_IsOK(res1)) {
3552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Green" "', expected argument " "1"" of type '" "wxColour *""'");
3553 }
3554 arg1 = reinterpret_cast< wxColour * >(argp1);
3555 {
3556 PyThreadState* __tstate = wxPyBeginAllowThreads();
3557 result = (byte)(arg1)->Green();
3558 wxPyEndAllowThreads(__tstate);
3559 if (PyErr_Occurred()) SWIG_fail;
3560 }
3561 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 SWIGINTERN PyObject *_wrap_Colour_Blue(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_Blue" "', expected argument " "1"" of type '" "wxColour *""'");
3581 }
3582 arg1 = reinterpret_cast< wxColour * >(argp1);
3583 {
3584 PyThreadState* __tstate = wxPyBeginAllowThreads();
3585 result = (byte)(arg1)->Blue();
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_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3597 PyObject *resultobj = 0;
3598 wxColour *arg1 = (wxColour *) 0 ;
3599 bool 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_Ok" "', expected argument " "1"" of type '" "wxColour *""'");
3609 }
3610 arg1 = reinterpret_cast< wxColour * >(argp1);
3611 {
3612 PyThreadState* __tstate = wxPyBeginAllowThreads();
3613 result = (bool)(arg1)->Ok();
3614 wxPyEndAllowThreads(__tstate);
3615 if (PyErr_Occurred()) SWIG_fail;
3616 }
3617 {
3618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3619 }
3620 return resultobj;
3621 fail:
3622 return NULL;
3623 }
3624
3625
3626 SWIGINTERN PyObject *_wrap_Colour_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3627 PyObject *resultobj = 0;
3628 wxColour *arg1 = (wxColour *) 0 ;
3629 byte arg2 ;
3630 byte arg3 ;
3631 byte arg4 ;
3632 void *argp1 = 0 ;
3633 int res1 = 0 ;
3634 unsigned char val2 ;
3635 int ecode2 = 0 ;
3636 unsigned char val3 ;
3637 int ecode3 = 0 ;
3638 unsigned char val4 ;
3639 int ecode4 = 0 ;
3640 PyObject * obj0 = 0 ;
3641 PyObject * obj1 = 0 ;
3642 PyObject * obj2 = 0 ;
3643 PyObject * obj3 = 0 ;
3644 char * kwnames[] = {
3645 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
3646 };
3647
3648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3650 if (!SWIG_IsOK(res1)) {
3651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Set" "', expected argument " "1"" of type '" "wxColour *""'");
3652 }
3653 arg1 = reinterpret_cast< wxColour * >(argp1);
3654 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3655 if (!SWIG_IsOK(ecode2)) {
3656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Set" "', expected argument " "2"" of type '" "byte""'");
3657 }
3658 arg2 = static_cast< byte >(val2);
3659 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3660 if (!SWIG_IsOK(ecode3)) {
3661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Colour_Set" "', expected argument " "3"" of type '" "byte""'");
3662 }
3663 arg3 = static_cast< byte >(val3);
3664 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3665 if (!SWIG_IsOK(ecode4)) {
3666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Colour_Set" "', expected argument " "4"" of type '" "byte""'");
3667 }
3668 arg4 = static_cast< byte >(val4);
3669 {
3670 PyThreadState* __tstate = wxPyBeginAllowThreads();
3671 (arg1)->Set(arg2,arg3,arg4);
3672 wxPyEndAllowThreads(__tstate);
3673 if (PyErr_Occurred()) SWIG_fail;
3674 }
3675 resultobj = SWIG_Py_Void();
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 SWIGINTERN PyObject *_wrap_Colour_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj = 0;
3684 wxColour *arg1 = (wxColour *) 0 ;
3685 unsigned long arg2 ;
3686 void *argp1 = 0 ;
3687 int res1 = 0 ;
3688 unsigned long val2 ;
3689 int ecode2 = 0 ;
3690 PyObject * obj0 = 0 ;
3691 PyObject * obj1 = 0 ;
3692 char * kwnames[] = {
3693 (char *) "self",(char *) "colRGB", NULL
3694 };
3695
3696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
3697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3698 if (!SWIG_IsOK(res1)) {
3699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
3700 }
3701 arg1 = reinterpret_cast< wxColour * >(argp1);
3702 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
3703 if (!SWIG_IsOK(ecode2)) {
3704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_SetRGB" "', expected argument " "2"" of type '" "unsigned long""'");
3705 }
3706 arg2 = static_cast< unsigned long >(val2);
3707 {
3708 PyThreadState* __tstate = wxPyBeginAllowThreads();
3709 (arg1)->Set(arg2);
3710 wxPyEndAllowThreads(__tstate);
3711 if (PyErr_Occurred()) SWIG_fail;
3712 }
3713 resultobj = SWIG_Py_Void();
3714 return resultobj;
3715 fail:
3716 return NULL;
3717 }
3718
3719
3720 SWIGINTERN PyObject *_wrap_Colour_SetFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3721 PyObject *resultobj = 0;
3722 wxColour *arg1 = (wxColour *) 0 ;
3723 wxString *arg2 = 0 ;
3724 void *argp1 = 0 ;
3725 int res1 = 0 ;
3726 bool temp2 = false ;
3727 PyObject * obj0 = 0 ;
3728 PyObject * obj1 = 0 ;
3729 char * kwnames[] = {
3730 (char *) "self",(char *) "colourName", NULL
3731 };
3732
3733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) SWIG_fail;
3734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3735 if (!SWIG_IsOK(res1)) {
3736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetFromName" "', expected argument " "1"" of type '" "wxColour *""'");
3737 }
3738 arg1 = reinterpret_cast< wxColour * >(argp1);
3739 {
3740 arg2 = wxString_in_helper(obj1);
3741 if (arg2 == NULL) SWIG_fail;
3742 temp2 = true;
3743 }
3744 {
3745 PyThreadState* __tstate = wxPyBeginAllowThreads();
3746 (arg1)->InitFromName((wxString const &)*arg2);
3747 wxPyEndAllowThreads(__tstate);
3748 if (PyErr_Occurred()) SWIG_fail;
3749 }
3750 resultobj = SWIG_Py_Void();
3751 {
3752 if (temp2)
3753 delete arg2;
3754 }
3755 return resultobj;
3756 fail:
3757 {
3758 if (temp2)
3759 delete arg2;
3760 }
3761 return NULL;
3762 }
3763
3764
3765 SWIGINTERN PyObject *_wrap_Colour_GetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3766 PyObject *resultobj = 0;
3767 wxColour *arg1 = (wxColour *) 0 ;
3768 long arg2 = (long) wxC2S_NAME|wxC2S_CSS_SYNTAX ;
3769 wxString result;
3770 void *argp1 = 0 ;
3771 int res1 = 0 ;
3772 long val2 ;
3773 int ecode2 = 0 ;
3774 PyObject * obj0 = 0 ;
3775 PyObject * obj1 = 0 ;
3776 char * kwnames[] = {
3777 (char *) "self",(char *) "flags", NULL
3778 };
3779
3780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_GetAsString",kwnames,&obj0,&obj1)) SWIG_fail;
3781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3782 if (!SWIG_IsOK(res1)) {
3783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetAsString" "', expected argument " "1"" of type '" "wxColour const *""'");
3784 }
3785 arg1 = reinterpret_cast< wxColour * >(argp1);
3786 if (obj1) {
3787 ecode2 = SWIG_AsVal_long(obj1, &val2);
3788 if (!SWIG_IsOK(ecode2)) {
3789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_GetAsString" "', expected argument " "2"" of type '" "long""'");
3790 }
3791 arg2 = static_cast< long >(val2);
3792 }
3793 {
3794 PyThreadState* __tstate = wxPyBeginAllowThreads();
3795 result = ((wxColour const *)arg1)->GetAsString(arg2);
3796 wxPyEndAllowThreads(__tstate);
3797 if (PyErr_Occurred()) SWIG_fail;
3798 }
3799 {
3800 #if wxUSE_UNICODE
3801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3802 #else
3803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3804 #endif
3805 }
3806 return resultobj;
3807 fail:
3808 return NULL;
3809 }
3810
3811
3812 SWIGINTERN PyObject *_wrap_Colour_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3813 PyObject *resultobj = 0;
3814 wxColour *arg1 = (wxColour *) 0 ;
3815 long result;
3816 void *argp1 = 0 ;
3817 int res1 = 0 ;
3818 PyObject *swig_obj[1] ;
3819
3820 if (!args) SWIG_fail;
3821 swig_obj[0] = args;
3822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3823 if (!SWIG_IsOK(res1)) {
3824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetPixel" "', expected argument " "1"" of type '" "wxColour const *""'");
3825 }
3826 arg1 = reinterpret_cast< wxColour * >(argp1);
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (long)((wxColour const *)arg1)->GetPixel();
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 resultobj = SWIG_From_long(static_cast< long >(result));
3834 return resultobj;
3835 fail:
3836 return NULL;
3837 }
3838
3839
3840 SWIGINTERN PyObject *_wrap_Colour___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3841 PyObject *resultobj = 0;
3842 wxColour *arg1 = (wxColour *) 0 ;
3843 PyObject *arg2 = (PyObject *) 0 ;
3844 bool result;
3845 void *argp1 = 0 ;
3846 int res1 = 0 ;
3847 PyObject * obj0 = 0 ;
3848 PyObject * obj1 = 0 ;
3849 char * kwnames[] = {
3850 (char *) "self",(char *) "other", NULL
3851 };
3852
3853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
3854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3855 if (!SWIG_IsOK(res1)) {
3856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___eq__" "', expected argument " "1"" of type '" "wxColour *""'");
3857 }
3858 arg1 = reinterpret_cast< wxColour * >(argp1);
3859 arg2 = obj1;
3860 {
3861 result = (bool)wxColour___eq__(arg1,arg2);
3862 if (PyErr_Occurred()) SWIG_fail;
3863 }
3864 {
3865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3866 }
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 SWIGINTERN PyObject *_wrap_Colour___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj = 0;
3875 wxColour *arg1 = (wxColour *) 0 ;
3876 PyObject *arg2 = (PyObject *) 0 ;
3877 bool result;
3878 void *argp1 = 0 ;
3879 int res1 = 0 ;
3880 PyObject * obj0 = 0 ;
3881 PyObject * obj1 = 0 ;
3882 char * kwnames[] = {
3883 (char *) "self",(char *) "other", NULL
3884 };
3885
3886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
3887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3888 if (!SWIG_IsOK(res1)) {
3889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___ne__" "', expected argument " "1"" of type '" "wxColour *""'");
3890 }
3891 arg1 = reinterpret_cast< wxColour * >(argp1);
3892 arg2 = obj1;
3893 {
3894 result = (bool)wxColour___ne__(arg1,arg2);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3899 }
3900 return resultobj;
3901 fail:
3902 return NULL;
3903 }
3904
3905
3906 SWIGINTERN PyObject *_wrap_Colour_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3907 PyObject *resultobj = 0;
3908 wxColour *arg1 = (wxColour *) 0 ;
3909 PyObject *result = 0 ;
3910 void *argp1 = 0 ;
3911 int res1 = 0 ;
3912 PyObject *swig_obj[1] ;
3913
3914 if (!args) SWIG_fail;
3915 swig_obj[0] = args;
3916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3917 if (!SWIG_IsOK(res1)) {
3918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Get" "', expected argument " "1"" of type '" "wxColour *""'");
3919 }
3920 arg1 = reinterpret_cast< wxColour * >(argp1);
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 result = (PyObject *)wxColour_Get(arg1);
3924 wxPyEndAllowThreads(__tstate);
3925 if (PyErr_Occurred()) SWIG_fail;
3926 }
3927 resultobj = result;
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 SWIGINTERN PyObject *_wrap_Colour_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3935 PyObject *resultobj = 0;
3936 wxColour *arg1 = (wxColour *) 0 ;
3937 unsigned long result;
3938 void *argp1 = 0 ;
3939 int res1 = 0 ;
3940 PyObject *swig_obj[1] ;
3941
3942 if (!args) SWIG_fail;
3943 swig_obj[0] = args;
3944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3945 if (!SWIG_IsOK(res1)) {
3946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
3947 }
3948 arg1 = reinterpret_cast< wxColour * >(argp1);
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 result = (unsigned long)wxColour_GetRGB(arg1);
3952 wxPyEndAllowThreads(__tstate);
3953 if (PyErr_Occurred()) SWIG_fail;
3954 }
3955 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 SWIGINTERN PyObject *Colour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3963 PyObject *obj;
3964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3965 SWIG_TypeNewClientData(SWIGTYPE_p_wxColour, SWIG_NewClientData(obj));
3966 return SWIG_Py_Void();
3967 }
3968
3969 SWIGINTERN PyObject *Colour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3970 return SWIG_Python_InitShadowInstance(args);
3971 }
3972
3973 SWIGINTERN PyObject *_wrap_new_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3974 PyObject *resultobj = 0;
3975 int arg1 ;
3976 unsigned char *arg2 = (unsigned char *) 0 ;
3977 unsigned char *arg3 = (unsigned char *) 0 ;
3978 unsigned char *arg4 = (unsigned char *) 0 ;
3979 wxPalette *result = 0 ;
3980 int val1 ;
3981 int ecode1 = 0 ;
3982 void *argp2 = 0 ;
3983 int res2 = 0 ;
3984 void *argp3 = 0 ;
3985 int res3 = 0 ;
3986 void *argp4 = 0 ;
3987 int res4 = 0 ;
3988 PyObject * obj0 = 0 ;
3989 PyObject * obj1 = 0 ;
3990 PyObject * obj2 = 0 ;
3991 PyObject * obj3 = 0 ;
3992 char * kwnames[] = {
3993 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
3994 };
3995
3996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3997 ecode1 = SWIG_AsVal_int(obj0, &val1);
3998 if (!SWIG_IsOK(ecode1)) {
3999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Palette" "', expected argument " "1"" of type '" "int""'");
4000 }
4001 arg1 = static_cast< int >(val1);
4002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4003 if (!SWIG_IsOK(res2)) {
4004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Palette" "', expected argument " "2"" of type '" "unsigned char const *""'");
4005 }
4006 arg2 = reinterpret_cast< unsigned char * >(argp2);
4007 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
4008 if (!SWIG_IsOK(res3)) {
4009 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Palette" "', expected argument " "3"" of type '" "unsigned char const *""'");
4010 }
4011 arg3 = reinterpret_cast< unsigned char * >(argp3);
4012 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
4013 if (!SWIG_IsOK(res4)) {
4014 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Palette" "', expected argument " "4"" of type '" "unsigned char const *""'");
4015 }
4016 arg4 = reinterpret_cast< unsigned char * >(argp4);
4017 {
4018 if (!wxPyCheckForApp()) SWIG_fail;
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
4021 wxPyEndAllowThreads(__tstate);
4022 if (PyErr_Occurred()) SWIG_fail;
4023 }
4024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, SWIG_POINTER_NEW | 0 );
4025 return resultobj;
4026 fail:
4027 return NULL;
4028 }
4029
4030
4031 SWIGINTERN PyObject *_wrap_delete_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4032 PyObject *resultobj = 0;
4033 wxPalette *arg1 = (wxPalette *) 0 ;
4034 void *argp1 = 0 ;
4035 int res1 = 0 ;
4036 PyObject *swig_obj[1] ;
4037
4038 if (!args) SWIG_fail;
4039 swig_obj[0] = args;
4040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, SWIG_POINTER_DISOWN | 0 );
4041 if (!SWIG_IsOK(res1)) {
4042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Palette" "', expected argument " "1"" of type '" "wxPalette *""'");
4043 }
4044 arg1 = reinterpret_cast< wxPalette * >(argp1);
4045 {
4046 PyThreadState* __tstate = wxPyBeginAllowThreads();
4047 delete arg1;
4048
4049 wxPyEndAllowThreads(__tstate);
4050 if (PyErr_Occurred()) SWIG_fail;
4051 }
4052 resultobj = SWIG_Py_Void();
4053 return resultobj;
4054 fail:
4055 return NULL;
4056 }
4057
4058
4059 SWIGINTERN PyObject *_wrap_Palette_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4060 PyObject *resultobj = 0;
4061 wxPalette *arg1 = (wxPalette *) 0 ;
4062 byte arg2 ;
4063 byte arg3 ;
4064 byte arg4 ;
4065 int result;
4066 void *argp1 = 0 ;
4067 int res1 = 0 ;
4068 unsigned char val2 ;
4069 int ecode2 = 0 ;
4070 unsigned char val3 ;
4071 int ecode3 = 0 ;
4072 unsigned char val4 ;
4073 int ecode4 = 0 ;
4074 PyObject * obj0 = 0 ;
4075 PyObject * obj1 = 0 ;
4076 PyObject * obj2 = 0 ;
4077 PyObject * obj3 = 0 ;
4078 char * kwnames[] = {
4079 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
4080 };
4081
4082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4084 if (!SWIG_IsOK(res1)) {
4085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetPixel" "', expected argument " "1"" of type '" "wxPalette *""'");
4086 }
4087 arg1 = reinterpret_cast< wxPalette * >(argp1);
4088 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4089 if (!SWIG_IsOK(ecode2)) {
4090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetPixel" "', expected argument " "2"" of type '" "byte""'");
4091 }
4092 arg2 = static_cast< byte >(val2);
4093 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4094 if (!SWIG_IsOK(ecode3)) {
4095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Palette_GetPixel" "', expected argument " "3"" of type '" "byte""'");
4096 }
4097 arg3 = static_cast< byte >(val3);
4098 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4099 if (!SWIG_IsOK(ecode4)) {
4100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Palette_GetPixel" "', expected argument " "4"" of type '" "byte""'");
4101 }
4102 arg4 = static_cast< byte >(val4);
4103 {
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
4106 wxPyEndAllowThreads(__tstate);
4107 if (PyErr_Occurred()) SWIG_fail;
4108 }
4109 resultobj = SWIG_From_int(static_cast< int >(result));
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 SWIGINTERN PyObject *_wrap_Palette_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj = 0;
4118 wxPalette *arg1 = (wxPalette *) 0 ;
4119 int arg2 ;
4120 byte *arg3 = (byte *) 0 ;
4121 byte *arg4 = (byte *) 0 ;
4122 byte *arg5 = (byte *) 0 ;
4123 bool result;
4124 void *argp1 = 0 ;
4125 int res1 = 0 ;
4126 int val2 ;
4127 int ecode2 = 0 ;
4128 byte temp3 ;
4129 int res3 = SWIG_TMPOBJ ;
4130 byte temp4 ;
4131 int res4 = SWIG_TMPOBJ ;
4132 byte temp5 ;
4133 int res5 = SWIG_TMPOBJ ;
4134 PyObject * obj0 = 0 ;
4135 PyObject * obj1 = 0 ;
4136 char * kwnames[] = {
4137 (char *) "self",(char *) "pixel", NULL
4138 };
4139
4140 arg3 = &temp3;
4141 arg4 = &temp4;
4142 arg5 = &temp5;
4143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4145 if (!SWIG_IsOK(res1)) {
4146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetRGB" "', expected argument " "1"" of type '" "wxPalette *""'");
4147 }
4148 arg1 = reinterpret_cast< wxPalette * >(argp1);
4149 ecode2 = SWIG_AsVal_int(obj1, &val2);
4150 if (!SWIG_IsOK(ecode2)) {
4151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetRGB" "', expected argument " "2"" of type '" "int""'");
4152 }
4153 arg2 = static_cast< int >(val2);
4154 {
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 {
4161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4162 }
4163 if (SWIG_IsTmpObj(res3)) {
4164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
4165 } else {
4166 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
4168 }
4169 if (SWIG_IsTmpObj(res4)) {
4170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
4171 } else {
4172 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
4174 }
4175 if (SWIG_IsTmpObj(res5)) {
4176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)));
4177 } else {
4178 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags));
4180 }
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 SWIGINTERN PyObject *_wrap_Palette_GetColoursCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4188 PyObject *resultobj = 0;
4189 wxPalette *arg1 = (wxPalette *) 0 ;
4190 int result;
4191 void *argp1 = 0 ;
4192 int res1 = 0 ;
4193 PyObject *swig_obj[1] ;
4194
4195 if (!args) SWIG_fail;
4196 swig_obj[0] = args;
4197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4198 if (!SWIG_IsOK(res1)) {
4199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetColoursCount" "', expected argument " "1"" of type '" "wxPalette const *""'");
4200 }
4201 arg1 = reinterpret_cast< wxPalette * >(argp1);
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (int)((wxPalette const *)arg1)->GetColoursCount();
4205 wxPyEndAllowThreads(__tstate);
4206 if (PyErr_Occurred()) SWIG_fail;
4207 }
4208 resultobj = SWIG_From_int(static_cast< int >(result));
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 SWIGINTERN PyObject *_wrap_Palette_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4216 PyObject *resultobj = 0;
4217 wxPalette *arg1 = (wxPalette *) 0 ;
4218 bool result;
4219 void *argp1 = 0 ;
4220 int res1 = 0 ;
4221 PyObject *swig_obj[1] ;
4222
4223 if (!args) SWIG_fail;
4224 swig_obj[0] = args;
4225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4226 if (!SWIG_IsOK(res1)) {
4227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_Ok" "', expected argument " "1"" of type '" "wxPalette *""'");
4228 }
4229 arg1 = reinterpret_cast< wxPalette * >(argp1);
4230 {
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (bool)(arg1)->Ok();
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 {
4237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4238 }
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 SWIGINTERN PyObject *Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4246 PyObject *obj;
4247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4248 SWIG_TypeNewClientData(SWIGTYPE_p_wxPalette, SWIG_NewClientData(obj));
4249 return SWIG_Py_Void();
4250 }
4251
4252 SWIGINTERN PyObject *Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4253 return SWIG_Python_InitShadowInstance(args);
4254 }
4255
4256 SWIGINTERN PyObject *_wrap_new_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = 0;
4258 wxColour *arg1 = 0 ;
4259 int arg2 = (int) 1 ;
4260 int arg3 = (int) wxSOLID ;
4261 wxPen *result = 0 ;
4262 wxColour temp1 ;
4263 int val2 ;
4264 int ecode2 = 0 ;
4265 int val3 ;
4266 int ecode3 = 0 ;
4267 PyObject * obj0 = 0 ;
4268 PyObject * obj1 = 0 ;
4269 PyObject * obj2 = 0 ;
4270 char * kwnames[] = {
4271 (char *) "colour",(char *) "width",(char *) "style", NULL
4272 };
4273
4274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4275 {
4276 arg1 = &temp1;
4277 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4278 }
4279 if (obj1) {
4280 ecode2 = SWIG_AsVal_int(obj1, &val2);
4281 if (!SWIG_IsOK(ecode2)) {
4282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pen" "', expected argument " "2"" of type '" "int""'");
4283 }
4284 arg2 = static_cast< int >(val2);
4285 }
4286 if (obj2) {
4287 ecode3 = SWIG_AsVal_int(obj2, &val3);
4288 if (!SWIG_IsOK(ecode3)) {
4289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pen" "', expected argument " "3"" of type '" "int""'");
4290 }
4291 arg3 = static_cast< int >(val3);
4292 }
4293 {
4294 if (!wxPyCheckForApp()) SWIG_fail;
4295 PyThreadState* __tstate = wxPyBeginAllowThreads();
4296 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
4297 wxPyEndAllowThreads(__tstate);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, SWIG_POINTER_NEW | 0 );
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 SWIGINTERN PyObject *_wrap_delete_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxPen *arg1 = (wxPen *) 0 ;
4310 void *argp1 = 0 ;
4311 int res1 = 0 ;
4312 PyObject *swig_obj[1] ;
4313
4314 if (!args) SWIG_fail;
4315 swig_obj[0] = args;
4316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, SWIG_POINTER_DISOWN | 0 );
4317 if (!SWIG_IsOK(res1)) {
4318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pen" "', expected argument " "1"" of type '" "wxPen *""'");
4319 }
4320 arg1 = reinterpret_cast< wxPen * >(argp1);
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 delete arg1;
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 resultobj = SWIG_Py_Void();
4329 return resultobj;
4330 fail:
4331 return NULL;
4332 }
4333
4334
4335 SWIGINTERN PyObject *_wrap_Pen_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4336 PyObject *resultobj = 0;
4337 wxPen *arg1 = (wxPen *) 0 ;
4338 int result;
4339 void *argp1 = 0 ;
4340 int res1 = 0 ;
4341 PyObject *swig_obj[1] ;
4342
4343 if (!args) SWIG_fail;
4344 swig_obj[0] = args;
4345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4346 if (!SWIG_IsOK(res1)) {
4347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4348 }
4349 arg1 = reinterpret_cast< wxPen * >(argp1);
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = (int)(arg1)->GetCap();
4353 wxPyEndAllowThreads(__tstate);
4354 if (PyErr_Occurred()) SWIG_fail;
4355 }
4356 resultobj = SWIG_From_int(static_cast< int >(result));
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 SWIGINTERN PyObject *_wrap_Pen_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4364 PyObject *resultobj = 0;
4365 wxPen *arg1 = (wxPen *) 0 ;
4366 wxColour result;
4367 void *argp1 = 0 ;
4368 int res1 = 0 ;
4369 PyObject *swig_obj[1] ;
4370
4371 if (!args) SWIG_fail;
4372 swig_obj[0] = args;
4373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4374 if (!SWIG_IsOK(res1)) {
4375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4376 }
4377 arg1 = reinterpret_cast< wxPen * >(argp1);
4378 {
4379 PyThreadState* __tstate = wxPyBeginAllowThreads();
4380 result = (arg1)->GetColour();
4381 wxPyEndAllowThreads(__tstate);
4382 if (PyErr_Occurred()) SWIG_fail;
4383 }
4384 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 SWIGINTERN PyObject *_wrap_Pen_GetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4392 PyObject *resultobj = 0;
4393 wxPen *arg1 = (wxPen *) 0 ;
4394 int result;
4395 void *argp1 = 0 ;
4396 int res1 = 0 ;
4397 PyObject *swig_obj[1] ;
4398
4399 if (!args) SWIG_fail;
4400 swig_obj[0] = args;
4401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4402 if (!SWIG_IsOK(res1)) {
4403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4404 }
4405 arg1 = reinterpret_cast< wxPen * >(argp1);
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 result = (int)(arg1)->GetJoin();
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_From_int(static_cast< int >(result));
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 SWIGINTERN PyObject *_wrap_Pen_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4420 PyObject *resultobj = 0;
4421 wxPen *arg1 = (wxPen *) 0 ;
4422 int result;
4423 void *argp1 = 0 ;
4424 int res1 = 0 ;
4425 PyObject *swig_obj[1] ;
4426
4427 if (!args) SWIG_fail;
4428 swig_obj[0] = args;
4429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4430 if (!SWIG_IsOK(res1)) {
4431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4432 }
4433 arg1 = reinterpret_cast< wxPen * >(argp1);
4434 {
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 result = (int)(arg1)->GetStyle();
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 resultobj = SWIG_From_int(static_cast< int >(result));
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Pen_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxPen *arg1 = (wxPen *) 0 ;
4450 int result;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 PyObject *swig_obj[1] ;
4454
4455 if (!args) SWIG_fail;
4456 swig_obj[0] = args;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4460 }
4461 arg1 = reinterpret_cast< wxPen * >(argp1);
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 result = (int)(arg1)->GetWidth();
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_From_int(static_cast< int >(result));
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Pen_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxPen *arg1 = (wxPen *) 0 ;
4478 bool result;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_Ok" "', expected argument " "1"" of type '" "wxPen *""'");
4488 }
4489 arg1 = reinterpret_cast< wxPen * >(argp1);
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 result = (bool)(arg1)->Ok();
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 {
4497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4498 }
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 SWIGINTERN PyObject *_wrap_Pen_SetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj = 0;
4507 wxPen *arg1 = (wxPen *) 0 ;
4508 int arg2 ;
4509 void *argp1 = 0 ;
4510 int res1 = 0 ;
4511 int val2 ;
4512 int ecode2 = 0 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char * kwnames[] = {
4516 (char *) "self",(char *) "cap_style", NULL
4517 };
4518
4519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) SWIG_fail;
4520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4523 }
4524 arg1 = reinterpret_cast< wxPen * >(argp1);
4525 ecode2 = SWIG_AsVal_int(obj1, &val2);
4526 if (!SWIG_IsOK(ecode2)) {
4527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetCap" "', expected argument " "2"" of type '" "int""'");
4528 }
4529 arg2 = static_cast< int >(val2);
4530 {
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 (arg1)->SetCap(arg2);
4533 wxPyEndAllowThreads(__tstate);
4534 if (PyErr_Occurred()) SWIG_fail;
4535 }
4536 resultobj = SWIG_Py_Void();
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 SWIGINTERN PyObject *_wrap_Pen_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4544 PyObject *resultobj = 0;
4545 wxPen *arg1 = (wxPen *) 0 ;
4546 wxColour *arg2 = 0 ;
4547 void *argp1 = 0 ;
4548 int res1 = 0 ;
4549 wxColour temp2 ;
4550 PyObject * obj0 = 0 ;
4551 PyObject * obj1 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "self",(char *) "colour", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
4557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4558 if (!SWIG_IsOK(res1)) {
4559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4560 }
4561 arg1 = reinterpret_cast< wxPen * >(argp1);
4562 {
4563 arg2 = &temp2;
4564 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4565 }
4566 {
4567 PyThreadState* __tstate = wxPyBeginAllowThreads();
4568 (arg1)->SetColour(*arg2);
4569 wxPyEndAllowThreads(__tstate);
4570 if (PyErr_Occurred()) SWIG_fail;
4571 }
4572 resultobj = SWIG_Py_Void();
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 SWIGINTERN PyObject *_wrap_Pen_SetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj = 0;
4581 wxPen *arg1 = (wxPen *) 0 ;
4582 int arg2 ;
4583 void *argp1 = 0 ;
4584 int res1 = 0 ;
4585 int val2 ;
4586 int ecode2 = 0 ;
4587 PyObject * obj0 = 0 ;
4588 PyObject * obj1 = 0 ;
4589 char * kwnames[] = {
4590 (char *) "self",(char *) "join_style", NULL
4591 };
4592
4593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) SWIG_fail;
4594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4595 if (!SWIG_IsOK(res1)) {
4596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4597 }
4598 arg1 = reinterpret_cast< wxPen * >(argp1);
4599 ecode2 = SWIG_AsVal_int(obj1, &val2);
4600 if (!SWIG_IsOK(ecode2)) {
4601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetJoin" "', expected argument " "2"" of type '" "int""'");
4602 }
4603 arg2 = static_cast< int >(val2);
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 (arg1)->SetJoin(arg2);
4607 wxPyEndAllowThreads(__tstate);
4608 if (PyErr_Occurred()) SWIG_fail;
4609 }
4610 resultobj = SWIG_Py_Void();
4611 return resultobj;
4612 fail:
4613 return NULL;
4614 }
4615
4616
4617 SWIGINTERN PyObject *_wrap_Pen_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4618 PyObject *resultobj = 0;
4619 wxPen *arg1 = (wxPen *) 0 ;
4620 int arg2 ;
4621 void *argp1 = 0 ;
4622 int res1 = 0 ;
4623 int val2 ;
4624 int ecode2 = 0 ;
4625 PyObject * obj0 = 0 ;
4626 PyObject * obj1 = 0 ;
4627 char * kwnames[] = {
4628 (char *) "self",(char *) "style", NULL
4629 };
4630
4631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4635 }
4636 arg1 = reinterpret_cast< wxPen * >(argp1);
4637 ecode2 = SWIG_AsVal_int(obj1, &val2);
4638 if (!SWIG_IsOK(ecode2)) {
4639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetStyle" "', expected argument " "2"" of type '" "int""'");
4640 }
4641 arg2 = static_cast< int >(val2);
4642 {
4643 PyThreadState* __tstate = wxPyBeginAllowThreads();
4644 (arg1)->SetStyle(arg2);
4645 wxPyEndAllowThreads(__tstate);
4646 if (PyErr_Occurred()) SWIG_fail;
4647 }
4648 resultobj = SWIG_Py_Void();
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 SWIGINTERN PyObject *_wrap_Pen_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj = 0;
4657 wxPen *arg1 = (wxPen *) 0 ;
4658 int arg2 ;
4659 void *argp1 = 0 ;
4660 int res1 = 0 ;
4661 int val2 ;
4662 int ecode2 = 0 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 char * kwnames[] = {
4666 (char *) "self",(char *) "width", NULL
4667 };
4668
4669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4671 if (!SWIG_IsOK(res1)) {
4672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4673 }
4674 arg1 = reinterpret_cast< wxPen * >(argp1);
4675 ecode2 = SWIG_AsVal_int(obj1, &val2);
4676 if (!SWIG_IsOK(ecode2)) {
4677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetWidth" "', expected argument " "2"" of type '" "int""'");
4678 }
4679 arg2 = static_cast< int >(val2);
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 (arg1)->SetWidth(arg2);
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 resultobj = SWIG_Py_Void();
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Pen_SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxPen *arg1 = (wxPen *) 0 ;
4696 int arg2 ;
4697 wxDash *arg3 = (wxDash *) 0 ;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "dashes", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4710 }
4711 arg1 = reinterpret_cast< wxPen * >(argp1);
4712 {
4713 arg2 = PyList_Size(obj1);
4714 arg3 = (wxDash*)byte_LIST_helper(obj1);
4715 if (arg3 == NULL) SWIG_fail;
4716 }
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 (arg1)->SetDashes(arg2,arg3);
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_Py_Void();
4724 {
4725 if (arg3) delete [] arg3;
4726 }
4727 return resultobj;
4728 fail:
4729 {
4730 if (arg3) delete [] arg3;
4731 }
4732 return NULL;
4733 }
4734
4735
4736 SWIGINTERN PyObject *_wrap_Pen_GetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4737 PyObject *resultobj = 0;
4738 wxPen *arg1 = (wxPen *) 0 ;
4739 PyObject *result = 0 ;
4740 void *argp1 = 0 ;
4741 int res1 = 0 ;
4742 PyObject *swig_obj[1] ;
4743
4744 if (!args) SWIG_fail;
4745 swig_obj[0] = args;
4746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4747 if (!SWIG_IsOK(res1)) {
4748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4749 }
4750 arg1 = reinterpret_cast< wxPen * >(argp1);
4751 {
4752 PyThreadState* __tstate = wxPyBeginAllowThreads();
4753 result = (PyObject *)wxPen_GetDashes(arg1);
4754 wxPyEndAllowThreads(__tstate);
4755 if (PyErr_Occurred()) SWIG_fail;
4756 }
4757 resultobj = result;
4758 return resultobj;
4759 fail:
4760 return NULL;
4761 }
4762
4763
4764 SWIGINTERN PyObject *_wrap_Pen__SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj = 0;
4766 wxPen *arg1 = (wxPen *) 0 ;
4767 PyObject *arg2 = (PyObject *) 0 ;
4768 PyObject *arg3 = (PyObject *) 0 ;
4769 void *argp1 = 0 ;
4770 int res1 = 0 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 PyObject * obj2 = 0 ;
4774 char * kwnames[] = {
4775 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
4776 };
4777
4778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4780 if (!SWIG_IsOK(res1)) {
4781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen__SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
4782 }
4783 arg1 = reinterpret_cast< wxPen * >(argp1);
4784 arg2 = obj1;
4785 arg3 = obj2;
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 wxPen__SetDashes(arg1,arg2,arg3);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_Py_Void();
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Pen_GetDashCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4800 PyObject *resultobj = 0;
4801 wxPen *arg1 = (wxPen *) 0 ;
4802 int result;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 PyObject *swig_obj[1] ;
4806
4807 if (!args) SWIG_fail;
4808 swig_obj[0] = args;
4809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4810 if (!SWIG_IsOK(res1)) {
4811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashCount" "', expected argument " "1"" of type '" "wxPen const *""'");
4812 }
4813 arg1 = reinterpret_cast< wxPen * >(argp1);
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (int)((wxPen const *)arg1)->GetDashCount();
4817 wxPyEndAllowThreads(__tstate);
4818 if (PyErr_Occurred()) SWIG_fail;
4819 }
4820 resultobj = SWIG_From_int(static_cast< int >(result));
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_Pen___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4828 PyObject *resultobj = 0;
4829 wxPen *arg1 = (wxPen *) 0 ;
4830 wxPen *arg2 = (wxPen *) 0 ;
4831 bool result;
4832 void *argp1 = 0 ;
4833 int res1 = 0 ;
4834 void *argp2 = 0 ;
4835 int res2 = 0 ;
4836 PyObject * obj0 = 0 ;
4837 PyObject * obj1 = 0 ;
4838 char * kwnames[] = {
4839 (char *) "self",(char *) "other", NULL
4840 };
4841
4842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___eq__" "', expected argument " "1"" of type '" "wxPen *""'");
4846 }
4847 arg1 = reinterpret_cast< wxPen * >(argp1);
4848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
4849 if (!SWIG_IsOK(res2)) {
4850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___eq__" "', expected argument " "2"" of type '" "wxPen const *""'");
4851 }
4852 arg2 = reinterpret_cast< wxPen * >(argp2);
4853 {
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 {
4860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4861 }
4862 return resultobj;
4863 fail:
4864 return NULL;
4865 }
4866
4867
4868 SWIGINTERN PyObject *_wrap_Pen___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4869 PyObject *resultobj = 0;
4870 wxPen *arg1 = (wxPen *) 0 ;
4871 wxPen *arg2 = (wxPen *) 0 ;
4872 bool result;
4873 void *argp1 = 0 ;
4874 int res1 = 0 ;
4875 void *argp2 = 0 ;
4876 int res2 = 0 ;
4877 PyObject * obj0 = 0 ;
4878 PyObject * obj1 = 0 ;
4879 char * kwnames[] = {
4880 (char *) "self",(char *) "other", NULL
4881 };
4882
4883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4885 if (!SWIG_IsOK(res1)) {
4886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___ne__" "', expected argument " "1"" of type '" "wxPen *""'");
4887 }
4888 arg1 = reinterpret_cast< wxPen * >(argp1);
4889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
4890 if (!SWIG_IsOK(res2)) {
4891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___ne__" "', expected argument " "2"" of type '" "wxPen const *""'");
4892 }
4893 arg2 = reinterpret_cast< wxPen * >(argp2);
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 {
4901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4902 }
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *Pen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *obj;
4911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4912 SWIG_TypeNewClientData(SWIGTYPE_p_wxPen, SWIG_NewClientData(obj));
4913 return SWIG_Py_Void();
4914 }
4915
4916 SWIGINTERN PyObject *Pen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4917 return SWIG_Python_InitShadowInstance(args);
4918 }
4919
4920 SWIGINTERN PyObject *_wrap_new_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4921 PyObject *resultobj = 0;
4922 wxColour *arg1 = 0 ;
4923 int arg2 = (int) wxSOLID ;
4924 wxBrush *result = 0 ;
4925 wxColour temp1 ;
4926 int val2 ;
4927 int ecode2 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "colour",(char *) "style", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) SWIG_fail;
4935 {
4936 arg1 = &temp1;
4937 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4938 }
4939 if (obj1) {
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Brush" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 }
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
4950 wxPyEndAllowThreads(__tstate);
4951 if (PyErr_Occurred()) SWIG_fail;
4952 }
4953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_NEW | 0 );
4954 return resultobj;
4955 fail:
4956 return NULL;
4957 }
4958
4959
4960 SWIGINTERN PyObject *_wrap_new_BrushFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4961 PyObject *resultobj = 0;
4962 wxBitmap *arg1 = 0 ;
4963 wxBrush *result = 0 ;
4964 void *argp1 = 0 ;
4965 int res1 = 0 ;
4966 PyObject * obj0 = 0 ;
4967 char * kwnames[] = {
4968 (char *) "stippleBitmap", NULL
4969 };
4970
4971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) SWIG_fail;
4972 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
4973 if (!SWIG_IsOK(res1)) {
4974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
4975 }
4976 if (!argp1) {
4977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
4978 }
4979 arg1 = reinterpret_cast< wxBitmap * >(argp1);
4980 {
4981 if (!wxPyCheckForApp()) SWIG_fail;
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_OWN | 0 );
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 SWIGINTERN PyObject *_wrap_delete_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4995 PyObject *resultobj = 0;
4996 wxBrush *arg1 = (wxBrush *) 0 ;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 PyObject *swig_obj[1] ;
5000
5001 if (!args) SWIG_fail;
5002 swig_obj[0] = args;
5003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, SWIG_POINTER_DISOWN | 0 );
5004 if (!SWIG_IsOK(res1)) {
5005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brush" "', expected argument " "1"" of type '" "wxBrush *""'");
5006 }
5007 arg1 = reinterpret_cast< wxBrush * >(argp1);
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 delete arg1;
5011
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 resultobj = SWIG_Py_Void();
5016 return resultobj;
5017 fail:
5018 return NULL;
5019 }
5020
5021
5022 SWIGINTERN PyObject *_wrap_Brush_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj = 0;
5024 wxBrush *arg1 = (wxBrush *) 0 ;
5025 wxColour *arg2 = 0 ;
5026 void *argp1 = 0 ;
5027 int res1 = 0 ;
5028 wxColour temp2 ;
5029 PyObject * obj0 = 0 ;
5030 PyObject * obj1 = 0 ;
5031 char * kwnames[] = {
5032 (char *) "self",(char *) "col", NULL
5033 };
5034
5035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
5036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5037 if (!SWIG_IsOK(res1)) {
5038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetColour" "', expected argument " "1"" of type '" "wxBrush *""'");
5039 }
5040 arg1 = reinterpret_cast< wxBrush * >(argp1);
5041 {
5042 arg2 = &temp2;
5043 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5044 }
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 (arg1)->SetColour((wxColour const &)*arg2);
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_Py_Void();
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_Brush_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj = 0;
5060 wxBrush *arg1 = (wxBrush *) 0 ;
5061 int arg2 ;
5062 void *argp1 = 0 ;
5063 int res1 = 0 ;
5064 int val2 ;
5065 int ecode2 = 0 ;
5066 PyObject * obj0 = 0 ;
5067 PyObject * obj1 = 0 ;
5068 char * kwnames[] = {
5069 (char *) "self",(char *) "style", NULL
5070 };
5071
5072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5074 if (!SWIG_IsOK(res1)) {
5075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStyle" "', expected argument " "1"" of type '" "wxBrush *""'");
5076 }
5077 arg1 = reinterpret_cast< wxBrush * >(argp1);
5078 ecode2 = SWIG_AsVal_int(obj1, &val2);
5079 if (!SWIG_IsOK(ecode2)) {
5080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_SetStyle" "', expected argument " "2"" of type '" "int""'");
5081 }
5082 arg2 = static_cast< int >(val2);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 (arg1)->SetStyle(arg2);
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_Py_Void();
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Brush_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj = 0;
5098 wxBrush *arg1 = (wxBrush *) 0 ;
5099 wxBitmap *arg2 = 0 ;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 void *argp2 = 0 ;
5103 int res2 = 0 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char * kwnames[] = {
5107 (char *) "self",(char *) "stipple", NULL
5108 };
5109
5110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5112 if (!SWIG_IsOK(res1)) {
5113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStipple" "', expected argument " "1"" of type '" "wxBrush *""'");
5114 }
5115 arg1 = reinterpret_cast< wxBrush * >(argp1);
5116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
5117 if (!SWIG_IsOK(res2)) {
5118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5119 }
5120 if (!argp2) {
5121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5122 }
5123 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5124 {
5125 PyThreadState* __tstate = wxPyBeginAllowThreads();
5126 (arg1)->SetStipple((wxBitmap const &)*arg2);
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 resultobj = SWIG_Py_Void();
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_Brush_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138 PyObject *resultobj = 0;
5139 wxBrush *arg1 = (wxBrush *) 0 ;
5140 wxColour result;
5141 void *argp1 = 0 ;
5142 int res1 = 0 ;
5143 PyObject *swig_obj[1] ;
5144
5145 if (!args) SWIG_fail;
5146 swig_obj[0] = args;
5147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5148 if (!SWIG_IsOK(res1)) {
5149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetColour" "', expected argument " "1"" of type '" "wxBrush const *""'");
5150 }
5151 arg1 = reinterpret_cast< wxBrush * >(argp1);
5152 {
5153 PyThreadState* __tstate = wxPyBeginAllowThreads();
5154 result = ((wxBrush const *)arg1)->GetColour();
5155 wxPyEndAllowThreads(__tstate);
5156 if (PyErr_Occurred()) SWIG_fail;
5157 }
5158 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
5159 return resultobj;
5160 fail:
5161 return NULL;
5162 }
5163
5164
5165 SWIGINTERN PyObject *_wrap_Brush_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5166 PyObject *resultobj = 0;
5167 wxBrush *arg1 = (wxBrush *) 0 ;
5168 int result;
5169 void *argp1 = 0 ;
5170 int res1 = 0 ;
5171 PyObject *swig_obj[1] ;
5172
5173 if (!args) SWIG_fail;
5174 swig_obj[0] = args;
5175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5176 if (!SWIG_IsOK(res1)) {
5177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStyle" "', expected argument " "1"" of type '" "wxBrush const *""'");
5178 }
5179 arg1 = reinterpret_cast< wxBrush * >(argp1);
5180 {
5181 PyThreadState* __tstate = wxPyBeginAllowThreads();
5182 result = (int)((wxBrush const *)arg1)->GetStyle();
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_From_int(static_cast< int >(result));
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_Brush_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5194 PyObject *resultobj = 0;
5195 wxBrush *arg1 = (wxBrush *) 0 ;
5196 wxBitmap *result = 0 ;
5197 void *argp1 = 0 ;
5198 int res1 = 0 ;
5199 PyObject *swig_obj[1] ;
5200
5201 if (!args) SWIG_fail;
5202 swig_obj[0] = args;
5203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5204 if (!SWIG_IsOK(res1)) {
5205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStipple" "', expected argument " "1"" of type '" "wxBrush const *""'");
5206 }
5207 arg1 = reinterpret_cast< wxBrush * >(argp1);
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Brush_IsHatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5222 PyObject *resultobj = 0;
5223 wxBrush *arg1 = (wxBrush *) 0 ;
5224 bool result;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 PyObject *swig_obj[1] ;
5228
5229 if (!args) SWIG_fail;
5230 swig_obj[0] = args;
5231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5232 if (!SWIG_IsOK(res1)) {
5233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_IsHatch" "', expected argument " "1"" of type '" "wxBrush const *""'");
5234 }
5235 arg1 = reinterpret_cast< wxBrush * >(argp1);
5236 {
5237 PyThreadState* __tstate = wxPyBeginAllowThreads();
5238 result = (bool)((wxBrush const *)arg1)->IsHatch();
5239 wxPyEndAllowThreads(__tstate);
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 {
5243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5244 }
5245 return resultobj;
5246 fail:
5247 return NULL;
5248 }
5249
5250
5251 SWIGINTERN PyObject *_wrap_Brush_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5252 PyObject *resultobj = 0;
5253 wxBrush *arg1 = (wxBrush *) 0 ;
5254 bool result;
5255 void *argp1 = 0 ;
5256 int res1 = 0 ;
5257 PyObject *swig_obj[1] ;
5258
5259 if (!args) SWIG_fail;
5260 swig_obj[0] = args;
5261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_Ok" "', expected argument " "1"" of type '" "wxBrush *""'");
5264 }
5265 arg1 = reinterpret_cast< wxBrush * >(argp1);
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (bool)(arg1)->Ok();
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5274 }
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 SWIGINTERN PyObject *Brush_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 PyObject *obj;
5283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5284 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrush, SWIG_NewClientData(obj));
5285 return SWIG_Py_Void();
5286 }
5287
5288 SWIGINTERN PyObject *Brush_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5289 return SWIG_Python_InitShadowInstance(args);
5290 }
5291
5292 SWIGINTERN PyObject *_wrap_new_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 wxString *arg1 = 0 ;
5295 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
5296 wxBitmap *result = 0 ;
5297 bool temp1 = false ;
5298 int val2 ;
5299 int ecode2 = 0 ;
5300 PyObject * obj0 = 0 ;
5301 PyObject * obj1 = 0 ;
5302 char * kwnames[] = {
5303 (char *) "name",(char *) "type", NULL
5304 };
5305
5306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5307 {
5308 arg1 = wxString_in_helper(obj0);
5309 if (arg1 == NULL) SWIG_fail;
5310 temp1 = true;
5311 }
5312 if (obj1) {
5313 ecode2 = SWIG_AsVal_int(obj1, &val2);
5314 if (!SWIG_IsOK(ecode2)) {
5315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Bitmap" "', expected argument " "2"" of type '" "wxBitmapType""'");
5316 }
5317 arg2 = static_cast< wxBitmapType >(val2);
5318 }
5319 {
5320 if (!wxPyCheckForApp()) SWIG_fail;
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,arg2);
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_NEW | 0 );
5327 {
5328 if (temp1)
5329 delete arg1;
5330 }
5331 return resultobj;
5332 fail:
5333 {
5334 if (temp1)
5335 delete arg1;
5336 }
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_delete_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5342 PyObject *resultobj = 0;
5343 wxBitmap *arg1 = (wxBitmap *) 0 ;
5344 void *argp1 = 0 ;
5345 int res1 = 0 ;
5346 PyObject *swig_obj[1] ;
5347
5348 if (!args) SWIG_fail;
5349 swig_obj[0] = args;
5350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, SWIG_POINTER_DISOWN | 0 );
5351 if (!SWIG_IsOK(res1)) {
5352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bitmap" "', expected argument " "1"" of type '" "wxBitmap *""'");
5353 }
5354 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5355 {
5356 PyThreadState* __tstate = wxPyBeginAllowThreads();
5357 delete arg1;
5358
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 resultobj = SWIG_Py_Void();
5363 return resultobj;
5364 fail:
5365 return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *_wrap_new_EmptyBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5370 PyObject *resultobj = 0;
5371 int arg1 ;
5372 int arg2 ;
5373 int arg3 = (int) -1 ;
5374 wxBitmap *result = 0 ;
5375 int val1 ;
5376 int ecode1 = 0 ;
5377 int val2 ;
5378 int ecode2 = 0 ;
5379 int val3 ;
5380 int ecode3 = 0 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 PyObject * obj2 = 0 ;
5384 char * kwnames[] = {
5385 (char *) "width",(char *) "height",(char *) "depth", NULL
5386 };
5387
5388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5389 ecode1 = SWIG_AsVal_int(obj0, &val1);
5390 if (!SWIG_IsOK(ecode1)) {
5391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyBitmap" "', expected argument " "1"" of type '" "int""'");
5392 }
5393 arg1 = static_cast< int >(val1);
5394 ecode2 = SWIG_AsVal_int(obj1, &val2);
5395 if (!SWIG_IsOK(ecode2)) {
5396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyBitmap" "', expected argument " "2"" of type '" "int""'");
5397 }
5398 arg2 = static_cast< int >(val2);
5399 if (obj2) {
5400 ecode3 = SWIG_AsVal_int(obj2, &val3);
5401 if (!SWIG_IsOK(ecode3)) {
5402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyBitmap" "', expected argument " "3"" of type '" "int""'");
5403 }
5404 arg3 = static_cast< int >(val3);
5405 }
5406 {
5407 if (!wxPyCheckForApp()) SWIG_fail;
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 SWIGINTERN PyObject *_wrap_new_BitmapFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5421 PyObject *resultobj = 0;
5422 wxIcon *arg1 = 0 ;
5423 wxBitmap *result = 0 ;
5424 void *argp1 = 0 ;
5425 int res1 = 0 ;
5426 PyObject * obj0 = 0 ;
5427 char * kwnames[] = {
5428 (char *) "icon", NULL
5429 };
5430
5431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) SWIG_fail;
5432 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5435 }
5436 if (!argp1) {
5437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5438 }
5439 arg1 = reinterpret_cast< wxIcon * >(argp1);
5440 {
5441 if (!wxPyCheckForApp()) SWIG_fail;
5442 PyThreadState* __tstate = wxPyBeginAllowThreads();
5443 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
5454 SWIGINTERN PyObject *_wrap_new_BitmapFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj = 0;
5456 wxImage *arg1 = 0 ;
5457 int arg2 = (int) -1 ;
5458 wxBitmap *result = 0 ;
5459 void *argp1 = 0 ;
5460 int res1 = 0 ;
5461 int val2 ;
5462 int ecode2 = 0 ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char * kwnames[] = {
5466 (char *) "image",(char *) "depth", NULL
5467 };
5468
5469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) SWIG_fail;
5470 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5473 }
5474 if (!argp1) {
5475 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5476 }
5477 arg1 = reinterpret_cast< wxImage * >(argp1);
5478 if (obj1) {
5479 ecode2 = SWIG_AsVal_int(obj1, &val2);
5480 if (!SWIG_IsOK(ecode2)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromImage" "', expected argument " "2"" of type '" "int""'");
5482 }
5483 arg2 = static_cast< int >(val2);
5484 }
5485 {
5486 if (!wxPyCheckForApp()) SWIG_fail;
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_new_BitmapFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5500 PyObject *resultobj = 0;
5501 PyObject *arg1 = (PyObject *) 0 ;
5502 wxBitmap *result = 0 ;
5503 PyObject * obj0 = 0 ;
5504 char * kwnames[] = {
5505 (char *) "listOfStrings", NULL
5506 };
5507
5508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) SWIG_fail;
5509 arg1 = obj0;
5510 {
5511 if (!wxPyCheckForApp()) SWIG_fail;
5512 PyThreadState* __tstate = wxPyBeginAllowThreads();
5513 result = (wxBitmap *)new_wxBitmap(arg1);
5514 wxPyEndAllowThreads(__tstate);
5515 if (PyErr_Occurred()) SWIG_fail;
5516 }
5517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_new_BitmapFromBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 PyObject *arg1 = (PyObject *) 0 ;
5527 int arg2 ;
5528 int arg3 ;
5529 int arg4 = (int) 1 ;
5530 wxBitmap *result = 0 ;
5531 int val2 ;
5532 int ecode2 = 0 ;
5533 int val3 ;
5534 int ecode3 = 0 ;
5535 int val4 ;
5536 int ecode4 = 0 ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 PyObject * obj2 = 0 ;
5540 PyObject * obj3 = 0 ;
5541 char * kwnames[] = {
5542 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
5543 };
5544
5545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5546 arg1 = obj0;
5547 ecode2 = SWIG_AsVal_int(obj1, &val2);
5548 if (!SWIG_IsOK(ecode2)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromBits" "', expected argument " "2"" of type '" "int""'");
5550 }
5551 arg2 = static_cast< int >(val2);
5552 ecode3 = SWIG_AsVal_int(obj2, &val3);
5553 if (!SWIG_IsOK(ecode3)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BitmapFromBits" "', expected argument " "3"" of type '" "int""'");
5555 }
5556 arg3 = static_cast< int >(val3);
5557 if (obj3) {
5558 ecode4 = SWIG_AsVal_int(obj3, &val4);
5559 if (!SWIG_IsOK(ecode4)) {
5560 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BitmapFromBits" "', expected argument " "4"" of type '" "int""'");
5561 }
5562 arg4 = static_cast< int >(val4);
5563 }
5564 {
5565 if (!wxPyCheckForApp()) SWIG_fail;
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *_wrap_Bitmap_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *resultobj = 0;
5580 wxBitmap *arg1 = (wxBitmap *) 0 ;
5581 bool result;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 PyObject *swig_obj[1] ;
5585
5586 if (!args) SWIG_fail;
5587 swig_obj[0] = args;
5588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5589 if (!SWIG_IsOK(res1)) {
5590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_Ok" "', expected argument " "1"" of type '" "wxBitmap *""'");
5591 }
5592 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5593 {
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 result = (bool)(arg1)->Ok();
5596 wxPyEndAllowThreads(__tstate);
5597 if (PyErr_Occurred()) SWIG_fail;
5598 }
5599 {
5600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5601 }
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 SWIGINTERN PyObject *_wrap_Bitmap_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5609 PyObject *resultobj = 0;
5610 wxBitmap *arg1 = (wxBitmap *) 0 ;
5611 int result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 PyObject *swig_obj[1] ;
5615
5616 if (!args) SWIG_fail;
5617 swig_obj[0] = args;
5618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5619 if (!SWIG_IsOK(res1)) {
5620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
5621 }
5622 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5623 {
5624 PyThreadState* __tstate = wxPyBeginAllowThreads();
5625 result = (int)(arg1)->GetWidth();
5626 wxPyEndAllowThreads(__tstate);
5627 if (PyErr_Occurred()) SWIG_fail;
5628 }
5629 resultobj = SWIG_From_int(static_cast< int >(result));
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 SWIGINTERN PyObject *_wrap_Bitmap_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5637 PyObject *resultobj = 0;
5638 wxBitmap *arg1 = (wxBitmap *) 0 ;
5639 int result;
5640 void *argp1 = 0 ;
5641 int res1 = 0 ;
5642 PyObject *swig_obj[1] ;
5643
5644 if (!args) SWIG_fail;
5645 swig_obj[0] = args;
5646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5647 if (!SWIG_IsOK(res1)) {
5648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
5649 }
5650 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5651 {
5652 PyThreadState* __tstate = wxPyBeginAllowThreads();
5653 result = (int)(arg1)->GetHeight();
5654 wxPyEndAllowThreads(__tstate);
5655 if (PyErr_Occurred()) SWIG_fail;
5656 }
5657 resultobj = SWIG_From_int(static_cast< int >(result));
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
5664 SWIGINTERN PyObject *_wrap_Bitmap_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5665 PyObject *resultobj = 0;
5666 wxBitmap *arg1 = (wxBitmap *) 0 ;
5667 int result;
5668 void *argp1 = 0 ;
5669 int res1 = 0 ;
5670 PyObject *swig_obj[1] ;
5671
5672 if (!args) SWIG_fail;
5673 swig_obj[0] = args;
5674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5675 if (!SWIG_IsOK(res1)) {
5676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
5677 }
5678 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5679 {
5680 PyThreadState* __tstate = wxPyBeginAllowThreads();
5681 result = (int)(arg1)->GetDepth();
5682 wxPyEndAllowThreads(__tstate);
5683 if (PyErr_Occurred()) SWIG_fail;
5684 }
5685 resultobj = SWIG_From_int(static_cast< int >(result));
5686 return resultobj;
5687 fail:
5688 return NULL;
5689 }
5690
5691
5692 SWIGINTERN PyObject *_wrap_Bitmap_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5693 PyObject *resultobj = 0;
5694 wxBitmap *arg1 = (wxBitmap *) 0 ;
5695 wxSize result;
5696 void *argp1 = 0 ;
5697 int res1 = 0 ;
5698 PyObject *swig_obj[1] ;
5699
5700 if (!args) SWIG_fail;
5701 swig_obj[0] = args;
5702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5703 if (!SWIG_IsOK(res1)) {
5704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
5705 }
5706 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5707 {
5708 PyThreadState* __tstate = wxPyBeginAllowThreads();
5709 result = wxBitmap_GetSize(arg1);
5710 wxPyEndAllowThreads(__tstate);
5711 if (PyErr_Occurred()) SWIG_fail;
5712 }
5713 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 SWIGINTERN PyObject *_wrap_Bitmap_ConvertToImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 PyObject *resultobj = 0;
5722 wxBitmap *arg1 = (wxBitmap *) 0 ;
5723 SwigValueWrapper<wxImage > result;
5724 void *argp1 = 0 ;
5725 int res1 = 0 ;
5726 PyObject *swig_obj[1] ;
5727
5728 if (!args) SWIG_fail;
5729 swig_obj[0] = args;
5730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_ConvertToImage" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5733 }
5734 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5735 {
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 result = ((wxBitmap const *)arg1)->ConvertToImage();
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 SWIGINTERN PyObject *_wrap_Bitmap_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5749 PyObject *resultobj = 0;
5750 wxBitmap *arg1 = (wxBitmap *) 0 ;
5751 wxMask *result = 0 ;
5752 void *argp1 = 0 ;
5753 int res1 = 0 ;
5754 PyObject *swig_obj[1] ;
5755
5756 if (!args) SWIG_fail;
5757 swig_obj[0] = args;
5758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5759 if (!SWIG_IsOK(res1)) {
5760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetMask" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5761 }
5762 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5763 {
5764 PyThreadState* __tstate = wxPyBeginAllowThreads();
5765 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
5766 wxPyEndAllowThreads(__tstate);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, 0 | 0 );
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_Bitmap_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxBitmap *arg1 = (wxBitmap *) 0 ;
5779 wxMask *arg2 = (wxMask *) 0 ;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 int res2 = 0 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "self",(char *) "mask", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
5790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMask" "', expected argument " "1"" of type '" "wxBitmap *""'");
5793 }
5794 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5795 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
5796 if (!SWIG_IsOK(res2)) {
5797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetMask" "', expected argument " "2"" of type '" "wxMask *""'");
5798 }
5799 {
5800 PyThreadState* __tstate = wxPyBeginAllowThreads();
5801 (arg1)->SetMask(arg2);
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 resultobj = SWIG_Py_Void();
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_Bitmap_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = 0;
5814 wxBitmap *arg1 = (wxBitmap *) 0 ;
5815 wxColour *arg2 = 0 ;
5816 void *argp1 = 0 ;
5817 int res1 = 0 ;
5818 wxColour temp2 ;
5819 PyObject * obj0 = 0 ;
5820 PyObject * obj1 = 0 ;
5821 char * kwnames[] = {
5822 (char *) "self",(char *) "colour", NULL
5823 };
5824
5825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) SWIG_fail;
5826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5827 if (!SWIG_IsOK(res1)) {
5828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMaskColour" "', expected argument " "1"" of type '" "wxBitmap *""'");
5829 }
5830 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5831 {
5832 arg2 = &temp2;
5833 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 resultobj = SWIG_Py_Void();
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5849 PyObject *resultobj = 0;
5850 wxBitmap *arg1 = (wxBitmap *) 0 ;
5851 wxRect *arg2 = 0 ;
5852 SwigValueWrapper<wxBitmap > result;
5853 void *argp1 = 0 ;
5854 int res1 = 0 ;
5855 wxRect temp2 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "self",(char *) "rect", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5864 if (!SWIG_IsOK(res1)) {
5865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSubBitmap" "', expected argument " "1"" of type '" "wxBitmap const *""'");
5866 }
5867 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 SWIGINTERN PyObject *_wrap_Bitmap_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj = 0;
5887 wxBitmap *arg1 = (wxBitmap *) 0 ;
5888 wxString *arg2 = 0 ;
5889 wxBitmapType arg3 ;
5890 wxPalette *arg4 = (wxPalette *) NULL ;
5891 bool result;
5892 void *argp1 = 0 ;
5893 int res1 = 0 ;
5894 bool temp2 = false ;
5895 int val3 ;
5896 int ecode3 = 0 ;
5897 void *argp4 = 0 ;
5898 int res4 = 0 ;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5901 PyObject * obj2 = 0 ;
5902 PyObject * obj3 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SaveFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
5911 }
5912 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5913 {
5914 arg2 = wxString_in_helper(obj1);
5915 if (arg2 == NULL) SWIG_fail;
5916 temp2 = true;
5917 }
5918 ecode3 = SWIG_AsVal_int(obj2, &val3);
5919 if (!SWIG_IsOK(ecode3)) {
5920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_SaveFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
5921 }
5922 arg3 = static_cast< wxBitmapType >(val3);
5923 if (obj3) {
5924 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxPalette, 0 | 0 );
5925 if (!SWIG_IsOK(res4)) {
5926 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Bitmap_SaveFile" "', expected argument " "4"" of type '" "wxPalette *""'");
5927 }
5928 arg4 = reinterpret_cast< wxPalette * >(argp4);
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3,arg4);
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 {
5937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5938 }
5939 {
5940 if (temp2)
5941 delete arg2;
5942 }
5943 return resultobj;
5944 fail:
5945 {
5946 if (temp2)
5947 delete arg2;
5948 }
5949 return NULL;
5950 }
5951
5952
5953 SWIGINTERN PyObject *_wrap_Bitmap_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj = 0;
5955 wxBitmap *arg1 = (wxBitmap *) 0 ;
5956 wxString *arg2 = 0 ;
5957 wxBitmapType arg3 ;
5958 bool result;
5959 void *argp1 = 0 ;
5960 int res1 = 0 ;
5961 bool temp2 = false ;
5962 int val3 ;
5963 int ecode3 = 0 ;
5964 PyObject * obj0 = 0 ;
5965 PyObject * obj1 = 0 ;
5966 PyObject * obj2 = 0 ;
5967 char * kwnames[] = {
5968 (char *) "self",(char *) "name",(char *) "type", NULL
5969 };
5970
5971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5973 if (!SWIG_IsOK(res1)) {
5974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_LoadFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
5975 }
5976 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5977 {
5978 arg2 = wxString_in_helper(obj1);
5979 if (arg2 == NULL) SWIG_fail;
5980 temp2 = true;
5981 }
5982 ecode3 = SWIG_AsVal_int(obj2, &val3);
5983 if (!SWIG_IsOK(ecode3)) {
5984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
5985 }
5986 arg3 = static_cast< wxBitmapType >(val3);
5987 {
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 {
5994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5995 }
5996 {
5997 if (temp2)
5998 delete arg2;
5999 }
6000 return resultobj;
6001 fail:
6002 {
6003 if (temp2)
6004 delete arg2;
6005 }
6006 return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_Bitmap_GetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6011 PyObject *resultobj = 0;
6012 wxBitmap *arg1 = (wxBitmap *) 0 ;
6013 wxPalette *result = 0 ;
6014 void *argp1 = 0 ;
6015 int res1 = 0 ;
6016 PyObject *swig_obj[1] ;
6017
6018 if (!args) SWIG_fail;
6019 swig_obj[0] = args;
6020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetPalette" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6023 }
6024 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, 0 | 0 );
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj = 0;
6040 wxBitmap *arg1 = (wxBitmap *) 0 ;
6041 wxIcon *arg2 = 0 ;
6042 bool result;
6043 void *argp1 = 0 ;
6044 int res1 = 0 ;
6045 void *argp2 = 0 ;
6046 int res2 = 0 ;
6047 PyObject * obj0 = 0 ;
6048 PyObject * obj1 = 0 ;
6049 char * kwnames[] = {
6050 (char *) "self",(char *) "icon", NULL
6051 };
6052
6053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) SWIG_fail;
6054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6055 if (!SWIG_IsOK(res1)) {
6056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "1"" of type '" "wxBitmap *""'");
6057 }
6058 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
6060 if (!SWIG_IsOK(res2)) {
6061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6062 }
6063 if (!argp2) {
6064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6065 }
6066 arg2 = reinterpret_cast< wxIcon * >(argp2);
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 {
6074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6075 }
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 SWIGINTERN PyObject *_wrap_Bitmap_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj = 0;
6084 wxBitmap *arg1 = (wxBitmap *) 0 ;
6085 int arg2 ;
6086 void *argp1 = 0 ;
6087 int res1 = 0 ;
6088 int val2 ;
6089 int ecode2 = 0 ;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 char * kwnames[] = {
6093 (char *) "self",(char *) "height", NULL
6094 };
6095
6096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6098 if (!SWIG_IsOK(res1)) {
6099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6100 }
6101 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6102 ecode2 = SWIG_AsVal_int(obj1, &val2);
6103 if (!SWIG_IsOK(ecode2)) {
6104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHeight" "', expected argument " "2"" of type '" "int""'");
6105 }
6106 arg2 = static_cast< int >(val2);
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 (arg1)->SetHeight(arg2);
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_Py_Void();
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_Bitmap_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxBitmap *arg1 = (wxBitmap *) 0 ;
6123 int arg2 ;
6124 void *argp1 = 0 ;
6125 int res1 = 0 ;
6126 int val2 ;
6127 int ecode2 = 0 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char * kwnames[] = {
6131 (char *) "self",(char *) "width", NULL
6132 };
6133
6134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6138 }
6139 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6140 ecode2 = SWIG_AsVal_int(obj1, &val2);
6141 if (!SWIG_IsOK(ecode2)) {
6142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetWidth" "', expected argument " "2"" of type '" "int""'");
6143 }
6144 arg2 = static_cast< int >(val2);
6145 {
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 (arg1)->SetWidth(arg2);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 resultobj = SWIG_Py_Void();
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 SWIGINTERN PyObject *_wrap_Bitmap_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6159 PyObject *resultobj = 0;
6160 wxBitmap *arg1 = (wxBitmap *) 0 ;
6161 int arg2 ;
6162 void *argp1 = 0 ;
6163 int res1 = 0 ;
6164 int val2 ;
6165 int ecode2 = 0 ;
6166 PyObject * obj0 = 0 ;
6167 PyObject * obj1 = 0 ;
6168 char * kwnames[] = {
6169 (char *) "self",(char *) "depth", NULL
6170 };
6171
6172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6174 if (!SWIG_IsOK(res1)) {
6175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6176 }
6177 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6178 ecode2 = SWIG_AsVal_int(obj1, &val2);
6179 if (!SWIG_IsOK(ecode2)) {
6180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetDepth" "', expected argument " "2"" of type '" "int""'");
6181 }
6182 arg2 = static_cast< int >(val2);
6183 {
6184 PyThreadState* __tstate = wxPyBeginAllowThreads();
6185 (arg1)->SetDepth(arg2);
6186 wxPyEndAllowThreads(__tstate);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = SWIG_Py_Void();
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *_wrap_Bitmap_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6197 PyObject *resultobj = 0;
6198 wxBitmap *arg1 = (wxBitmap *) 0 ;
6199 wxSize *arg2 = 0 ;
6200 void *argp1 = 0 ;
6201 int res1 = 0 ;
6202 wxSize temp2 ;
6203 PyObject * obj0 = 0 ;
6204 PyObject * obj1 = 0 ;
6205 char * kwnames[] = {
6206 (char *) "self",(char *) "size", NULL
6207 };
6208
6209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6211 if (!SWIG_IsOK(res1)) {
6212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6213 }
6214 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6215 {
6216 arg2 = &temp2;
6217 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6218 }
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_Py_Void();
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_Bitmap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxBitmap *arg1 = (wxBitmap *) 0 ;
6235 wxBitmap *arg2 = (wxBitmap *) 0 ;
6236 bool result;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 void *argp2 = 0 ;
6240 int res2 = 0 ;
6241 PyObject * obj0 = 0 ;
6242 PyObject * obj1 = 0 ;
6243 char * kwnames[] = {
6244 (char *) "self",(char *) "other", NULL
6245 };
6246
6247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6249 if (!SWIG_IsOK(res1)) {
6250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___eq__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6251 }
6252 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6254 if (!SWIG_IsOK(res2)) {
6255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___eq__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6256 }
6257 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6258 {
6259 PyThreadState* __tstate = wxPyBeginAllowThreads();
6260 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 {
6265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6266 }
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_Bitmap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = 0;
6275 wxBitmap *arg1 = (wxBitmap *) 0 ;
6276 wxBitmap *arg2 = (wxBitmap *) 0 ;
6277 bool result;
6278 void *argp1 = 0 ;
6279 int res1 = 0 ;
6280 void *argp2 = 0 ;
6281 int res2 = 0 ;
6282 PyObject * obj0 = 0 ;
6283 PyObject * obj1 = 0 ;
6284 char * kwnames[] = {
6285 (char *) "self",(char *) "other", NULL
6286 };
6287
6288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6290 if (!SWIG_IsOK(res1)) {
6291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___ne__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6292 }
6293 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6295 if (!SWIG_IsOK(res2)) {
6296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___ne__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6297 }
6298 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6299 {
6300 PyThreadState* __tstate = wxPyBeginAllowThreads();
6301 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
6302 wxPyEndAllowThreads(__tstate);
6303 if (PyErr_Occurred()) SWIG_fail;
6304 }
6305 {
6306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6307 }
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 SWIGINTERN PyObject *Bitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6315 PyObject *obj;
6316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6317 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmap, SWIG_NewClientData(obj));
6318 return SWIG_Py_Void();
6319 }
6320
6321 SWIGINTERN PyObject *Bitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6322 return SWIG_Python_InitShadowInstance(args);
6323 }
6324
6325 SWIGINTERN PyObject *_wrap_new_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = 0;
6327 wxBitmap *arg1 = 0 ;
6328 wxColour const &arg2_defvalue = wxNullColour ;
6329 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
6330 wxMask *result = 0 ;
6331 void *argp1 = 0 ;
6332 int res1 = 0 ;
6333 wxColour temp2 ;
6334 PyObject * obj0 = 0 ;
6335 PyObject * obj1 = 0 ;
6336 char * kwnames[] = {
6337 (char *) "bitmap",(char *) "colour", NULL
6338 };
6339
6340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) SWIG_fail;
6341 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
6342 if (!SWIG_IsOK(res1)) {
6343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6344 }
6345 if (!argp1) {
6346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6347 }
6348 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6349 if (obj1) {
6350 {
6351 arg2 = &temp2;
6352 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6353 }
6354 }
6355 {
6356 if (!wxPyCheckForApp()) SWIG_fail;
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, SWIG_POINTER_NEW | 0 );
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 SWIGINTERN PyObject *_wrap_delete_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6370 PyObject *resultobj = 0;
6371 wxMask *arg1 = (wxMask *) 0 ;
6372 void *argp1 = 0 ;
6373 int res1 = 0 ;
6374 PyObject *swig_obj[1] ;
6375
6376 if (!args) SWIG_fail;
6377 swig_obj[0] = args;
6378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
6379 if (!SWIG_IsOK(res1)) {
6380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mask" "', expected argument " "1"" of type '" "wxMask *""'");
6381 }
6382 arg1 = reinterpret_cast< wxMask * >(argp1);
6383 {
6384 PyThreadState* __tstate = wxPyBeginAllowThreads();
6385 delete arg1;
6386
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 resultobj = SWIG_Py_Void();
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 SWIGINTERN PyObject *Mask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6398 PyObject *obj;
6399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6400 SWIG_TypeNewClientData(SWIGTYPE_p_wxMask, SWIG_NewClientData(obj));
6401 return SWIG_Py_Void();
6402 }
6403
6404 SWIGINTERN PyObject *Mask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6405 return SWIG_Python_InitShadowInstance(args);
6406 }
6407
6408 SWIGINTERN PyObject *_wrap_new_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6409 PyObject *resultobj = 0;
6410 wxString *arg1 = 0 ;
6411 wxBitmapType arg2 ;
6412 int arg3 = (int) -1 ;
6413 int arg4 = (int) -1 ;
6414 wxIcon *result = 0 ;
6415 bool temp1 = false ;
6416 int val2 ;
6417 int ecode2 = 0 ;
6418 int val3 ;
6419 int ecode3 = 0 ;
6420 int val4 ;
6421 int ecode4 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 PyObject * obj2 = 0 ;
6425 PyObject * obj3 = 0 ;
6426 char * kwnames[] = {
6427 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
6428 };
6429
6430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6431 {
6432 arg1 = wxString_in_helper(obj0);
6433 if (arg1 == NULL) SWIG_fail;
6434 temp1 = true;
6435 }
6436 ecode2 = SWIG_AsVal_int(obj1, &val2);
6437 if (!SWIG_IsOK(ecode2)) {
6438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Icon" "', expected argument " "2"" of type '" "wxBitmapType""'");
6439 }
6440 arg2 = static_cast< wxBitmapType >(val2);
6441 if (obj2) {
6442 ecode3 = SWIG_AsVal_int(obj2, &val3);
6443 if (!SWIG_IsOK(ecode3)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Icon" "', expected argument " "3"" of type '" "int""'");
6445 }
6446 arg3 = static_cast< int >(val3);
6447 }
6448 if (obj3) {
6449 ecode4 = SWIG_AsVal_int(obj3, &val4);
6450 if (!SWIG_IsOK(ecode4)) {
6451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Icon" "', expected argument " "4"" of type '" "int""'");
6452 }
6453 arg4 = static_cast< int >(val4);
6454 }
6455 {
6456 if (!wxPyCheckForApp()) SWIG_fail;
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (wxIcon *)new wxIcon((wxString const &)*arg1,arg2,arg3,arg4);
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_NEW | 0 );
6463 {
6464 if (temp1)
6465 delete arg1;
6466 }
6467 return resultobj;
6468 fail:
6469 {
6470 if (temp1)
6471 delete arg1;
6472 }
6473 return NULL;
6474 }
6475
6476
6477 SWIGINTERN PyObject *_wrap_delete_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6478 PyObject *resultobj = 0;
6479 wxIcon *arg1 = (wxIcon *) 0 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, SWIG_POINTER_DISOWN | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Icon" "', expected argument " "1"" of type '" "wxIcon *""'");
6489 }
6490 arg1 = reinterpret_cast< wxIcon * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 delete arg1;
6494
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_Py_Void();
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 SWIGINTERN PyObject *_wrap_new_EmptyIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6506 PyObject *resultobj = 0;
6507 wxIcon *result = 0 ;
6508
6509 if (!SWIG_Python_UnpackTuple(args,"new_EmptyIcon",0,0,0)) SWIG_fail;
6510 {
6511 if (!wxPyCheckForApp()) SWIG_fail;
6512 PyThreadState* __tstate = wxPyBeginAllowThreads();
6513 result = (wxIcon *)new wxIcon();
6514 wxPyEndAllowThreads(__tstate);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 SWIGINTERN PyObject *_wrap_new_IconFromLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj = 0;
6526 wxIconLocation *arg1 = 0 ;
6527 wxIcon *result = 0 ;
6528 void *argp1 = 0 ;
6529 int res1 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 char * kwnames[] = {
6532 (char *) "loc", NULL
6533 };
6534
6535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) SWIG_fail;
6536 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIconLocation, 0 | 0);
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
6539 }
6540 if (!argp1) {
6541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
6542 }
6543 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
6544 {
6545 if (!wxPyCheckForApp()) SWIG_fail;
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_new_IconFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj = 0;
6560 wxBitmap *arg1 = 0 ;
6561 wxIcon *result = 0 ;
6562 void *argp1 = 0 ;
6563 int res1 = 0 ;
6564 PyObject * obj0 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "bmp", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) SWIG_fail;
6570 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
6571 if (!SWIG_IsOK(res1)) {
6572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6573 }
6574 if (!argp1) {
6575 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
6576 }
6577 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6578 {
6579 if (!wxPyCheckForApp()) SWIG_fail;
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
6582 wxPyEndAllowThreads(__tstate);
6583 if (PyErr_Occurred()) SWIG_fail;
6584 }
6585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 SWIGINTERN PyObject *_wrap_new_IconFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6593 PyObject *resultobj = 0;
6594 PyObject *arg1 = (PyObject *) 0 ;
6595 wxIcon *result = 0 ;
6596 PyObject * obj0 = 0 ;
6597 char * kwnames[] = {
6598 (char *) "listOfStrings", NULL
6599 };
6600
6601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) SWIG_fail;
6602 arg1 = obj0;
6603 {
6604 if (!wxPyCheckForApp()) SWIG_fail;
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 result = (wxIcon *)new_wxIcon(arg1);
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
6611 return resultobj;
6612 fail:
6613 return NULL;
6614 }
6615
6616
6617 SWIGINTERN PyObject *_wrap_Icon_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6618 PyObject *resultobj = 0;
6619 wxIcon *arg1 = (wxIcon *) 0 ;
6620 wxString *arg2 = 0 ;
6621 wxBitmapType arg3 ;
6622 bool result;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 bool temp2 = false ;
6626 int val3 ;
6627 int ecode3 = 0 ;
6628 PyObject * obj0 = 0 ;
6629 PyObject * obj1 = 0 ;
6630 PyObject * obj2 = 0 ;
6631 char * kwnames[] = {
6632 (char *) "self",(char *) "name",(char *) "type", NULL
6633 };
6634
6635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6637 if (!SWIG_IsOK(res1)) {
6638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_LoadFile" "', expected argument " "1"" of type '" "wxIcon *""'");
6639 }
6640 arg1 = reinterpret_cast< wxIcon * >(argp1);
6641 {
6642 arg2 = wxString_in_helper(obj1);
6643 if (arg2 == NULL) SWIG_fail;
6644 temp2 = true;
6645 }
6646 ecode3 = SWIG_AsVal_int(obj2, &val3);
6647 if (!SWIG_IsOK(ecode3)) {
6648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Icon_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6649 }
6650 arg3 = static_cast< wxBitmapType >(val3);
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 {
6658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6659 }
6660 {
6661 if (temp2)
6662 delete arg2;
6663 }
6664 return resultobj;
6665 fail:
6666 {
6667 if (temp2)
6668 delete arg2;
6669 }
6670 return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_Icon_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6675 PyObject *resultobj = 0;
6676 wxIcon *arg1 = (wxIcon *) 0 ;
6677 bool result;
6678 void *argp1 = 0 ;
6679 int res1 = 0 ;
6680 PyObject *swig_obj[1] ;
6681
6682 if (!args) SWIG_fail;
6683 swig_obj[0] = args;
6684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6685 if (!SWIG_IsOK(res1)) {
6686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_Ok" "', expected argument " "1"" of type '" "wxIcon *""'");
6687 }
6688 arg1 = reinterpret_cast< wxIcon * >(argp1);
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (bool)(arg1)->Ok();
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 {
6696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6697 }
6698 return resultobj;
6699 fail:
6700 return NULL;
6701 }
6702
6703
6704 SWIGINTERN PyObject *_wrap_Icon_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6705 PyObject *resultobj = 0;
6706 wxIcon *arg1 = (wxIcon *) 0 ;
6707 int result;
6708 void *argp1 = 0 ;
6709 int res1 = 0 ;
6710 PyObject *swig_obj[1] ;
6711
6712 if (!args) SWIG_fail;
6713 swig_obj[0] = args;
6714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6715 if (!SWIG_IsOK(res1)) {
6716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
6717 }
6718 arg1 = reinterpret_cast< wxIcon * >(argp1);
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 result = (int)(arg1)->GetWidth();
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_From_int(static_cast< int >(result));
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 SWIGINTERN PyObject *_wrap_Icon_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6733 PyObject *resultobj = 0;
6734 wxIcon *arg1 = (wxIcon *) 0 ;
6735 int result;
6736 void *argp1 = 0 ;
6737 int res1 = 0 ;
6738 PyObject *swig_obj[1] ;
6739
6740 if (!args) SWIG_fail;
6741 swig_obj[0] = args;
6742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
6745 }
6746 arg1 = reinterpret_cast< wxIcon * >(argp1);
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 result = (int)(arg1)->GetHeight();
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 resultobj = SWIG_From_int(static_cast< int >(result));
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_Icon_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxIcon *arg1 = (wxIcon *) 0 ;
6763 int result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
6773 }
6774 arg1 = reinterpret_cast< wxIcon * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)(arg1)->GetDepth();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_Icon_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj = 0;
6790 wxIcon *arg1 = (wxIcon *) 0 ;
6791 int arg2 ;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 int val2 ;
6795 int ecode2 = 0 ;
6796 PyObject * obj0 = 0 ;
6797 PyObject * obj1 = 0 ;
6798 char * kwnames[] = {
6799 (char *) "self",(char *) "w", NULL
6800 };
6801
6802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
6806 }
6807 arg1 = reinterpret_cast< wxIcon * >(argp1);
6808 ecode2 = SWIG_AsVal_int(obj1, &val2);
6809 if (!SWIG_IsOK(ecode2)) {
6810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetWidth" "', expected argument " "2"" of type '" "int""'");
6811 }
6812 arg2 = static_cast< int >(val2);
6813 {
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 (arg1)->SetWidth(arg2);
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 resultobj = SWIG_Py_Void();
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 SWIGINTERN PyObject *_wrap_Icon_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj = 0;
6828 wxIcon *arg1 = (wxIcon *) 0 ;
6829 int arg2 ;
6830 void *argp1 = 0 ;
6831 int res1 = 0 ;
6832 int val2 ;
6833 int ecode2 = 0 ;
6834 PyObject * obj0 = 0 ;
6835 PyObject * obj1 = 0 ;
6836 char * kwnames[] = {
6837 (char *) "self",(char *) "h", NULL
6838 };
6839
6840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6842 if (!SWIG_IsOK(res1)) {
6843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
6844 }
6845 arg1 = reinterpret_cast< wxIcon * >(argp1);
6846 ecode2 = SWIG_AsVal_int(obj1, &val2);
6847 if (!SWIG_IsOK(ecode2)) {
6848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHeight" "', expected argument " "2"" of type '" "int""'");
6849 }
6850 arg2 = static_cast< int >(val2);
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 (arg1)->SetHeight(arg2);
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_Py_Void();
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 SWIGINTERN PyObject *_wrap_Icon_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6865 PyObject *resultobj = 0;
6866 wxIcon *arg1 = (wxIcon *) 0 ;
6867 int arg2 ;
6868 void *argp1 = 0 ;
6869 int res1 = 0 ;
6870 int val2 ;
6871 int ecode2 = 0 ;
6872 PyObject * obj0 = 0 ;
6873 PyObject * obj1 = 0 ;
6874 char * kwnames[] = {
6875 (char *) "self",(char *) "d", NULL
6876 };
6877
6878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6880 if (!SWIG_IsOK(res1)) {
6881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
6882 }
6883 arg1 = reinterpret_cast< wxIcon * >(argp1);
6884 ecode2 = SWIG_AsVal_int(obj1, &val2);
6885 if (!SWIG_IsOK(ecode2)) {
6886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetDepth" "', expected argument " "2"" of type '" "int""'");
6887 }
6888 arg2 = static_cast< int >(val2);
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 (arg1)->SetDepth(arg2);
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_Py_Void();
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_Icon_CopyFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj = 0;
6904 wxIcon *arg1 = (wxIcon *) 0 ;
6905 wxBitmap *arg2 = 0 ;
6906 void *argp1 = 0 ;
6907 int res1 = 0 ;
6908 void *argp2 = 0 ;
6909 int res2 = 0 ;
6910 PyObject * obj0 = 0 ;
6911 PyObject * obj1 = 0 ;
6912 char * kwnames[] = {
6913 (char *) "self",(char *) "bmp", NULL
6914 };
6915
6916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
6917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
6918 if (!SWIG_IsOK(res1)) {
6919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_CopyFromBitmap" "', expected argument " "1"" of type '" "wxIcon *""'");
6920 }
6921 arg1 = reinterpret_cast< wxIcon * >(argp1);
6922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
6923 if (!SWIG_IsOK(res2)) {
6924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
6925 }
6926 if (!argp2) {
6927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
6928 }
6929 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_Py_Void();
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 PyObject *obj;
6945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6946 SWIG_TypeNewClientData(SWIGTYPE_p_wxIcon, SWIG_NewClientData(obj));
6947 return SWIG_Py_Void();
6948 }
6949
6950 SWIGINTERN PyObject *Icon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6951 return SWIG_Python_InitShadowInstance(args);
6952 }
6953
6954 SWIGINTERN PyObject *_wrap_new_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj = 0;
6956 wxString *arg1 = (wxString *) &wxPyEmptyString ;
6957 int arg2 = (int) 0 ;
6958 wxIconLocation *result = 0 ;
6959 bool temp1 = false ;
6960 int val2 ;
6961 int ecode2 = 0 ;
6962 PyObject * obj0 = 0 ;
6963 PyObject * obj1 = 0 ;
6964 char * kwnames[] = {
6965 (char *) "filename",(char *) "num", NULL
6966 };
6967
6968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) SWIG_fail;
6969 if (obj0) {
6970 {
6971 arg1 = wxString_in_helper(obj0);
6972 if (arg1 == NULL) SWIG_fail;
6973 temp1 = true;
6974 }
6975 }
6976 if (obj1) {
6977 ecode2 = SWIG_AsVal_int(obj1, &val2);
6978 if (!SWIG_IsOK(ecode2)) {
6979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconLocation" "', expected argument " "2"" of type '" "int""'");
6980 }
6981 arg2 = static_cast< int >(val2);
6982 }
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconLocation, SWIG_POINTER_NEW | 0 );
6990 {
6991 if (temp1)
6992 delete arg1;
6993 }
6994 return resultobj;
6995 fail:
6996 {
6997 if (temp1)
6998 delete arg1;
6999 }
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_delete_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *resultobj = 0;
7006 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7007 void *argp1 = 0 ;
7008 int res1 = 0 ;
7009 PyObject *swig_obj[1] ;
7010
7011 if (!args) SWIG_fail;
7012 swig_obj[0] = args;
7013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, SWIG_POINTER_DISOWN | 0 );
7014 if (!SWIG_IsOK(res1)) {
7015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconLocation" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7016 }
7017 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7018 {
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 delete arg1;
7021
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_Py_Void();
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 SWIGINTERN PyObject *_wrap_IconLocation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7033 PyObject *resultobj = 0;
7034 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7035 bool result;
7036 void *argp1 = 0 ;
7037 int res1 = 0 ;
7038 PyObject *swig_obj[1] ;
7039
7040 if (!args) SWIG_fail;
7041 swig_obj[0] = args;
7042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7043 if (!SWIG_IsOK(res1)) {
7044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_IsOk" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
7045 }
7046 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7047 {
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (bool)((wxIconLocation const *)arg1)->IsOk();
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 {
7054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7055 }
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_IconLocation_SetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj = 0;
7064 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7065 wxString *arg2 = 0 ;
7066 void *argp1 = 0 ;
7067 int res1 = 0 ;
7068 bool temp2 = false ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "self",(char *) "filename", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) SWIG_fail;
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetFileName" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7079 }
7080 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7081 {
7082 arg2 = wxString_in_helper(obj1);
7083 if (arg2 == NULL) SWIG_fail;
7084 temp2 = true;
7085 }
7086 {
7087 PyThreadState* __tstate = wxPyBeginAllowThreads();
7088 (arg1)->SetFileName((wxString const &)*arg2);
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_Py_Void();
7093 {
7094 if (temp2)
7095 delete arg2;
7096 }
7097 return resultobj;
7098 fail:
7099 {
7100 if (temp2)
7101 delete arg2;
7102 }
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_IconLocation_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7108 PyObject *resultobj = 0;
7109 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7110 wxString *result = 0 ;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 PyObject *swig_obj[1] ;
7114
7115 if (!args) SWIG_fail;
7116 swig_obj[0] = args;
7117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetFileName" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
7120 }
7121 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 {
7125 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
7126 result = (wxString *) &_result_ref;
7127 }
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 #if wxUSE_UNICODE
7133 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
7134 #else
7135 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
7136 #endif
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_IconLocation_SetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj = 0;
7146 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7147 int arg2 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "self",(char *) "num", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) SWIG_fail;
7159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7162 }
7163 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7164 ecode2 = SWIG_AsVal_int(obj1, &val2);
7165 if (!SWIG_IsOK(ecode2)) {
7166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IconLocation_SetIndex" "', expected argument " "2"" of type '" "int""'");
7167 }
7168 arg2 = static_cast< int >(val2);
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 wxIconLocation_SetIndex(arg1,arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_Py_Void();
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_IconLocation_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7183 PyObject *resultobj = 0;
7184 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
7185 int result;
7186 void *argp1 = 0 ;
7187 int res1 = 0 ;
7188 PyObject *swig_obj[1] ;
7189
7190 if (!args) SWIG_fail;
7191 swig_obj[0] = args;
7192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
7193 if (!SWIG_IsOK(res1)) {
7194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
7195 }
7196 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
7197 {
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 result = (int)wxIconLocation_GetIndex(arg1);
7200 wxPyEndAllowThreads(__tstate);
7201 if (PyErr_Occurred()) SWIG_fail;
7202 }
7203 resultobj = SWIG_From_int(static_cast< int >(result));
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 SWIGINTERN PyObject *IconLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7211 PyObject *obj;
7212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7213 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconLocation, SWIG_NewClientData(obj));
7214 return SWIG_Py_Void();
7215 }
7216
7217 SWIGINTERN PyObject *IconLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7218 return SWIG_Python_InitShadowInstance(args);
7219 }
7220
7221 SWIGINTERN PyObject *_wrap_new_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7222 PyObject *resultobj = 0;
7223 wxIconBundle *result = 0 ;
7224
7225 if (!SWIG_Python_UnpackTuple(args,"new_IconBundle",0,0,0)) SWIG_fail;
7226 {
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 result = (wxIconBundle *)new wxIconBundle();
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_NEW | 0 );
7233 return resultobj;
7234 fail:
7235 return NULL;
7236 }
7237
7238
7239 SWIGINTERN PyObject *_wrap_new_IconBundleFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7240 PyObject *resultobj = 0;
7241 wxString *arg1 = 0 ;
7242 long arg2 ;
7243 wxIconBundle *result = 0 ;
7244 bool temp1 = false ;
7245 long val2 ;
7246 int ecode2 = 0 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "file",(char *) "type", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) SWIG_fail;
7254 {
7255 arg1 = wxString_in_helper(obj0);
7256 if (arg1 == NULL) SWIG_fail;
7257 temp1 = true;
7258 }
7259 ecode2 = SWIG_AsVal_long(obj1, &val2);
7260 if (!SWIG_IsOK(ecode2)) {
7261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconBundleFromFile" "', expected argument " "2"" of type '" "long""'");
7262 }
7263 arg2 = static_cast< long >(val2);
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
7271 {
7272 if (temp1)
7273 delete arg1;
7274 }
7275 return resultobj;
7276 fail:
7277 {
7278 if (temp1)
7279 delete arg1;
7280 }
7281 return NULL;
7282 }
7283
7284
7285 SWIGINTERN PyObject *_wrap_new_IconBundleFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7286 PyObject *resultobj = 0;
7287 wxIcon *arg1 = 0 ;
7288 wxIconBundle *result = 0 ;
7289 void *argp1 = 0 ;
7290 int res1 = 0 ;
7291 PyObject * obj0 = 0 ;
7292 char * kwnames[] = {
7293 (char *) "icon", NULL
7294 };
7295
7296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) SWIG_fail;
7297 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
7298 if (!SWIG_IsOK(res1)) {
7299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
7300 }
7301 if (!argp1) {
7302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
7303 }
7304 arg1 = reinterpret_cast< wxIcon * >(argp1);
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 SWIGINTERN PyObject *_wrap_delete_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7319 PyObject *resultobj = 0;
7320 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 PyObject *swig_obj[1] ;
7324
7325 if (!args) SWIG_fail;
7326 swig_obj[0] = args;
7327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconBundle, SWIG_POINTER_DISOWN | 0 );
7328 if (!SWIG_IsOK(res1)) {
7329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconBundle" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7330 }
7331 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7332 {
7333 PyThreadState* __tstate = wxPyBeginAllowThreads();
7334 delete arg1;
7335
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_Py_Void();
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_IconBundle_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj = 0;
7348 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7349 wxIcon *arg2 = 0 ;
7350 void *argp1 = 0 ;
7351 int res1 = 0 ;
7352 void *argp2 = 0 ;
7353 int res2 = 0 ;
7354 PyObject * obj0 = 0 ;
7355 PyObject * obj1 = 0 ;
7356 char * kwnames[] = {
7357 (char *) "self",(char *) "icon", NULL
7358 };
7359
7360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
7361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIcon" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7364 }
7365 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
7367 if (!SWIG_IsOK(res2)) {
7368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
7369 }
7370 if (!argp2) {
7371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
7372 }
7373 arg2 = reinterpret_cast< wxIcon * >(argp2);
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 (arg1)->AddIcon((wxIcon const &)*arg2);
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_Py_Void();
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7390 wxString *arg2 = 0 ;
7391 long arg3 ;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 bool temp2 = false ;
7395 long val3 ;
7396 int ecode3 = 0 ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 PyObject * obj2 = 0 ;
7400 char * kwnames[] = {
7401 (char *) "self",(char *) "file",(char *) "type", NULL
7402 };
7403
7404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7406 if (!SWIG_IsOK(res1)) {
7407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "1"" of type '" "wxIconBundle *""'");
7408 }
7409 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7410 {
7411 arg2 = wxString_in_helper(obj1);
7412 if (arg2 == NULL) SWIG_fail;
7413 temp2 = true;
7414 }
7415 ecode3 = SWIG_AsVal_long(obj2, &val3);
7416 if (!SWIG_IsOK(ecode3)) {
7417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "3"" of type '" "long""'");
7418 }
7419 arg3 = static_cast< long >(val3);
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->AddIcon((wxString const &)*arg2,arg3);
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 resultobj = SWIG_Py_Void();
7427 {
7428 if (temp2)
7429 delete arg2;
7430 }
7431 return resultobj;
7432 fail:
7433 {
7434 if (temp2)
7435 delete arg2;
7436 }
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_IconBundle_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
7444 wxSize *arg2 = 0 ;
7445 wxIcon *result = 0 ;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 wxSize temp2 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "size", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_GetIcon" "', expected argument " "1"" of type '" "wxIconBundle const *""'");
7459 }
7460 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
7461 {
7462 arg2 = &temp2;
7463 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7464 }
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 {
7468 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
7469 result = (wxIcon *) &_result_ref;
7470 }
7471 wxPyEndAllowThreads(__tstate);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 {
7475 wxIcon* resultptr = new wxIcon(*result);
7476 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
7477 }
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *IconBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7485 PyObject *obj;
7486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7487 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconBundle, SWIG_NewClientData(obj));
7488 return SWIG_Py_Void();
7489 }
7490
7491 SWIGINTERN PyObject *IconBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7492 return SWIG_Python_InitShadowInstance(args);
7493 }
7494
7495 SWIGINTERN PyObject *_wrap_new_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj = 0;
7497 wxString *arg1 = 0 ;
7498 long arg2 ;
7499 int arg3 = (int) 0 ;
7500 int arg4 = (int) 0 ;
7501 wxCursor *result = 0 ;
7502 bool temp1 = false ;
7503 long val2 ;
7504 int ecode2 = 0 ;
7505 int val3 ;
7506 int ecode3 = 0 ;
7507 int val4 ;
7508 int ecode4 = 0 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 PyObject * obj2 = 0 ;
7512 PyObject * obj3 = 0 ;
7513 char * kwnames[] = {
7514 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
7515 };
7516
7517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7518 {
7519 arg1 = wxString_in_helper(obj0);
7520 if (arg1 == NULL) SWIG_fail;
7521 temp1 = true;
7522 }
7523 ecode2 = SWIG_AsVal_long(obj1, &val2);
7524 if (!SWIG_IsOK(ecode2)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cursor" "', expected argument " "2"" of type '" "long""'");
7526 }
7527 arg2 = static_cast< long >(val2);
7528 if (obj2) {
7529 ecode3 = SWIG_AsVal_int(obj2, &val3);
7530 if (!SWIG_IsOK(ecode3)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cursor" "', expected argument " "3"" of type '" "int""'");
7532 }
7533 arg3 = static_cast< int >(val3);
7534 }
7535 if (obj3) {
7536 ecode4 = SWIG_AsVal_int(obj3, &val4);
7537 if (!SWIG_IsOK(ecode4)) {
7538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cursor" "', expected argument " "4"" of type '" "int""'");
7539 }
7540 arg4 = static_cast< int >(val4);
7541 }
7542 {
7543 if (!wxPyCheckForApp()) SWIG_fail;
7544 PyThreadState* __tstate = wxPyBeginAllowThreads();
7545 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
7546 wxPyEndAllowThreads(__tstate);
7547 if (PyErr_Occurred()) SWIG_fail;
7548 }
7549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_NEW | 0 );
7550 {
7551 if (temp1)
7552 delete arg1;
7553 }
7554 return resultobj;
7555 fail:
7556 {
7557 if (temp1)
7558 delete arg1;
7559 }
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_delete_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7565 PyObject *resultobj = 0;
7566 wxCursor *arg1 = (wxCursor *) 0 ;
7567 void *argp1 = 0 ;
7568 int res1 = 0 ;
7569 PyObject *swig_obj[1] ;
7570
7571 if (!args) SWIG_fail;
7572 swig_obj[0] = args;
7573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, SWIG_POINTER_DISOWN | 0 );
7574 if (!SWIG_IsOK(res1)) {
7575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7576 }
7577 arg1 = reinterpret_cast< wxCursor * >(argp1);
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 delete arg1;
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_Py_Void();
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_new_StockCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 int arg1 ;
7595 wxCursor *result = 0 ;
7596 int val1 ;
7597 int ecode1 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 char * kwnames[] = {
7600 (char *) "id", NULL
7601 };
7602
7603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) SWIG_fail;
7604 ecode1 = SWIG_AsVal_int(obj0, &val1);
7605 if (!SWIG_IsOK(ecode1)) {
7606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StockCursor" "', expected argument " "1"" of type '" "int""'");
7607 }
7608 arg1 = static_cast< int >(val1);
7609 {
7610 if (!wxPyCheckForApp()) SWIG_fail;
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 result = (wxCursor *)new wxCursor(arg1);
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_new_CursorFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = 0;
7625 wxImage *arg1 = 0 ;
7626 wxCursor *result = 0 ;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 PyObject * obj0 = 0 ;
7630 char * kwnames[] = {
7631 (char *) "image", NULL
7632 };
7633
7634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) SWIG_fail;
7635 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
7636 if (!SWIG_IsOK(res1)) {
7637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
7638 }
7639 if (!argp1) {
7640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
7641 }
7642 arg1 = reinterpret_cast< wxImage * >(argp1);
7643 {
7644 if (!wxPyCheckForApp()) SWIG_fail;
7645 PyThreadState* __tstate = wxPyBeginAllowThreads();
7646 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
7647 wxPyEndAllowThreads(__tstate);
7648 if (PyErr_Occurred()) SWIG_fail;
7649 }
7650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 SWIGINTERN PyObject *_wrap_Cursor_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7658 PyObject *resultobj = 0;
7659 wxCursor *arg1 = (wxCursor *) 0 ;
7660 bool result;
7661 void *argp1 = 0 ;
7662 int res1 = 0 ;
7663 PyObject *swig_obj[1] ;
7664
7665 if (!args) SWIG_fail;
7666 swig_obj[0] = args;
7667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7668 if (!SWIG_IsOK(res1)) {
7669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_Ok" "', expected argument " "1"" of type '" "wxCursor *""'");
7670 }
7671 arg1 = reinterpret_cast< wxCursor * >(argp1);
7672 {
7673 PyThreadState* __tstate = wxPyBeginAllowThreads();
7674 result = (bool)(arg1)->Ok();
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 SWIGINTERN PyObject *Cursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7688 PyObject *obj;
7689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7690 SWIG_TypeNewClientData(SWIGTYPE_p_wxCursor, SWIG_NewClientData(obj));
7691 return SWIG_Py_Void();
7692 }
7693
7694 SWIGINTERN PyObject *Cursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7695 return SWIG_Python_InitShadowInstance(args);
7696 }
7697
7698 SWIGINTERN PyObject *_wrap_new_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7699 PyObject *resultobj = 0;
7700 int arg1 = (int) 0 ;
7701 int arg2 = (int) 0 ;
7702 int arg3 = (int) 0 ;
7703 int arg4 = (int) 0 ;
7704 wxRegion *result = 0 ;
7705 int val1 ;
7706 int ecode1 = 0 ;
7707 int val2 ;
7708 int ecode2 = 0 ;
7709 int val3 ;
7710 int ecode3 = 0 ;
7711 int val4 ;
7712 int ecode4 = 0 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 PyObject * obj2 = 0 ;
7716 PyObject * obj3 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7722 if (obj0) {
7723 ecode1 = SWIG_AsVal_int(obj0, &val1);
7724 if (!SWIG_IsOK(ecode1)) {
7725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Region" "', expected argument " "1"" of type '" "int""'");
7726 }
7727 arg1 = static_cast< int >(val1);
7728 }
7729 if (obj1) {
7730 ecode2 = SWIG_AsVal_int(obj1, &val2);
7731 if (!SWIG_IsOK(ecode2)) {
7732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Region" "', expected argument " "2"" of type '" "int""'");
7733 }
7734 arg2 = static_cast< int >(val2);
7735 }
7736 if (obj2) {
7737 ecode3 = SWIG_AsVal_int(obj2, &val3);
7738 if (!SWIG_IsOK(ecode3)) {
7739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Region" "', expected argument " "3"" of type '" "int""'");
7740 }
7741 arg3 = static_cast< int >(val3);
7742 }
7743 if (obj3) {
7744 ecode4 = SWIG_AsVal_int(obj3, &val4);
7745 if (!SWIG_IsOK(ecode4)) {
7746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Region" "', expected argument " "4"" of type '" "int""'");
7747 }
7748 arg4 = static_cast< int >(val4);
7749 }
7750 {
7751 if (!wxPyCheckForApp()) SWIG_fail;
7752 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_NEW | 0 );
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_new_RegionFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxBitmap *arg1 = 0 ;
7767 wxRegion *result = 0 ;
7768 void *argp1 = 0 ;
7769 int res1 = 0 ;
7770 PyObject * obj0 = 0 ;
7771 char * kwnames[] = {
7772 (char *) "bmp", NULL
7773 };
7774
7775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) SWIG_fail;
7776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
7777 if (!SWIG_IsOK(res1)) {
7778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7779 }
7780 if (!argp1) {
7781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7782 }
7783 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7784 {
7785 if (!wxPyCheckForApp()) SWIG_fail;
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_new_RegionFromBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7799 PyObject *resultobj = 0;
7800 wxBitmap *arg1 = 0 ;
7801 wxColour *arg2 = 0 ;
7802 int arg3 = (int) 0 ;
7803 wxRegion *result = 0 ;
7804 void *argp1 = 0 ;
7805 int res1 = 0 ;
7806 wxColour temp2 ;
7807 int val3 ;
7808 int ecode3 = 0 ;
7809 PyObject * obj0 = 0 ;
7810 PyObject * obj1 = 0 ;
7811 PyObject * obj2 = 0 ;
7812 char * kwnames[] = {
7813 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7814 };
7815
7816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7817 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
7818 if (!SWIG_IsOK(res1)) {
7819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7820 }
7821 if (!argp1) {
7822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
7823 }
7824 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7825 {
7826 arg2 = &temp2;
7827 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
7828 }
7829 if (obj2) {
7830 ecode3 = SWIG_AsVal_int(obj2, &val3);
7831 if (!SWIG_IsOK(ecode3)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromBitmapColour" "', expected argument " "3"" of type '" "int""'");
7833 }
7834 arg3 = static_cast< int >(val3);
7835 }
7836 {
7837 if (!wxPyCheckForApp()) SWIG_fail;
7838 PyThreadState* __tstate = wxPyBeginAllowThreads();
7839 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 SWIGINTERN PyObject *_wrap_new_RegionFromPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = 0;
7852 int arg1 ;
7853 wxPoint *arg2 = (wxPoint *) 0 ;
7854 int arg3 = (int) wxWINDING_RULE ;
7855 wxRegion *result = 0 ;
7856 int val3 ;
7857 int ecode3 = 0 ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 char * kwnames[] = {
7861 (char *) "points",(char *) "fillStyle", NULL
7862 };
7863
7864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) SWIG_fail;
7865 {
7866 arg2 = wxPoint_LIST_helper(obj0, &arg1);
7867 if (arg2 == NULL) SWIG_fail;
7868 }
7869 if (obj1) {
7870 ecode3 = SWIG_AsVal_int(obj1, &val3);
7871 if (!SWIG_IsOK(ecode3)) {
7872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromPoints" "', expected argument " "3"" of type '" "int""'");
7873 }
7874 arg3 = static_cast< int >(val3);
7875 }
7876 {
7877 if (!wxPyCheckForApp()) SWIG_fail;
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
7884 {
7885 if (arg2) delete [] arg2;
7886 }
7887 return resultobj;
7888 fail:
7889 {
7890 if (arg2) delete [] arg2;
7891 }
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_delete_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *resultobj = 0;
7898 wxRegion *arg1 = (wxRegion *) 0 ;
7899 void *argp1 = 0 ;
7900 int res1 = 0 ;
7901 PyObject *swig_obj[1] ;
7902
7903 if (!args) SWIG_fail;
7904 swig_obj[0] = args;
7905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, SWIG_POINTER_DISOWN | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', expected argument " "1"" of type '" "wxRegion *""'");
7908 }
7909 arg1 = reinterpret_cast< wxRegion * >(argp1);
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 delete arg1;
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 resultobj = SWIG_Py_Void();
7918 return resultobj;
7919 fail:
7920 return NULL;
7921 }
7922
7923
7924 SWIGINTERN PyObject *_wrap_Region_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925 PyObject *resultobj = 0;
7926 wxRegion *arg1 = (wxRegion *) 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 PyObject *swig_obj[1] ;
7930
7931 if (!args) SWIG_fail;
7932 swig_obj[0] = args;
7933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
7934 if (!SWIG_IsOK(res1)) {
7935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Clear" "', expected argument " "1"" of type '" "wxRegion *""'");
7936 }
7937 arg1 = reinterpret_cast< wxRegion * >(argp1);
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 (arg1)->Clear();
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 resultobj = SWIG_Py_Void();
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_Region_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7952 PyObject *resultobj = 0;
7953 wxRegion *arg1 = (wxRegion *) 0 ;
7954 int arg2 ;
7955 int arg3 ;
7956 bool result;
7957 void *argp1 = 0 ;
7958 int res1 = 0 ;
7959 int val2 ;
7960 int ecode2 = 0 ;
7961 int val3 ;
7962 int ecode3 = 0 ;
7963 PyObject * obj0 = 0 ;
7964 PyObject * obj1 = 0 ;
7965 PyObject * obj2 = 0 ;
7966 char * kwnames[] = {
7967 (char *) "self",(char *) "x",(char *) "y", NULL
7968 };
7969
7970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
7972 if (!SWIG_IsOK(res1)) {
7973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Offset" "', expected argument " "1"" of type '" "wxRegion *""'");
7974 }
7975 arg1 = reinterpret_cast< wxRegion * >(argp1);
7976 ecode2 = SWIG_AsVal_int(obj1, &val2);
7977 if (!SWIG_IsOK(ecode2)) {
7978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Offset" "', expected argument " "2"" of type '" "int""'");
7979 }
7980 arg2 = static_cast< int >(val2);
7981 ecode3 = SWIG_AsVal_int(obj2, &val3);
7982 if (!SWIG_IsOK(ecode3)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Offset" "', expected argument " "3"" of type '" "int""'");
7984 }
7985 arg3 = static_cast< int >(val3);
7986 {
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 result = (bool)(arg1)->Offset(arg2,arg3);
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 {
7993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7994 }
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 SWIGINTERN PyObject *_wrap_Region_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj = 0;
8003 wxRegion *arg1 = (wxRegion *) 0 ;
8004 int arg2 ;
8005 int arg3 ;
8006 wxRegionContain result;
8007 void *argp1 = 0 ;
8008 int res1 = 0 ;
8009 int val2 ;
8010 int ecode2 = 0 ;
8011 int val3 ;
8012 int ecode3 = 0 ;
8013 PyObject * obj0 = 0 ;
8014 PyObject * obj1 = 0 ;
8015 PyObject * obj2 = 0 ;
8016 char * kwnames[] = {
8017 (char *) "self",(char *) "x",(char *) "y", NULL
8018 };
8019
8020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8022 if (!SWIG_IsOK(res1)) {
8023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Contains" "', expected argument " "1"" of type '" "wxRegion *""'");
8024 }
8025 arg1 = reinterpret_cast< wxRegion * >(argp1);
8026 ecode2 = SWIG_AsVal_int(obj1, &val2);
8027 if (!SWIG_IsOK(ecode2)) {
8028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Contains" "', expected argument " "2"" of type '" "int""'");
8029 }
8030 arg2 = static_cast< int >(val2);
8031 ecode3 = SWIG_AsVal_int(obj2, &val3);
8032 if (!SWIG_IsOK(ecode3)) {
8033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Contains" "', expected argument " "3"" of type '" "int""'");
8034 }
8035 arg3 = static_cast< int >(val3);
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 resultobj = SWIG_From_int(static_cast< int >(result));
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 SWIGINTERN PyObject *_wrap_Region_ContainsPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj = 0;
8051 wxRegion *arg1 = (wxRegion *) 0 ;
8052 wxPoint *arg2 = 0 ;
8053 wxRegionContain result;
8054 void *argp1 = 0 ;
8055 int res1 = 0 ;
8056 wxPoint temp2 ;
8057 PyObject * obj0 = 0 ;
8058 PyObject * obj1 = 0 ;
8059 char * kwnames[] = {
8060 (char *) "self",(char *) "pt", NULL
8061 };
8062
8063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) SWIG_fail;
8064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8065 if (!SWIG_IsOK(res1)) {
8066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsPoint" "', expected argument " "1"" of type '" "wxRegion *""'");
8067 }
8068 arg1 = reinterpret_cast< wxRegion * >(argp1);
8069 {
8070 arg2 = &temp2;
8071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8072 }
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 resultobj = SWIG_From_int(static_cast< int >(result));
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_Region_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj = 0;
8088 wxRegion *arg1 = (wxRegion *) 0 ;
8089 wxRect *arg2 = 0 ;
8090 wxRegionContain result;
8091 void *argp1 = 0 ;
8092 int res1 = 0 ;
8093 wxRect temp2 ;
8094 PyObject * obj0 = 0 ;
8095 PyObject * obj1 = 0 ;
8096 char * kwnames[] = {
8097 (char *) "self",(char *) "rect", NULL
8098 };
8099
8100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
8101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8104 }
8105 arg1 = reinterpret_cast< wxRegion * >(argp1);
8106 {
8107 arg2 = &temp2;
8108 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8109 }
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
8113 wxPyEndAllowThreads(__tstate);
8114 if (PyErr_Occurred()) SWIG_fail;
8115 }
8116 resultobj = SWIG_From_int(static_cast< int >(result));
8117 return resultobj;
8118 fail:
8119 return NULL;
8120 }
8121
8122
8123 SWIGINTERN PyObject *_wrap_Region_ContainsRectDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8124 PyObject *resultobj = 0;
8125 wxRegion *arg1 = (wxRegion *) 0 ;
8126 int arg2 ;
8127 int arg3 ;
8128 int arg4 ;
8129 int arg5 ;
8130 wxRegionContain result;
8131 void *argp1 = 0 ;
8132 int res1 = 0 ;
8133 int val2 ;
8134 int ecode2 = 0 ;
8135 int val3 ;
8136 int ecode3 = 0 ;
8137 int val4 ;
8138 int ecode4 = 0 ;
8139 int val5 ;
8140 int ecode5 = 0 ;
8141 PyObject * obj0 = 0 ;
8142 PyObject * obj1 = 0 ;
8143 PyObject * obj2 = 0 ;
8144 PyObject * obj3 = 0 ;
8145 PyObject * obj4 = 0 ;
8146 char * kwnames[] = {
8147 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
8148 };
8149
8150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8152 if (!SWIG_IsOK(res1)) {
8153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRectDim" "', expected argument " "1"" of type '" "wxRegion *""'");
8154 }
8155 arg1 = reinterpret_cast< wxRegion * >(argp1);
8156 ecode2 = SWIG_AsVal_int(obj1, &val2);
8157 if (!SWIG_IsOK(ecode2)) {
8158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_ContainsRectDim" "', expected argument " "2"" of type '" "int""'");
8159 }
8160 arg2 = static_cast< int >(val2);
8161 ecode3 = SWIG_AsVal_int(obj2, &val3);
8162 if (!SWIG_IsOK(ecode3)) {
8163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_ContainsRectDim" "', expected argument " "3"" of type '" "int""'");
8164 }
8165 arg3 = static_cast< int >(val3);
8166 ecode4 = SWIG_AsVal_int(obj3, &val4);
8167 if (!SWIG_IsOK(ecode4)) {
8168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_ContainsRectDim" "', expected argument " "4"" of type '" "int""'");
8169 }
8170 arg4 = static_cast< int >(val4);
8171 ecode5 = SWIG_AsVal_int(obj4, &val5);
8172 if (!SWIG_IsOK(ecode5)) {
8173 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_ContainsRectDim" "', expected argument " "5"" of type '" "int""'");
8174 }
8175 arg5 = static_cast< int >(val5);
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 resultobj = SWIG_From_int(static_cast< int >(result));
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 SWIGINTERN PyObject *_wrap_Region_GetBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8190 PyObject *resultobj = 0;
8191 wxRegion *arg1 = (wxRegion *) 0 ;
8192 wxRect result;
8193 void *argp1 = 0 ;
8194 int res1 = 0 ;
8195 PyObject *swig_obj[1] ;
8196
8197 if (!args) SWIG_fail;
8198 swig_obj[0] = args;
8199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8200 if (!SWIG_IsOK(res1)) {
8201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_GetBox" "', expected argument " "1"" of type '" "wxRegion *""'");
8202 }
8203 arg1 = reinterpret_cast< wxRegion * >(argp1);
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 result = (arg1)->GetBox();
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_Region_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj = 0;
8219 wxRegion *arg1 = (wxRegion *) 0 ;
8220 int arg2 ;
8221 int arg3 ;
8222 int arg4 ;
8223 int arg5 ;
8224 bool result;
8225 void *argp1 = 0 ;
8226 int res1 = 0 ;
8227 int val2 ;
8228 int ecode2 = 0 ;
8229 int val3 ;
8230 int ecode3 = 0 ;
8231 int val4 ;
8232 int ecode4 = 0 ;
8233 int val5 ;
8234 int ecode5 = 0 ;
8235 PyObject * obj0 = 0 ;
8236 PyObject * obj1 = 0 ;
8237 PyObject * obj2 = 0 ;
8238 PyObject * obj3 = 0 ;
8239 PyObject * obj4 = 0 ;
8240 char * kwnames[] = {
8241 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8242 };
8243
8244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Intersect" "', expected argument " "1"" of type '" "wxRegion *""'");
8248 }
8249 arg1 = reinterpret_cast< wxRegion * >(argp1);
8250 ecode2 = SWIG_AsVal_int(obj1, &val2);
8251 if (!SWIG_IsOK(ecode2)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Intersect" "', expected argument " "2"" of type '" "int""'");
8253 }
8254 arg2 = static_cast< int >(val2);
8255 ecode3 = SWIG_AsVal_int(obj2, &val3);
8256 if (!SWIG_IsOK(ecode3)) {
8257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Intersect" "', expected argument " "3"" of type '" "int""'");
8258 }
8259 arg3 = static_cast< int >(val3);
8260 ecode4 = SWIG_AsVal_int(obj3, &val4);
8261 if (!SWIG_IsOK(ecode4)) {
8262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Intersect" "', expected argument " "4"" of type '" "int""'");
8263 }
8264 arg4 = static_cast< int >(val4);
8265 ecode5 = SWIG_AsVal_int(obj4, &val5);
8266 if (!SWIG_IsOK(ecode5)) {
8267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Intersect" "', expected argument " "5"" of type '" "int""'");
8268 }
8269 arg5 = static_cast< int >(val5);
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
8273 wxPyEndAllowThreads(__tstate);
8274 if (PyErr_Occurred()) SWIG_fail;
8275 }
8276 {
8277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8278 }
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 SWIGINTERN PyObject *_wrap_Region_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj = 0;
8287 wxRegion *arg1 = (wxRegion *) 0 ;
8288 wxRect *arg2 = 0 ;
8289 bool result;
8290 void *argp1 = 0 ;
8291 int res1 = 0 ;
8292 wxRect temp2 ;
8293 PyObject * obj0 = 0 ;
8294 PyObject * obj1 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "self",(char *) "rect", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8301 if (!SWIG_IsOK(res1)) {
8302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8303 }
8304 arg1 = reinterpret_cast< wxRegion * >(argp1);
8305 {
8306 arg2 = &temp2;
8307 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8308 }
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 {
8316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8317 }
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Region_IntersectRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxRegion *arg1 = (wxRegion *) 0 ;
8327 wxRegion *arg2 = 0 ;
8328 bool result;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 void *argp2 = 0 ;
8332 int res2 = 0 ;
8333 PyObject * obj0 = 0 ;
8334 PyObject * obj1 = 0 ;
8335 char * kwnames[] = {
8336 (char *) "self",(char *) "region", NULL
8337 };
8338
8339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8343 }
8344 arg1 = reinterpret_cast< wxRegion * >(argp1);
8345 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8346 if (!SWIG_IsOK(res2)) {
8347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8348 }
8349 if (!argp2) {
8350 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8351 }
8352 arg2 = reinterpret_cast< wxRegion * >(argp2);
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 {
8360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8361 }
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_Region_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 PyObject *resultobj = 0;
8370 wxRegion *arg1 = (wxRegion *) 0 ;
8371 bool result;
8372 void *argp1 = 0 ;
8373 int res1 = 0 ;
8374 PyObject *swig_obj[1] ;
8375
8376 if (!args) SWIG_fail;
8377 swig_obj[0] = args;
8378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8379 if (!SWIG_IsOK(res1)) {
8380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IsEmpty" "', expected argument " "1"" of type '" "wxRegion *""'");
8381 }
8382 arg1 = reinterpret_cast< wxRegion * >(argp1);
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (bool)(arg1)->IsEmpty();
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 {
8390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Region_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxRegion *arg1 = (wxRegion *) 0 ;
8401 int arg2 ;
8402 int arg3 ;
8403 int arg4 ;
8404 int arg5 ;
8405 bool result;
8406 void *argp1 = 0 ;
8407 int res1 = 0 ;
8408 int val2 ;
8409 int ecode2 = 0 ;
8410 int val3 ;
8411 int ecode3 = 0 ;
8412 int val4 ;
8413 int ecode4 = 0 ;
8414 int val5 ;
8415 int ecode5 = 0 ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 PyObject * obj3 = 0 ;
8420 PyObject * obj4 = 0 ;
8421 char * kwnames[] = {
8422 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8423 };
8424
8425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Union" "', expected argument " "1"" of type '" "wxRegion *""'");
8429 }
8430 arg1 = reinterpret_cast< wxRegion * >(argp1);
8431 ecode2 = SWIG_AsVal_int(obj1, &val2);
8432 if (!SWIG_IsOK(ecode2)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Union" "', expected argument " "2"" of type '" "int""'");
8434 }
8435 arg2 = static_cast< int >(val2);
8436 ecode3 = SWIG_AsVal_int(obj2, &val3);
8437 if (!SWIG_IsOK(ecode3)) {
8438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Union" "', expected argument " "3"" of type '" "int""'");
8439 }
8440 arg3 = static_cast< int >(val3);
8441 ecode4 = SWIG_AsVal_int(obj3, &val4);
8442 if (!SWIG_IsOK(ecode4)) {
8443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Union" "', expected argument " "4"" of type '" "int""'");
8444 }
8445 arg4 = static_cast< int >(val4);
8446 ecode5 = SWIG_AsVal_int(obj4, &val5);
8447 if (!SWIG_IsOK(ecode5)) {
8448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Union" "', expected argument " "5"" of type '" "int""'");
8449 }
8450 arg5 = static_cast< int >(val5);
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 {
8458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8459 }
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 SWIGINTERN PyObject *_wrap_Region_UnionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8467 PyObject *resultobj = 0;
8468 wxRegion *arg1 = (wxRegion *) 0 ;
8469 wxRect *arg2 = 0 ;
8470 bool result;
8471 void *argp1 = 0 ;
8472 int res1 = 0 ;
8473 wxRect temp2 ;
8474 PyObject * obj0 = 0 ;
8475 PyObject * obj1 = 0 ;
8476 char * kwnames[] = {
8477 (char *) "self",(char *) "rect", NULL
8478 };
8479
8480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) SWIG_fail;
8481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8482 if (!SWIG_IsOK(res1)) {
8483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8484 }
8485 arg1 = reinterpret_cast< wxRegion * >(argp1);
8486 {
8487 arg2 = &temp2;
8488 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8489 }
8490 {
8491 PyThreadState* __tstate = wxPyBeginAllowThreads();
8492 result = (bool)(arg1)->Union((wxRect const &)*arg2);
8493 wxPyEndAllowThreads(__tstate);
8494 if (PyErr_Occurred()) SWIG_fail;
8495 }
8496 {
8497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8498 }
8499 return resultobj;
8500 fail:
8501 return NULL;
8502 }
8503
8504
8505 SWIGINTERN PyObject *_wrap_Region_UnionRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8506 PyObject *resultobj = 0;
8507 wxRegion *arg1 = (wxRegion *) 0 ;
8508 wxRegion *arg2 = 0 ;
8509 bool result;
8510 void *argp1 = 0 ;
8511 int res1 = 0 ;
8512 void *argp2 = 0 ;
8513 int res2 = 0 ;
8514 PyObject * obj0 = 0 ;
8515 PyObject * obj1 = 0 ;
8516 char * kwnames[] = {
8517 (char *) "self",(char *) "region", NULL
8518 };
8519
8520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8522 if (!SWIG_IsOK(res1)) {
8523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8524 }
8525 arg1 = reinterpret_cast< wxRegion * >(argp1);
8526 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8527 if (!SWIG_IsOK(res2)) {
8528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8529 }
8530 if (!argp2) {
8531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8532 }
8533 arg2 = reinterpret_cast< wxRegion * >(argp2);
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 {
8541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8542 }
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 SWIGINTERN PyObject *_wrap_Region_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj = 0;
8551 wxRegion *arg1 = (wxRegion *) 0 ;
8552 int arg2 ;
8553 int arg3 ;
8554 int arg4 ;
8555 int arg5 ;
8556 bool result;
8557 void *argp1 = 0 ;
8558 int res1 = 0 ;
8559 int val2 ;
8560 int ecode2 = 0 ;
8561 int val3 ;
8562 int ecode3 = 0 ;
8563 int val4 ;
8564 int ecode4 = 0 ;
8565 int val5 ;
8566 int ecode5 = 0 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 PyObject * obj2 = 0 ;
8570 PyObject * obj3 = 0 ;
8571 PyObject * obj4 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Subtract" "', expected argument " "1"" of type '" "wxRegion *""'");
8580 }
8581 arg1 = reinterpret_cast< wxRegion * >(argp1);
8582 ecode2 = SWIG_AsVal_int(obj1, &val2);
8583 if (!SWIG_IsOK(ecode2)) {
8584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Subtract" "', expected argument " "2"" of type '" "int""'");
8585 }
8586 arg2 = static_cast< int >(val2);
8587 ecode3 = SWIG_AsVal_int(obj2, &val3);
8588 if (!SWIG_IsOK(ecode3)) {
8589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Subtract" "', expected argument " "3"" of type '" "int""'");
8590 }
8591 arg3 = static_cast< int >(val3);
8592 ecode4 = SWIG_AsVal_int(obj3, &val4);
8593 if (!SWIG_IsOK(ecode4)) {
8594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Subtract" "', expected argument " "4"" of type '" "int""'");
8595 }
8596 arg4 = static_cast< int >(val4);
8597 ecode5 = SWIG_AsVal_int(obj4, &val5);
8598 if (!SWIG_IsOK(ecode5)) {
8599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Subtract" "', expected argument " "5"" of type '" "int""'");
8600 }
8601 arg5 = static_cast< int >(val5);
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 {
8609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8610 }
8611 return resultobj;
8612 fail:
8613 return NULL;
8614 }
8615
8616
8617 SWIGINTERN PyObject *_wrap_Region_SubtractRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8618 PyObject *resultobj = 0;
8619 wxRegion *arg1 = (wxRegion *) 0 ;
8620 wxRect *arg2 = 0 ;
8621 bool result;
8622 void *argp1 = 0 ;
8623 int res1 = 0 ;
8624 wxRect temp2 ;
8625 PyObject * obj0 = 0 ;
8626 PyObject * obj1 = 0 ;
8627 char * kwnames[] = {
8628 (char *) "self",(char *) "rect", NULL
8629 };
8630
8631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) SWIG_fail;
8632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8633 if (!SWIG_IsOK(res1)) {
8634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8635 }
8636 arg1 = reinterpret_cast< wxRegion * >(argp1);
8637 {
8638 arg2 = &temp2;
8639 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8640 }
8641 {
8642 PyThreadState* __tstate = wxPyBeginAllowThreads();
8643 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 {
8648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8649 }
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 SWIGINTERN PyObject *_wrap_Region_SubtractRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj = 0;
8658 wxRegion *arg1 = (wxRegion *) 0 ;
8659 wxRegion *arg2 = 0 ;
8660 bool result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 void *argp2 = 0 ;
8664 int res2 = 0 ;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 char * kwnames[] = {
8668 (char *) "self",(char *) "region", NULL
8669 };
8670
8671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8673 if (!SWIG_IsOK(res1)) {
8674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8675 }
8676 arg1 = reinterpret_cast< wxRegion * >(argp1);
8677 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8678 if (!SWIG_IsOK(res2)) {
8679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8680 }
8681 if (!argp2) {
8682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8683 }
8684 arg2 = reinterpret_cast< wxRegion * >(argp2);
8685 {
8686 PyThreadState* __tstate = wxPyBeginAllowThreads();
8687 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 {
8692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8693 }
8694 return resultobj;
8695 fail:
8696 return NULL;
8697 }
8698
8699
8700 SWIGINTERN PyObject *_wrap_Region_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8701 PyObject *resultobj = 0;
8702 wxRegion *arg1 = (wxRegion *) 0 ;
8703 int arg2 ;
8704 int arg3 ;
8705 int arg4 ;
8706 int arg5 ;
8707 bool result;
8708 void *argp1 = 0 ;
8709 int res1 = 0 ;
8710 int val2 ;
8711 int ecode2 = 0 ;
8712 int val3 ;
8713 int ecode3 = 0 ;
8714 int val4 ;
8715 int ecode4 = 0 ;
8716 int val5 ;
8717 int ecode5 = 0 ;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 PyObject * obj2 = 0 ;
8721 PyObject * obj3 = 0 ;
8722 PyObject * obj4 = 0 ;
8723 char * kwnames[] = {
8724 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8725 };
8726
8727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8729 if (!SWIG_IsOK(res1)) {
8730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Xor" "', expected argument " "1"" of type '" "wxRegion *""'");
8731 }
8732 arg1 = reinterpret_cast< wxRegion * >(argp1);
8733 ecode2 = SWIG_AsVal_int(obj1, &val2);
8734 if (!SWIG_IsOK(ecode2)) {
8735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Xor" "', expected argument " "2"" of type '" "int""'");
8736 }
8737 arg2 = static_cast< int >(val2);
8738 ecode3 = SWIG_AsVal_int(obj2, &val3);
8739 if (!SWIG_IsOK(ecode3)) {
8740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Xor" "', expected argument " "3"" of type '" "int""'");
8741 }
8742 arg3 = static_cast< int >(val3);
8743 ecode4 = SWIG_AsVal_int(obj3, &val4);
8744 if (!SWIG_IsOK(ecode4)) {
8745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Xor" "', expected argument " "4"" of type '" "int""'");
8746 }
8747 arg4 = static_cast< int >(val4);
8748 ecode5 = SWIG_AsVal_int(obj4, &val5);
8749 if (!SWIG_IsOK(ecode5)) {
8750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Xor" "', expected argument " "5"" of type '" "int""'");
8751 }
8752 arg5 = static_cast< int >(val5);
8753 {
8754 PyThreadState* __tstate = wxPyBeginAllowThreads();
8755 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 SWIGINTERN PyObject *_wrap_Region_XorRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj = 0;
8770 wxRegion *arg1 = (wxRegion *) 0 ;
8771 wxRect *arg2 = 0 ;
8772 bool result;
8773 void *argp1 = 0 ;
8774 int res1 = 0 ;
8775 wxRect temp2 ;
8776 PyObject * obj0 = 0 ;
8777 PyObject * obj1 = 0 ;
8778 char * kwnames[] = {
8779 (char *) "self",(char *) "rect", NULL
8780 };
8781
8782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) SWIG_fail;
8783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRect" "', expected argument " "1"" of type '" "wxRegion *""'");
8786 }
8787 arg1 = reinterpret_cast< wxRegion * >(argp1);
8788 {
8789 arg2 = &temp2;
8790 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
8791 }
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 {
8799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8800 }
8801 return resultobj;
8802 fail:
8803 return NULL;
8804 }
8805
8806
8807 SWIGINTERN PyObject *_wrap_Region_XorRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8808 PyObject *resultobj = 0;
8809 wxRegion *arg1 = (wxRegion *) 0 ;
8810 wxRegion *arg2 = 0 ;
8811 bool result;
8812 void *argp1 = 0 ;
8813 int res1 = 0 ;
8814 void *argp2 = 0 ;
8815 int res2 = 0 ;
8816 PyObject * obj0 = 0 ;
8817 PyObject * obj1 = 0 ;
8818 char * kwnames[] = {
8819 (char *) "self",(char *) "region", NULL
8820 };
8821
8822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) SWIG_fail;
8823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8824 if (!SWIG_IsOK(res1)) {
8825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
8826 }
8827 arg1 = reinterpret_cast< wxRegion * >(argp1);
8828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
8829 if (!SWIG_IsOK(res2)) {
8830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8831 }
8832 if (!argp2) {
8833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
8834 }
8835 arg2 = reinterpret_cast< wxRegion * >(argp2);
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
8839 wxPyEndAllowThreads(__tstate);
8840 if (PyErr_Occurred()) SWIG_fail;
8841 }
8842 {
8843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8844 }
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 SWIGINTERN PyObject *_wrap_Region_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8852 PyObject *resultobj = 0;
8853 wxRegion *arg1 = (wxRegion *) 0 ;
8854 SwigValueWrapper<wxBitmap > result;
8855 void *argp1 = 0 ;
8856 int res1 = 0 ;
8857 PyObject *swig_obj[1] ;
8858
8859 if (!args) SWIG_fail;
8860 swig_obj[0] = args;
8861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8862 if (!SWIG_IsOK(res1)) {
8863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ConvertToBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
8864 }
8865 arg1 = reinterpret_cast< wxRegion * >(argp1);
8866 {
8867 PyThreadState* __tstate = wxPyBeginAllowThreads();
8868 result = (arg1)->ConvertToBitmap();
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *_wrap_Region_UnionBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj = 0;
8881 wxRegion *arg1 = (wxRegion *) 0 ;
8882 wxBitmap *arg2 = 0 ;
8883 bool result;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 void *argp2 = 0 ;
8887 int res2 = 0 ;
8888 PyObject * obj0 = 0 ;
8889 PyObject * obj1 = 0 ;
8890 char * kwnames[] = {
8891 (char *) "self",(char *) "bmp", NULL
8892 };
8893
8894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
8895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8896 if (!SWIG_IsOK(res1)) {
8897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
8898 }
8899 arg1 = reinterpret_cast< wxRegion * >(argp1);
8900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
8901 if (!SWIG_IsOK(res2)) {
8902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8903 }
8904 if (!argp2) {
8905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8906 }
8907 arg2 = reinterpret_cast< wxBitmap * >(argp2);
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 {
8915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8916 }
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 SWIGINTERN PyObject *_wrap_Region_UnionBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj = 0;
8925 wxRegion *arg1 = (wxRegion *) 0 ;
8926 wxBitmap *arg2 = 0 ;
8927 wxColour *arg3 = 0 ;
8928 int arg4 = (int) 0 ;
8929 bool result;
8930 void *argp1 = 0 ;
8931 int res1 = 0 ;
8932 void *argp2 = 0 ;
8933 int res2 = 0 ;
8934 wxColour temp3 ;
8935 int val4 ;
8936 int ecode4 = 0 ;
8937 PyObject * obj0 = 0 ;
8938 PyObject * obj1 = 0 ;
8939 PyObject * obj2 = 0 ;
8940 PyObject * obj3 = 0 ;
8941 char * kwnames[] = {
8942 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
8943 };
8944
8945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
8947 if (!SWIG_IsOK(res1)) {
8948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmapColour" "', expected argument " "1"" of type '" "wxRegion *""'");
8949 }
8950 arg1 = reinterpret_cast< wxRegion * >(argp1);
8951 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
8952 if (!SWIG_IsOK(res2)) {
8953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8954 }
8955 if (!argp2) {
8956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
8957 }
8958 arg2 = reinterpret_cast< wxBitmap * >(argp2);
8959 {
8960 arg3 = &temp3;
8961 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
8962 }
8963 if (obj3) {
8964 ecode4 = SWIG_AsVal_int(obj3, &val4);
8965 if (!SWIG_IsOK(ecode4)) {
8966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_UnionBitmapColour" "', expected argument " "4"" of type '" "int""'");
8967 }
8968 arg4 = static_cast< int >(val4);
8969 }
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 {
8977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegion, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Region_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN PyObject *_wrap_new_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj = 0;
8998 wxRegion *arg1 = 0 ;
8999 wxRegionIterator *result = 0 ;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "region", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) SWIG_fail;
9008 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRegion, 0 | 0);
9009 if (!SWIG_IsOK(res1)) {
9010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
9011 }
9012 if (!argp1) {
9013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
9014 }
9015 arg1 = reinterpret_cast< wxRegion * >(argp1);
9016 {
9017 if (!wxPyCheckForApp()) SWIG_fail;
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_NEW | 0 );
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *_wrap_delete_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *resultobj = 0;
9032 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9033 void *argp1 = 0 ;
9034 int res1 = 0 ;
9035 PyObject *swig_obj[1] ;
9036
9037 if (!args) SWIG_fail;
9038 swig_obj[0] = args;
9039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_DISOWN | 0 );
9040 if (!SWIG_IsOK(res1)) {
9041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegionIterator" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9042 }
9043 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 delete arg1;
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = SWIG_Py_Void();
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *_wrap_RegionIterator_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9059 PyObject *resultobj = 0;
9060 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9061 int result;
9062 void *argp1 = 0 ;
9063 int res1 = 0 ;
9064 PyObject *swig_obj[1] ;
9065
9066 if (!args) SWIG_fail;
9067 swig_obj[0] = args;
9068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9069 if (!SWIG_IsOK(res1)) {
9070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetX" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9071 }
9072 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (int)(arg1)->GetX();
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_From_int(static_cast< int >(result));
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_RegionIterator_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *resultobj = 0;
9088 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9089 int result;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 PyObject *swig_obj[1] ;
9093
9094 if (!args) SWIG_fail;
9095 swig_obj[0] = args;
9096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetY" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9099 }
9100 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (int)(arg1)->GetY();
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_From_int(static_cast< int >(result));
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_RegionIterator_GetW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *resultobj = 0;
9116 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9117 int result;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 PyObject *swig_obj[1] ;
9121
9122 if (!args) SWIG_fail;
9123 swig_obj[0] = args;
9124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetW" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9127 }
9128 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (int)(arg1)->GetW();
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = SWIG_From_int(static_cast< int >(result));
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_RegionIterator_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9145 int result;
9146 void *argp1 = 0 ;
9147 int res1 = 0 ;
9148 PyObject *swig_obj[1] ;
9149
9150 if (!args) SWIG_fail;
9151 swig_obj[0] = args;
9152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9153 if (!SWIG_IsOK(res1)) {
9154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetWidth" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9155 }
9156 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (int)(arg1)->GetWidth();
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_From_int(static_cast< int >(result));
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *_wrap_RegionIterator_GetH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *resultobj = 0;
9172 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9173 int result;
9174 void *argp1 = 0 ;
9175 int res1 = 0 ;
9176 PyObject *swig_obj[1] ;
9177
9178 if (!args) SWIG_fail;
9179 swig_obj[0] = args;
9180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9181 if (!SWIG_IsOK(res1)) {
9182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetH" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9183 }
9184 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9185 {
9186 PyThreadState* __tstate = wxPyBeginAllowThreads();
9187 result = (int)(arg1)->GetH();
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 resultobj = SWIG_From_int(static_cast< int >(result));
9192 return resultobj;
9193 fail:
9194 return NULL;
9195 }
9196
9197
9198 SWIGINTERN PyObject *_wrap_RegionIterator_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 PyObject *resultobj = 0;
9200 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9201 int result;
9202 void *argp1 = 0 ;
9203 int res1 = 0 ;
9204 PyObject *swig_obj[1] ;
9205
9206 if (!args) SWIG_fail;
9207 swig_obj[0] = args;
9208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9209 if (!SWIG_IsOK(res1)) {
9210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetHeight" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9211 }
9212 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (int)(arg1)->GetHeight();
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_From_int(static_cast< int >(result));
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_RegionIterator_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9229 wxRect result;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetRect" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9239 }
9240 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 result = (arg1)->GetRect();
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_RegionIterator_HaveRects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9257 bool result;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 PyObject *swig_obj[1] ;
9261
9262 if (!args) SWIG_fail;
9263 swig_obj[0] = args;
9264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_HaveRects" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9267 }
9268 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (bool)(arg1)->HaveRects();
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 {
9276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9277 }
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_RegionIterator_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Reset" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9296 }
9297 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 (arg1)->Reset();
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_Py_Void();
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_RegionIterator_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9312 PyObject *resultobj = 0;
9313 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9314 void *argp1 = 0 ;
9315 int res1 = 0 ;
9316 PyObject *swig_obj[1] ;
9317
9318 if (!args) SWIG_fail;
9319 swig_obj[0] = args;
9320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9321 if (!SWIG_IsOK(res1)) {
9322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Next" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9323 }
9324 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 wxRegionIterator_Next(arg1);
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 resultobj = SWIG_Py_Void();
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 SWIGINTERN PyObject *_wrap_RegionIterator___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *resultobj = 0;
9340 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
9341 bool result;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator___nonzero__" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
9351 }
9352 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (bool)wxRegionIterator___nonzero__(arg1);
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 {
9360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9361 }
9362 return resultobj;
9363 fail:
9364 return NULL;
9365 }
9366
9367
9368 SWIGINTERN PyObject *RegionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9369 PyObject *obj;
9370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9371 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegionIterator, SWIG_NewClientData(obj));
9372 return SWIG_Py_Void();
9373 }
9374
9375 SWIGINTERN PyObject *RegionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9376 return SWIG_Python_InitShadowInstance(args);
9377 }
9378
9379 SWIGINTERN PyObject *_wrap_new_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 PyObject *resultobj = 0;
9381 wxNativeFontInfo *result = 0 ;
9382
9383 if (!SWIG_Python_UnpackTuple(args,"new_NativeFontInfo",0,0,0)) SWIG_fail;
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 result = (wxNativeFontInfo *)new wxNativeFontInfo();
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_NEW | 0 );
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_delete_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9398 PyObject *resultobj = 0;
9399 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9400 void *argp1 = 0 ;
9401 int res1 = 0 ;
9402 PyObject *swig_obj[1] ;
9403
9404 if (!args) SWIG_fail;
9405 swig_obj[0] = args;
9406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_DISOWN | 0 );
9407 if (!SWIG_IsOK(res1)) {
9408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeFontInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9409 }
9410 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 delete arg1;
9414
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_Py_Void();
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_NativeFontInfo_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 PyObject *resultobj = 0;
9427 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9428 void *argp1 = 0 ;
9429 int res1 = 0 ;
9430 PyObject *swig_obj[1] ;
9431
9432 if (!args) SWIG_fail;
9433 swig_obj[0] = args;
9434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9435 if (!SWIG_IsOK(res1)) {
9436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_Init" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9437 }
9438 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 (arg1)->Init();
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = SWIG_Py_Void();
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 SWIGINTERN PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj = 0;
9454 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9455 wxFont *arg2 = 0 ;
9456 void *argp1 = 0 ;
9457 int res1 = 0 ;
9458 void *argp2 = 0 ;
9459 int res2 = 0 ;
9460 PyObject * obj0 = 0 ;
9461 PyObject * obj1 = 0 ;
9462 char * kwnames[] = {
9463 (char *) "self",(char *) "font", NULL
9464 };
9465
9466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) SWIG_fail;
9467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9468 if (!SWIG_IsOK(res1)) {
9469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9470 }
9471 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9472 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
9473 if (!SWIG_IsOK(res2)) {
9474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
9475 }
9476 if (!argp2) {
9477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
9478 }
9479 arg2 = reinterpret_cast< wxFont * >(argp2);
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 (arg1)->InitFromFont((wxFont const &)*arg2);
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = SWIG_Py_Void();
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9494 PyObject *resultobj = 0;
9495 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9496 int result;
9497 void *argp1 = 0 ;
9498 int res1 = 0 ;
9499 PyObject *swig_obj[1] ;
9500
9501 if (!args) SWIG_fail;
9502 swig_obj[0] = args;
9503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9504 if (!SWIG_IsOK(res1)) {
9505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9506 }
9507 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_From_int(static_cast< int >(result));
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9522 PyObject *resultobj = 0;
9523 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9524 wxFontStyle result;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 PyObject *swig_obj[1] ;
9528
9529 if (!args) SWIG_fail;
9530 swig_obj[0] = args;
9531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9534 }
9535 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_From_int(static_cast< int >(result));
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *resultobj = 0;
9551 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9552 wxFontWeight result;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 PyObject *swig_obj[1] ;
9556
9557 if (!args) SWIG_fail;
9558 swig_obj[0] = args;
9559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9562 }
9563 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 resultobj = SWIG_From_int(static_cast< int >(result));
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
9577 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9578 PyObject *resultobj = 0;
9579 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9580 bool result;
9581 void *argp1 = 0 ;
9582 int res1 = 0 ;
9583 PyObject *swig_obj[1] ;
9584
9585 if (!args) SWIG_fail;
9586 swig_obj[0] = args;
9587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9588 if (!SWIG_IsOK(res1)) {
9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9590 }
9591 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 {
9599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9600 }
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *resultobj = 0;
9609 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9610 wxString result;
9611 void *argp1 = 0 ;
9612 int res1 = 0 ;
9613 PyObject *swig_obj[1] ;
9614
9615 if (!args) SWIG_fail;
9616 swig_obj[0] = args;
9617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9620 }
9621 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 {
9629 #if wxUSE_UNICODE
9630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9631 #else
9632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9633 #endif
9634 }
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9642 PyObject *resultobj = 0;
9643 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9644 wxFontFamily result;
9645 void *argp1 = 0 ;
9646 int res1 = 0 ;
9647 PyObject *swig_obj[1] ;
9648
9649 if (!args) SWIG_fail;
9650 swig_obj[0] = args;
9651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9652 if (!SWIG_IsOK(res1)) {
9653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9654 }
9655 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 resultobj = SWIG_From_int(static_cast< int >(result));
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9670 PyObject *resultobj = 0;
9671 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9672 wxFontEncoding result;
9673 void *argp1 = 0 ;
9674 int res1 = 0 ;
9675 PyObject *swig_obj[1] ;
9676
9677 if (!args) SWIG_fail;
9678 swig_obj[0] = args;
9679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9680 if (!SWIG_IsOK(res1)) {
9681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
9682 }
9683 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_From_int(static_cast< int >(result));
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = 0;
9699 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9700 int arg2 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 int val2 ;
9704 int ecode2 = 0 ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char * kwnames[] = {
9708 (char *) "self",(char *) "pointsize", NULL
9709 };
9710
9711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
9712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9715 }
9716 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9717 ecode2 = SWIG_AsVal_int(obj1, &val2);
9718 if (!SWIG_IsOK(ecode2)) {
9719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "2"" of type '" "int""'");
9720 }
9721 arg2 = static_cast< int >(val2);
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->SetPointSize(arg2);
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_Py_Void();
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj = 0;
9737 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9738 wxFontStyle arg2 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 int val2 ;
9742 int ecode2 = 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char * kwnames[] = {
9746 (char *) "self",(char *) "style", NULL
9747 };
9748
9749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
9750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9753 }
9754 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9755 ecode2 = SWIG_AsVal_int(obj1, &val2);
9756 if (!SWIG_IsOK(ecode2)) {
9757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
9758 }
9759 arg2 = static_cast< wxFontStyle >(val2);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 (arg1)->SetStyle(arg2);
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_Py_Void();
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9776 wxFontWeight arg2 ;
9777 void *argp1 = 0 ;
9778 int res1 = 0 ;
9779 int val2 ;
9780 int ecode2 = 0 ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 char * kwnames[] = {
9784 (char *) "self",(char *) "weight", NULL
9785 };
9786
9787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
9788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9791 }
9792 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9793 ecode2 = SWIG_AsVal_int(obj1, &val2);
9794 if (!SWIG_IsOK(ecode2)) {
9795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
9796 }
9797 arg2 = static_cast< wxFontWeight >(val2);
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 (arg1)->SetWeight(arg2);
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj = 0;
9813 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9814 bool arg2 ;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 bool val2 ;
9818 int ecode2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "underlined", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9829 }
9830 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
9832 if (!SWIG_IsOK(ecode2)) {
9833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
9834 }
9835 arg2 = static_cast< bool >(val2);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 (arg1)->SetUnderlined(arg2);
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 resultobj = SWIG_Py_Void();
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9850 PyObject *resultobj = 0;
9851 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9852 wxString arg2 ;
9853 bool result;
9854 void *argp1 = 0 ;
9855 int res1 = 0 ;
9856 PyObject * obj0 = 0 ;
9857 PyObject * obj1 = 0 ;
9858 char * kwnames[] = {
9859 (char *) "self",(char *) "facename", NULL
9860 };
9861
9862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
9863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9864 if (!SWIG_IsOK(res1)) {
9865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9866 }
9867 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9868 {
9869 wxString* sptr = wxString_in_helper(obj1);
9870 if (sptr == NULL) SWIG_fail;
9871 arg2 = *sptr;
9872 delete sptr;
9873 }
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 result = (bool)(arg1)->SetFaceName(arg2);
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 {
9881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9882 }
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj = 0;
9891 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9892 wxFontFamily arg2 ;
9893 void *argp1 = 0 ;
9894 int res1 = 0 ;
9895 int val2 ;
9896 int ecode2 = 0 ;
9897 PyObject * obj0 = 0 ;
9898 PyObject * obj1 = 0 ;
9899 char * kwnames[] = {
9900 (char *) "self",(char *) "family", NULL
9901 };
9902
9903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
9904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9905 if (!SWIG_IsOK(res1)) {
9906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9907 }
9908 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9909 ecode2 = SWIG_AsVal_int(obj1, &val2);
9910 if (!SWIG_IsOK(ecode2)) {
9911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
9912 }
9913 arg2 = static_cast< wxFontFamily >(val2);
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 (arg1)->SetFamily(arg2);
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 resultobj = SWIG_Py_Void();
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj = 0;
9929 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9930 wxFontEncoding arg2 ;
9931 void *argp1 = 0 ;
9932 int res1 = 0 ;
9933 int val2 ;
9934 int ecode2 = 0 ;
9935 PyObject * obj0 = 0 ;
9936 PyObject * obj1 = 0 ;
9937 char * kwnames[] = {
9938 (char *) "self",(char *) "encoding", NULL
9939 };
9940
9941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
9942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9943 if (!SWIG_IsOK(res1)) {
9944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9945 }
9946 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9947 ecode2 = SWIG_AsVal_int(obj1, &val2);
9948 if (!SWIG_IsOK(ecode2)) {
9949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
9950 }
9951 arg2 = static_cast< wxFontEncoding >(val2);
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 (arg1)->SetEncoding(arg2);
9955 wxPyEndAllowThreads(__tstate);
9956 if (PyErr_Occurred()) SWIG_fail;
9957 }
9958 resultobj = SWIG_Py_Void();
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9966 PyObject *resultobj = 0;
9967 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
9968 wxString *arg2 = 0 ;
9969 bool result;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 bool temp2 = false ;
9973 PyObject * obj0 = 0 ;
9974 PyObject * obj1 = 0 ;
9975 char * kwnames[] = {
9976 (char *) "self",(char *) "s", NULL
9977 };
9978
9979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
9980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
9981 if (!SWIG_IsOK(res1)) {
9982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
9983 }
9984 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
9985 {
9986 arg2 = wxString_in_helper(obj1);
9987 if (arg2 == NULL) SWIG_fail;
9988 temp2 = true;
9989 }
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 {
9997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9998 }
9999 {
10000 if (temp2)
10001 delete arg2;
10002 }
10003 return resultobj;
10004 fail:
10005 {
10006 if (temp2)
10007 delete arg2;
10008 }
10009 return NULL;
10010 }
10011
10012
10013 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10014 PyObject *resultobj = 0;
10015 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10016 wxString result;
10017 void *argp1 = 0 ;
10018 int res1 = 0 ;
10019 PyObject *swig_obj[1] ;
10020
10021 if (!args) SWIG_fail;
10022 swig_obj[0] = args;
10023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
10026 }
10027 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 result = ((wxNativeFontInfo const *)arg1)->ToString();
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 {
10035 #if wxUSE_UNICODE
10036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10037 #else
10038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10039 #endif
10040 }
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_NativeFontInfo___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10048 PyObject *resultobj = 0;
10049 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10050 wxString result;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 PyObject *swig_obj[1] ;
10054
10055 if (!args) SWIG_fail;
10056 swig_obj[0] = args;
10057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10058 if (!SWIG_IsOK(res1)) {
10059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo___str__" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
10060 }
10061 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 result = wxNativeFontInfo___str__(arg1);
10065 wxPyEndAllowThreads(__tstate);
10066 if (PyErr_Occurred()) SWIG_fail;
10067 }
10068 {
10069 #if wxUSE_UNICODE
10070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10071 #else
10072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10073 #endif
10074 }
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10082 PyObject *resultobj = 0;
10083 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10084 wxString *arg2 = 0 ;
10085 bool result;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 bool temp2 = false ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 char * kwnames[] = {
10092 (char *) "self",(char *) "s", NULL
10093 };
10094
10095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) SWIG_fail;
10096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
10099 }
10100 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10101 {
10102 arg2 = wxString_in_helper(obj1);
10103 if (arg2 == NULL) SWIG_fail;
10104 temp2 = true;
10105 }
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
10109 wxPyEndAllowThreads(__tstate);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 {
10113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10114 }
10115 {
10116 if (temp2)
10117 delete arg2;
10118 }
10119 return resultobj;
10120 fail:
10121 {
10122 if (temp2)
10123 delete arg2;
10124 }
10125 return NULL;
10126 }
10127
10128
10129 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10130 PyObject *resultobj = 0;
10131 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
10132 wxString result;
10133 void *argp1 = 0 ;
10134 int res1 = 0 ;
10135 PyObject *swig_obj[1] ;
10136
10137 if (!args) SWIG_fail;
10138 swig_obj[0] = args;
10139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
10140 if (!SWIG_IsOK(res1)) {
10141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
10142 }
10143 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
10144 {
10145 PyThreadState* __tstate = wxPyBeginAllowThreads();
10146 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 {
10151 #if wxUSE_UNICODE
10152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10153 #else
10154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10155 #endif
10156 }
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *NativeFontInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *obj;
10165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10166 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeFontInfo, SWIG_NewClientData(obj));
10167 return SWIG_Py_Void();
10168 }
10169
10170 SWIGINTERN PyObject *NativeFontInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10171 return SWIG_Python_InitShadowInstance(args);
10172 }
10173
10174 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10175 PyObject *resultobj = 0;
10176 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10177 wxString *arg2 = (wxString *) 0 ;
10178 void *argp1 = 0 ;
10179 int res1 = 0 ;
10180 bool temp2 = false ;
10181 PyObject *swig_obj[2] ;
10182
10183 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_facename_set",2,2,swig_obj)) SWIG_fail;
10184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10185 if (!SWIG_IsOK(res1)) {
10186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10187 }
10188 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10189 {
10190 arg2 = wxString_in_helper(swig_obj[1]);
10191 if (arg2 == NULL) SWIG_fail;
10192 temp2 = true;
10193 }
10194 if (arg1) (arg1)->facename = *arg2;
10195
10196 resultobj = SWIG_Py_Void();
10197 {
10198 if (temp2)
10199 delete arg2;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp2)
10205 delete arg2;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10212 PyObject *resultobj = 0;
10213 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10214 wxString *result = 0 ;
10215 void *argp1 = 0 ;
10216 int res1 = 0 ;
10217 PyObject *swig_obj[1] ;
10218
10219 if (!args) SWIG_fail;
10220 swig_obj[0] = args;
10221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10222 if (!SWIG_IsOK(res1)) {
10223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10224 }
10225 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10226 result = (wxString *)& ((arg1)->facename);
10227 {
10228 #if wxUSE_UNICODE
10229 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10230 #else
10231 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10232 #endif
10233 }
10234 return resultobj;
10235 fail:
10236 return NULL;
10237 }
10238
10239
10240 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10241 PyObject *resultobj = 0;
10242 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10243 wxFontEncoding arg2 ;
10244 void *argp1 = 0 ;
10245 int res1 = 0 ;
10246 int val2 ;
10247 int ecode2 = 0 ;
10248 PyObject *swig_obj[2] ;
10249
10250 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_encoding_set",2,2,swig_obj)) SWIG_fail;
10251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10252 if (!SWIG_IsOK(res1)) {
10253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10254 }
10255 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10256 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10257 if (!SWIG_IsOK(ecode2)) {
10258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10259 }
10260 arg2 = static_cast< wxFontEncoding >(val2);
10261 if (arg1) (arg1)->encoding = arg2;
10262
10263 resultobj = SWIG_Py_Void();
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10271 PyObject *resultobj = 0;
10272 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10273 wxFontEncoding result;
10274 void *argp1 = 0 ;
10275 int res1 = 0 ;
10276 PyObject *swig_obj[1] ;
10277
10278 if (!args) SWIG_fail;
10279 swig_obj[0] = args;
10280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10283 }
10284 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10285 result = (wxFontEncoding) ((arg1)->encoding);
10286 resultobj = SWIG_From_int(static_cast< int >(result));
10287 return resultobj;
10288 fail:
10289 return NULL;
10290 }
10291
10292
10293 SWIGINTERN PyObject *_wrap_new_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 wxNativeEncodingInfo *result = 0 ;
10296
10297 if (!SWIG_Python_UnpackTuple(args,"new_NativeEncodingInfo",0,0,0)) SWIG_fail;
10298 {
10299 PyThreadState* __tstate = wxPyBeginAllowThreads();
10300 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_NEW | 0 );
10305 return resultobj;
10306 fail:
10307 return NULL;
10308 }
10309
10310
10311 SWIGINTERN PyObject *_wrap_delete_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10312 PyObject *resultobj = 0;
10313 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10314 void *argp1 = 0 ;
10315 int res1 = 0 ;
10316 PyObject *swig_obj[1] ;
10317
10318 if (!args) SWIG_fail;
10319 swig_obj[0] = args;
10320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_DISOWN | 0 );
10321 if (!SWIG_IsOK(res1)) {
10322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeEncodingInfo" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10323 }
10324 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10325 {
10326 PyThreadState* __tstate = wxPyBeginAllowThreads();
10327 delete arg1;
10328
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 resultobj = SWIG_Py_Void();
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10340 PyObject *resultobj = 0;
10341 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10342 wxString *arg2 = 0 ;
10343 bool result;
10344 void *argp1 = 0 ;
10345 int res1 = 0 ;
10346 bool temp2 = false ;
10347 PyObject * obj0 = 0 ;
10348 PyObject * obj1 = 0 ;
10349 char * kwnames[] = {
10350 (char *) "self",(char *) "s", NULL
10351 };
10352
10353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
10354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10355 if (!SWIG_IsOK(res1)) {
10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_FromString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
10357 }
10358 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10359 {
10360 arg2 = wxString_in_helper(obj1);
10361 if (arg2 == NULL) SWIG_fail;
10362 temp2 = true;
10363 }
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 result = (bool)(arg1)->FromString((wxString const &)*arg2);
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 {
10371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10372 }
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return resultobj;
10378 fail:
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10388 PyObject *resultobj = 0;
10389 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
10390 wxString result;
10391 void *argp1 = 0 ;
10392 int res1 = 0 ;
10393 PyObject *swig_obj[1] ;
10394
10395 if (!args) SWIG_fail;
10396 swig_obj[0] = args;
10397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10398 if (!SWIG_IsOK(res1)) {
10399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_ToString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const *""'");
10400 }
10401 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10402 {
10403 PyThreadState* __tstate = wxPyBeginAllowThreads();
10404 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 {
10409 #if wxUSE_UNICODE
10410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10411 #else
10412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10413 #endif
10414 }
10415 return resultobj;
10416 fail:
10417 return NULL;
10418 }
10419
10420
10421 SWIGINTERN PyObject *NativeEncodingInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10422 PyObject *obj;
10423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10424 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeEncodingInfo, SWIG_NewClientData(obj));
10425 return SWIG_Py_Void();
10426 }
10427
10428 SWIGINTERN PyObject *NativeEncodingInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10429 return SWIG_Python_InitShadowInstance(args);
10430 }
10431
10432 SWIGINTERN PyObject *_wrap_GetNativeFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10433 PyObject *resultobj = 0;
10434 wxFontEncoding arg1 ;
10435 wxNativeEncodingInfo *result = 0 ;
10436 int val1 ;
10437 int ecode1 = 0 ;
10438 PyObject * obj0 = 0 ;
10439 char * kwnames[] = {
10440 (char *) "encoding", NULL
10441 };
10442
10443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) SWIG_fail;
10444 ecode1 = SWIG_AsVal_int(obj0, &val1);
10445 if (!SWIG_IsOK(ecode1)) {
10446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetNativeFontEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10447 }
10448 arg1 = static_cast< wxFontEncoding >(val1);
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding(arg1);
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_TestFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj = 0;
10464 wxNativeEncodingInfo *arg1 = 0 ;
10465 bool result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 PyObject * obj0 = 0 ;
10469 char * kwnames[] = {
10470 (char *) "info", NULL
10471 };
10472
10473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) SWIG_fail;
10474 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0);
10475 if (!SWIG_IsOK(res1)) {
10476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
10477 }
10478 if (!argp1) {
10479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
10480 }
10481 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 {
10489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10490 }
10491 return resultobj;
10492 fail:
10493 return NULL;
10494 }
10495
10496
10497 SWIGINTERN PyObject *_wrap_new_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10498 PyObject *resultobj = 0;
10499 wxFontMapper *result = 0 ;
10500
10501 if (!SWIG_Python_UnpackTuple(args,"new_FontMapper",0,0,0)) SWIG_fail;
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 result = (wxFontMapper *)new wxFontMapper();
10505 wxPyEndAllowThreads(__tstate);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, SWIG_POINTER_NEW | 0 );
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_delete_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10516 PyObject *resultobj = 0;
10517 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10518 void *argp1 = 0 ;
10519 int res1 = 0 ;
10520 PyObject *swig_obj[1] ;
10521
10522 if (!args) SWIG_fail;
10523 swig_obj[0] = args;
10524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontMapper, SWIG_POINTER_DISOWN | 0 );
10525 if (!SWIG_IsOK(res1)) {
10526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontMapper" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10527 }
10528 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10529 {
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 delete arg1;
10532
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 resultobj = SWIG_Py_Void();
10537 return resultobj;
10538 fail:
10539 return NULL;
10540 }
10541
10542
10543 SWIGINTERN PyObject *_wrap_FontMapper_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10544 PyObject *resultobj = 0;
10545 wxFontMapper *result = 0 ;
10546
10547 if (!SWIG_Python_UnpackTuple(args,"FontMapper_Get",0,0,0)) SWIG_fail;
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 result = (wxFontMapper *)wxFontMapper::Get();
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_FontMapper_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj = 0;
10563 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10564 wxFontMapper *result = 0 ;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 PyObject * obj0 = 0 ;
10568 char * kwnames[] = {
10569 (char *) "mapper", NULL
10570 };
10571
10572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) SWIG_fail;
10573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_Set" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10576 }
10577 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (wxFontMapper *)wxFontMapper::Set(arg1);
10581 wxPyEndAllowThreads(__tstate);
10582 if (PyErr_Occurred()) SWIG_fail;
10583 }
10584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
10585 return resultobj;
10586 fail:
10587 return NULL;
10588 }
10589
10590
10591 SWIGINTERN PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj = 0;
10593 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10594 wxString *arg2 = 0 ;
10595 bool arg3 = (bool) true ;
10596 wxFontEncoding result;
10597 void *argp1 = 0 ;
10598 int res1 = 0 ;
10599 bool temp2 = false ;
10600 bool val3 ;
10601 int ecode3 = 0 ;
10602 PyObject * obj0 = 0 ;
10603 PyObject * obj1 = 0 ;
10604 PyObject * obj2 = 0 ;
10605 char * kwnames[] = {
10606 (char *) "self",(char *) "charset",(char *) "interactive", NULL
10607 };
10608
10609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10611 if (!SWIG_IsOK(res1)) {
10612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10613 }
10614 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10615 {
10616 arg2 = wxString_in_helper(obj1);
10617 if (arg2 == NULL) SWIG_fail;
10618 temp2 = true;
10619 }
10620 if (obj2) {
10621 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10622 if (!SWIG_IsOK(ecode3)) {
10623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "3"" of type '" "bool""'");
10624 }
10625 arg3 = static_cast< bool >(val3);
10626 }
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 resultobj = SWIG_From_int(static_cast< int >(result));
10634 {
10635 if (temp2)
10636 delete arg2;
10637 }
10638 return resultobj;
10639 fail:
10640 {
10641 if (temp2)
10642 delete arg2;
10643 }
10644 return NULL;
10645 }
10646
10647
10648 SWIGINTERN PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10649 PyObject *resultobj = 0;
10650 size_t result;
10651
10652 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetSupportedEncodingsCount",0,0,0)) SWIG_fail;
10653 {
10654 PyThreadState* __tstate = wxPyBeginAllowThreads();
10655 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
10656 wxPyEndAllowThreads(__tstate);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10660 return resultobj;
10661 fail:
10662 return NULL;
10663 }
10664
10665
10666 SWIGINTERN PyObject *_wrap_FontMapper_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10667 PyObject *resultobj = 0;
10668 size_t arg1 ;
10669 wxFontEncoding result;
10670 size_t val1 ;
10671 int ecode1 = 0 ;
10672 PyObject * obj0 = 0 ;
10673 char * kwnames[] = {
10674 (char *) "n", NULL
10675 };
10676
10677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) SWIG_fail;
10678 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10679 if (!SWIG_IsOK(ecode1)) {
10680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncoding" "', expected argument " "1"" of type '" "size_t""'");
10681 }
10682 arg1 = static_cast< size_t >(val1);
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 resultobj = SWIG_From_int(static_cast< int >(result));
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj = 0;
10698 wxFontEncoding arg1 ;
10699 wxString result;
10700 int val1 ;
10701 int ecode1 = 0 ;
10702 PyObject * obj0 = 0 ;
10703 char * kwnames[] = {
10704 (char *) "encoding", NULL
10705 };
10706
10707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) SWIG_fail;
10708 ecode1 = SWIG_AsVal_int(obj0, &val1);
10709 if (!SWIG_IsOK(ecode1)) {
10710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingName" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10711 }
10712 arg1 = static_cast< wxFontEncoding >(val1);
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = wxFontMapper::GetEncodingName(arg1);
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 {
10720 #if wxUSE_UNICODE
10721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10722 #else
10723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10724 #endif
10725 }
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10733 PyObject *resultobj = 0;
10734 wxFontEncoding arg1 ;
10735 wxString result;
10736 int val1 ;
10737 int ecode1 = 0 ;
10738 PyObject * obj0 = 0 ;
10739 char * kwnames[] = {
10740 (char *) "encoding", NULL
10741 };
10742
10743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) SWIG_fail;
10744 ecode1 = SWIG_AsVal_int(obj0, &val1);
10745 if (!SWIG_IsOK(ecode1)) {
10746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingDescription" "', expected argument " "1"" of type '" "wxFontEncoding""'");
10747 }
10748 arg1 = static_cast< wxFontEncoding >(val1);
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 result = wxFontMapper::GetEncodingDescription(arg1);
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 #if wxUSE_UNICODE
10757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10758 #else
10759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10760 #endif
10761 }
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10769 PyObject *resultobj = 0;
10770 wxString *arg1 = 0 ;
10771 wxFontEncoding result;
10772 bool temp1 = false ;
10773 PyObject * obj0 = 0 ;
10774 char * kwnames[] = {
10775 (char *) "name", NULL
10776 };
10777
10778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) SWIG_fail;
10779 {
10780 arg1 = wxString_in_helper(obj0);
10781 if (arg1 == NULL) SWIG_fail;
10782 temp1 = true;
10783 }
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 resultobj = SWIG_From_int(static_cast< int >(result));
10791 {
10792 if (temp1)
10793 delete arg1;
10794 }
10795 return resultobj;
10796 fail:
10797 {
10798 if (temp1)
10799 delete arg1;
10800 }
10801 return NULL;
10802 }
10803
10804
10805 SWIGINTERN PyObject *_wrap_FontMapper_SetConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10806 PyObject *resultobj = 0;
10807 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10808 wxString *arg2 = 0 ;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 bool temp2 = false ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "prefix", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetConfigPath" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10822 }
10823 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10824 {
10825 arg2 = wxString_in_helper(obj1);
10826 if (arg2 == NULL) SWIG_fail;
10827 temp2 = true;
10828 }
10829 {
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 (arg1)->SetConfigPath((wxString const &)*arg2);
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 resultobj = SWIG_Py_Void();
10836 {
10837 if (temp2)
10838 delete arg2;
10839 }
10840 return resultobj;
10841 fail:
10842 {
10843 if (temp2)
10844 delete arg2;
10845 }
10846 return NULL;
10847 }
10848
10849
10850 SWIGINTERN PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10851 PyObject *resultobj = 0;
10852 wxString result;
10853
10854 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetDefaultConfigPath",0,0,0)) SWIG_fail;
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = wxFontMapper::GetDefaultConfigPath();
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 {
10862 #if wxUSE_UNICODE
10863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10864 #else
10865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10866 #endif
10867 }
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10877 wxFontEncoding arg2 ;
10878 wxString const &arg3_defvalue = wxPyEmptyString ;
10879 wxString *arg3 = (wxString *) &arg3_defvalue ;
10880 bool arg4 = (bool) true ;
10881 PyObject *result = 0 ;
10882 void *argp1 = 0 ;
10883 int res1 = 0 ;
10884 int val2 ;
10885 int ecode2 = 0 ;
10886 bool temp3 = false ;
10887 bool val4 ;
10888 int ecode4 = 0 ;
10889 PyObject * obj0 = 0 ;
10890 PyObject * obj1 = 0 ;
10891 PyObject * obj2 = 0 ;
10892 PyObject * obj3 = 0 ;
10893 char * kwnames[] = {
10894 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
10895 };
10896
10897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10899 if (!SWIG_IsOK(res1)) {
10900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10901 }
10902 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10903 ecode2 = SWIG_AsVal_int(obj1, &val2);
10904 if (!SWIG_IsOK(ecode2)) {
10905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10906 }
10907 arg2 = static_cast< wxFontEncoding >(val2);
10908 if (obj2) {
10909 {
10910 arg3 = wxString_in_helper(obj2);
10911 if (arg3 == NULL) SWIG_fail;
10912 temp3 = true;
10913 }
10914 }
10915 if (obj3) {
10916 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10917 if (!SWIG_IsOK(ecode4)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "4"" of type '" "bool""'");
10919 }
10920 arg4 = static_cast< bool >(val4);
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,arg2,(wxString const &)*arg3,arg4);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 resultobj = result;
10929 {
10930 if (temp3)
10931 delete arg3;
10932 }
10933 return resultobj;
10934 fail:
10935 {
10936 if (temp3)
10937 delete arg3;
10938 }
10939 return NULL;
10940 }
10941
10942
10943 SWIGINTERN PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj = 0;
10945 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
10946 wxFontEncoding arg2 ;
10947 wxString const &arg3_defvalue = wxPyEmptyString ;
10948 wxString *arg3 = (wxString *) &arg3_defvalue ;
10949 bool result;
10950 void *argp1 = 0 ;
10951 int res1 = 0 ;
10952 int val2 ;
10953 int ecode2 = 0 ;
10954 bool temp3 = false ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 PyObject * obj2 = 0 ;
10958 char * kwnames[] = {
10959 (char *) "self",(char *) "encoding",(char *) "facename", NULL
10960 };
10961
10962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
10964 if (!SWIG_IsOK(res1)) {
10965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "1"" of type '" "wxFontMapper *""'");
10966 }
10967 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
10968 ecode2 = SWIG_AsVal_int(obj1, &val2);
10969 if (!SWIG_IsOK(ecode2)) {
10970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "2"" of type '" "wxFontEncoding""'");
10971 }
10972 arg2 = static_cast< wxFontEncoding >(val2);
10973 if (obj2) {
10974 {
10975 arg3 = wxString_in_helper(obj2);
10976 if (arg3 == NULL) SWIG_fail;
10977 temp3 = true;
10978 }
10979 }
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 result = (bool)(arg1)->IsEncodingAvailable(arg2,(wxString const &)*arg3);
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 {
10987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10988 }
10989 {
10990 if (temp3)
10991 delete arg3;
10992 }
10993 return resultobj;
10994 fail:
10995 {
10996 if (temp3)
10997 delete arg3;
10998 }
10999 return NULL;
11000 }
11001
11002
11003 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11004 PyObject *resultobj = 0;
11005 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
11006 wxWindow *arg2 = (wxWindow *) 0 ;
11007 void *argp1 = 0 ;
11008 int res1 = 0 ;
11009 void *argp2 = 0 ;
11010 int res2 = 0 ;
11011 PyObject * obj0 = 0 ;
11012 PyObject * obj1 = 0 ;
11013 char * kwnames[] = {
11014 (char *) "self",(char *) "parent", NULL
11015 };
11016
11017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) SWIG_fail;
11018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
11019 if (!SWIG_IsOK(res1)) {
11020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogParent" "', expected argument " "1"" of type '" "wxFontMapper *""'");
11021 }
11022 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
11023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
11024 if (!SWIG_IsOK(res2)) {
11025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontMapper_SetDialogParent" "', expected argument " "2"" of type '" "wxWindow *""'");
11026 }
11027 arg2 = reinterpret_cast< wxWindow * >(argp2);
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 (arg1)->SetDialogParent(arg2);
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 resultobj = SWIG_Py_Void();
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
11044 wxString *arg2 = 0 ;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 bool temp2 = false ;
11048 PyObject * obj0 = 0 ;
11049 PyObject * obj1 = 0 ;
11050 char * kwnames[] = {
11051 (char *) "self",(char *) "title", NULL
11052 };
11053
11054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) SWIG_fail;
11055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogTitle" "', expected argument " "1"" of type '" "wxFontMapper *""'");
11058 }
11059 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
11060 {
11061 arg2 = wxString_in_helper(obj1);
11062 if (arg2 == NULL) SWIG_fail;
11063 temp2 = true;
11064 }
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 (arg1)->SetDialogTitle((wxString const &)*arg2);
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 resultobj = SWIG_Py_Void();
11072 {
11073 if (temp2)
11074 delete arg2;
11075 }
11076 return resultobj;
11077 fail:
11078 {
11079 if (temp2)
11080 delete arg2;
11081 }
11082 return NULL;
11083 }
11084
11085
11086 SWIGINTERN PyObject *FontMapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11087 PyObject *obj;
11088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11089 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontMapper, SWIG_NewClientData(obj));
11090 return SWIG_Py_Void();
11091 }
11092
11093 SWIGINTERN PyObject *FontMapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 return SWIG_Python_InitShadowInstance(args);
11095 }
11096
11097 SWIGINTERN PyObject *_wrap_new_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj = 0;
11099 int arg1 ;
11100 int arg2 ;
11101 int arg3 ;
11102 int arg4 ;
11103 bool arg5 = (bool) false ;
11104 wxString const &arg6_defvalue = wxPyEmptyString ;
11105 wxString *arg6 = (wxString *) &arg6_defvalue ;
11106 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11107 wxFont *result = 0 ;
11108 int val1 ;
11109 int ecode1 = 0 ;
11110 int val2 ;
11111 int ecode2 = 0 ;
11112 int val3 ;
11113 int ecode3 = 0 ;
11114 int val4 ;
11115 int ecode4 = 0 ;
11116 bool val5 ;
11117 int ecode5 = 0 ;
11118 bool temp6 = false ;
11119 int val7 ;
11120 int ecode7 = 0 ;
11121 PyObject * obj0 = 0 ;
11122 PyObject * obj1 = 0 ;
11123 PyObject * obj2 = 0 ;
11124 PyObject * obj3 = 0 ;
11125 PyObject * obj4 = 0 ;
11126 PyObject * obj5 = 0 ;
11127 PyObject * obj6 = 0 ;
11128 char * kwnames[] = {
11129 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
11130 };
11131
11132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11133 ecode1 = SWIG_AsVal_int(obj0, &val1);
11134 if (!SWIG_IsOK(ecode1)) {
11135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Font" "', expected argument " "1"" of type '" "int""'");
11136 }
11137 arg1 = static_cast< int >(val1);
11138 ecode2 = SWIG_AsVal_int(obj1, &val2);
11139 if (!SWIG_IsOK(ecode2)) {
11140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Font" "', expected argument " "2"" of type '" "int""'");
11141 }
11142 arg2 = static_cast< int >(val2);
11143 ecode3 = SWIG_AsVal_int(obj2, &val3);
11144 if (!SWIG_IsOK(ecode3)) {
11145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Font" "', expected argument " "3"" of type '" "int""'");
11146 }
11147 arg3 = static_cast< int >(val3);
11148 ecode4 = SWIG_AsVal_int(obj3, &val4);
11149 if (!SWIG_IsOK(ecode4)) {
11150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Font" "', expected argument " "4"" of type '" "int""'");
11151 }
11152 arg4 = static_cast< int >(val4);
11153 if (obj4) {
11154 ecode5 = SWIG_AsVal_bool(obj4, &val5);
11155 if (!SWIG_IsOK(ecode5)) {
11156 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Font" "', expected argument " "5"" of type '" "bool""'");
11157 }
11158 arg5 = static_cast< bool >(val5);
11159 }
11160 if (obj5) {
11161 {
11162 arg6 = wxString_in_helper(obj5);
11163 if (arg6 == NULL) SWIG_fail;
11164 temp6 = true;
11165 }
11166 }
11167 if (obj6) {
11168 ecode7 = SWIG_AsVal_int(obj6, &val7);
11169 if (!SWIG_IsOK(ecode7)) {
11170 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Font" "', expected argument " "7"" of type '" "wxFontEncoding""'");
11171 }
11172 arg7 = static_cast< wxFontEncoding >(val7);
11173 }
11174 {
11175 if (!wxPyCheckForApp()) SWIG_fail;
11176 PyThreadState* __tstate = wxPyBeginAllowThreads();
11177 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_NEW | 0 );
11182 {
11183 if (temp6)
11184 delete arg6;
11185 }
11186 return resultobj;
11187 fail:
11188 {
11189 if (temp6)
11190 delete arg6;
11191 }
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_delete_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198 wxFont *arg1 = (wxFont *) 0 ;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 PyObject *swig_obj[1] ;
11202
11203 if (!args) SWIG_fail;
11204 swig_obj[0] = args;
11205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, SWIG_POINTER_DISOWN | 0 );
11206 if (!SWIG_IsOK(res1)) {
11207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Font" "', expected argument " "1"" of type '" "wxFont *""'");
11208 }
11209 arg1 = reinterpret_cast< wxFont * >(argp1);
11210 {
11211 PyThreadState* __tstate = wxPyBeginAllowThreads();
11212 delete arg1;
11213
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 resultobj = SWIG_Py_Void();
11218 return resultobj;
11219 fail:
11220 return NULL;
11221 }
11222
11223
11224 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj = 0;
11226 wxNativeFontInfo *arg1 = 0 ;
11227 wxFont *result = 0 ;
11228 void *argp1 = 0 ;
11229 int res1 = 0 ;
11230 PyObject * obj0 = 0 ;
11231 char * kwnames[] = {
11232 (char *) "info", NULL
11233 };
11234
11235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) SWIG_fail;
11236 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
11237 if (!SWIG_IsOK(res1)) {
11238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
11239 }
11240 if (!argp1) {
11241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
11242 }
11243 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11244 {
11245 if (!wxPyCheckForApp()) SWIG_fail;
11246 PyThreadState* __tstate = wxPyBeginAllowThreads();
11247 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
11248 wxPyEndAllowThreads(__tstate);
11249 if (PyErr_Occurred()) SWIG_fail;
11250 }
11251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfoString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxString *arg1 = 0 ;
11261 wxFont *result = 0 ;
11262 bool temp1 = false ;
11263 PyObject * obj0 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "info", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) SWIG_fail;
11269 {
11270 arg1 = wxString_in_helper(obj0);
11271 if (arg1 == NULL) SWIG_fail;
11272 temp1 = true;
11273 }
11274 {
11275 if (!wxPyCheckForApp()) SWIG_fail;
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (wxFont *)new_wxFont((wxString const &)*arg1);
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11282 {
11283 if (temp1)
11284 delete arg1;
11285 }
11286 return resultobj;
11287 fail:
11288 {
11289 if (temp1)
11290 delete arg1;
11291 }
11292 return NULL;
11293 }
11294
11295
11296 SWIGINTERN PyObject *_wrap_new_FFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11297 PyObject *resultobj = 0;
11298 int arg1 ;
11299 wxFontFamily arg2 ;
11300 int arg3 = (int) wxFONTFLAG_DEFAULT ;
11301 wxString const &arg4_defvalue = wxPyEmptyString ;
11302 wxString *arg4 = (wxString *) &arg4_defvalue ;
11303 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11304 wxFont *result = 0 ;
11305 int val1 ;
11306 int ecode1 = 0 ;
11307 int val2 ;
11308 int ecode2 = 0 ;
11309 int val3 ;
11310 int ecode3 = 0 ;
11311 bool temp4 = false ;
11312 int val5 ;
11313 int ecode5 = 0 ;
11314 PyObject * obj0 = 0 ;
11315 PyObject * obj1 = 0 ;
11316 PyObject * obj2 = 0 ;
11317 PyObject * obj3 = 0 ;
11318 PyObject * obj4 = 0 ;
11319 char * kwnames[] = {
11320 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
11321 };
11322
11323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11324 ecode1 = SWIG_AsVal_int(obj0, &val1);
11325 if (!SWIG_IsOK(ecode1)) {
11326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FFont" "', expected argument " "1"" of type '" "int""'");
11327 }
11328 arg1 = static_cast< int >(val1);
11329 ecode2 = SWIG_AsVal_int(obj1, &val2);
11330 if (!SWIG_IsOK(ecode2)) {
11331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFont" "', expected argument " "2"" of type '" "wxFontFamily""'");
11332 }
11333 arg2 = static_cast< wxFontFamily >(val2);
11334 if (obj2) {
11335 ecode3 = SWIG_AsVal_int(obj2, &val3);
11336 if (!SWIG_IsOK(ecode3)) {
11337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFont" "', expected argument " "3"" of type '" "int""'");
11338 }
11339 arg3 = static_cast< int >(val3);
11340 }
11341 if (obj3) {
11342 {
11343 arg4 = wxString_in_helper(obj3);
11344 if (arg4 == NULL) SWIG_fail;
11345 temp4 = true;
11346 }
11347 }
11348 if (obj4) {
11349 ecode5 = SWIG_AsVal_int(obj4, &val5);
11350 if (!SWIG_IsOK(ecode5)) {
11351 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFont" "', expected argument " "5"" of type '" "wxFontEncoding""'");
11352 }
11353 arg5 = static_cast< wxFontEncoding >(val5);
11354 }
11355 {
11356 if (!wxPyCheckForApp()) SWIG_fail;
11357 PyThreadState* __tstate = wxPyBeginAllowThreads();
11358 result = (wxFont *)new_wxFont(arg1,arg2,arg3,(wxString const &)*arg4,arg5);
11359 wxPyEndAllowThreads(__tstate);
11360 if (PyErr_Occurred()) SWIG_fail;
11361 }
11362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11363 {
11364 if (temp4)
11365 delete arg4;
11366 }
11367 return resultobj;
11368 fail:
11369 {
11370 if (temp4)
11371 delete arg4;
11372 }
11373 return NULL;
11374 }
11375
11376
11377 SWIGINTERN PyObject *_wrap_new_FontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = 0;
11379 wxSize *arg1 = 0 ;
11380 int arg2 ;
11381 int arg3 ;
11382 int arg4 ;
11383 bool arg5 = (bool) false ;
11384 wxString const &arg6_defvalue = wxEmptyString ;
11385 wxString *arg6 = (wxString *) &arg6_defvalue ;
11386 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11387 wxFont *result = 0 ;
11388 wxSize temp1 ;
11389 int val2 ;
11390 int ecode2 = 0 ;
11391 int val3 ;
11392 int ecode3 = 0 ;
11393 int val4 ;
11394 int ecode4 = 0 ;
11395 bool val5 ;
11396 int ecode5 = 0 ;
11397 bool temp6 = false ;
11398 int val7 ;
11399 int ecode7 = 0 ;
11400 PyObject * obj0 = 0 ;
11401 PyObject * obj1 = 0 ;
11402 PyObject * obj2 = 0 ;
11403 PyObject * obj3 = 0 ;
11404 PyObject * obj4 = 0 ;
11405 PyObject * obj5 = 0 ;
11406 PyObject * obj6 = 0 ;
11407 char * kwnames[] = {
11408 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
11409 };
11410
11411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11412 {
11413 arg1 = &temp1;
11414 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
11415 }
11416 ecode2 = SWIG_AsVal_int(obj1, &val2);
11417 if (!SWIG_IsOK(ecode2)) {
11418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontFromPixelSize" "', expected argument " "2"" of type '" "int""'");
11419 }
11420 arg2 = static_cast< int >(val2);
11421 ecode3 = SWIG_AsVal_int(obj2, &val3);
11422 if (!SWIG_IsOK(ecode3)) {
11423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
11424 }
11425 arg3 = static_cast< int >(val3);
11426 ecode4 = SWIG_AsVal_int(obj3, &val4);
11427 if (!SWIG_IsOK(ecode4)) {
11428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FontFromPixelSize" "', expected argument " "4"" of type '" "int""'");
11429 }
11430 arg4 = static_cast< int >(val4);
11431 if (obj4) {
11432 ecode5 = SWIG_AsVal_bool(obj4, &val5);
11433 if (!SWIG_IsOK(ecode5)) {
11434 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FontFromPixelSize" "', expected argument " "5"" of type '" "bool""'");
11435 }
11436 arg5 = static_cast< bool >(val5);
11437 }
11438 if (obj5) {
11439 {
11440 arg6 = wxString_in_helper(obj5);
11441 if (arg6 == NULL) SWIG_fail;
11442 temp6 = true;
11443 }
11444 }
11445 if (obj6) {
11446 ecode7 = SWIG_AsVal_int(obj6, &val7);
11447 if (!SWIG_IsOK(ecode7)) {
11448 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FontFromPixelSize" "', expected argument " "7"" of type '" "wxFontEncoding""'");
11449 }
11450 arg7 = static_cast< wxFontEncoding >(val7);
11451 }
11452 {
11453 if (!wxPyCheckForApp()) SWIG_fail;
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11460 {
11461 if (temp6)
11462 delete arg6;
11463 }
11464 return resultobj;
11465 fail:
11466 {
11467 if (temp6)
11468 delete arg6;
11469 }
11470 return NULL;
11471 }
11472
11473
11474 SWIGINTERN PyObject *_wrap_new_FFontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj = 0;
11476 wxSize *arg1 = 0 ;
11477 wxFontFamily arg2 ;
11478 int arg3 = (int) wxFONTFLAG_DEFAULT ;
11479 wxString const &arg4_defvalue = wxEmptyString ;
11480 wxString *arg4 = (wxString *) &arg4_defvalue ;
11481 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
11482 wxFont *result = 0 ;
11483 wxSize temp1 ;
11484 int val2 ;
11485 int ecode2 = 0 ;
11486 int val3 ;
11487 int ecode3 = 0 ;
11488 bool temp4 = false ;
11489 int val5 ;
11490 int ecode5 = 0 ;
11491 PyObject * obj0 = 0 ;
11492 PyObject * obj1 = 0 ;
11493 PyObject * obj2 = 0 ;
11494 PyObject * obj3 = 0 ;
11495 PyObject * obj4 = 0 ;
11496 char * kwnames[] = {
11497 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
11498 };
11499
11500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11501 {
11502 arg1 = &temp1;
11503 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
11504 }
11505 ecode2 = SWIG_AsVal_int(obj1, &val2);
11506 if (!SWIG_IsOK(ecode2)) {
11507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFontFromPixelSize" "', expected argument " "2"" of type '" "wxFontFamily""'");
11508 }
11509 arg2 = static_cast< wxFontFamily >(val2);
11510 if (obj2) {
11511 ecode3 = SWIG_AsVal_int(obj2, &val3);
11512 if (!SWIG_IsOK(ecode3)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
11514 }
11515 arg3 = static_cast< int >(val3);
11516 }
11517 if (obj3) {
11518 {
11519 arg4 = wxString_in_helper(obj3);
11520 if (arg4 == NULL) SWIG_fail;
11521 temp4 = true;
11522 }
11523 }
11524 if (obj4) {
11525 ecode5 = SWIG_AsVal_int(obj4, &val5);
11526 if (!SWIG_IsOK(ecode5)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFontFromPixelSize" "', expected argument " "5"" of type '" "wxFontEncoding""'");
11528 }
11529 arg5 = static_cast< wxFontEncoding >(val5);
11530 }
11531 {
11532 if (!wxPyCheckForApp()) SWIG_fail;
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,(wxString const &)*arg4,arg5);
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
11539 {
11540 if (temp4)
11541 delete arg4;
11542 }
11543 return resultobj;
11544 fail:
11545 {
11546 if (temp4)
11547 delete arg4;
11548 }
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_Font_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11554 PyObject *resultobj = 0;
11555 wxFont *arg1 = (wxFont *) 0 ;
11556 bool result;
11557 void *argp1 = 0 ;
11558 int res1 = 0 ;
11559 PyObject *swig_obj[1] ;
11560
11561 if (!args) SWIG_fail;
11562 swig_obj[0] = args;
11563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_Ok" "', expected argument " "1"" of type '" "wxFont const *""'");
11566 }
11567 arg1 = reinterpret_cast< wxFont * >(argp1);
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = (bool)((wxFont const *)arg1)->Ok();
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11576 }
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 SWIGINTERN PyObject *_wrap_Font___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj = 0;
11585 wxFont *arg1 = (wxFont *) 0 ;
11586 wxFont *arg2 = (wxFont *) 0 ;
11587 bool result;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 void *argp2 = 0 ;
11591 int res2 = 0 ;
11592 PyObject * obj0 = 0 ;
11593 PyObject * obj1 = 0 ;
11594 char * kwnames[] = {
11595 (char *) "self",(char *) "other", NULL
11596 };
11597
11598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___eq__" "', expected argument " "1"" of type '" "wxFont *""'");
11602 }
11603 arg1 = reinterpret_cast< wxFont * >(argp1);
11604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
11605 if (!SWIG_IsOK(res2)) {
11606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___eq__" "', expected argument " "2"" of type '" "wxFont const *""'");
11607 }
11608 arg2 = reinterpret_cast< wxFont * >(argp2);
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 {
11616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11617 }
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 SWIGINTERN PyObject *_wrap_Font___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj = 0;
11626 wxFont *arg1 = (wxFont *) 0 ;
11627 wxFont *arg2 = (wxFont *) 0 ;
11628 bool result;
11629 void *argp1 = 0 ;
11630 int res1 = 0 ;
11631 void *argp2 = 0 ;
11632 int res2 = 0 ;
11633 PyObject * obj0 = 0 ;
11634 PyObject * obj1 = 0 ;
11635 char * kwnames[] = {
11636 (char *) "self",(char *) "other", NULL
11637 };
11638
11639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___ne__" "', expected argument " "1"" of type '" "wxFont *""'");
11643 }
11644 arg1 = reinterpret_cast< wxFont * >(argp1);
11645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
11646 if (!SWIG_IsOK(res2)) {
11647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___ne__" "', expected argument " "2"" of type '" "wxFont const *""'");
11648 }
11649 arg2 = reinterpret_cast< wxFont * >(argp2);
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11658 }
11659 return resultobj;
11660 fail:
11661 return NULL;
11662 }
11663
11664
11665 SWIGINTERN PyObject *_wrap_Font_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11666 PyObject *resultobj = 0;
11667 wxFont *arg1 = (wxFont *) 0 ;
11668 int result;
11669 void *argp1 = 0 ;
11670 int res1 = 0 ;
11671 PyObject *swig_obj[1] ;
11672
11673 if (!args) SWIG_fail;
11674 swig_obj[0] = args;
11675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPointSize" "', expected argument " "1"" of type '" "wxFont const *""'");
11678 }
11679 arg1 = reinterpret_cast< wxFont * >(argp1);
11680 {
11681 PyThreadState* __tstate = wxPyBeginAllowThreads();
11682 result = (int)((wxFont const *)arg1)->GetPointSize();
11683 wxPyEndAllowThreads(__tstate);
11684 if (PyErr_Occurred()) SWIG_fail;
11685 }
11686 resultobj = SWIG_From_int(static_cast< int >(result));
11687 return resultobj;
11688 fail:
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_Font_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 wxFont *arg1 = (wxFont *) 0 ;
11696 wxSize result;
11697 void *argp1 = 0 ;
11698 int res1 = 0 ;
11699 PyObject *swig_obj[1] ;
11700
11701 if (!args) SWIG_fail;
11702 swig_obj[0] = args;
11703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPixelSize" "', expected argument " "1"" of type '" "wxFont const *""'");
11706 }
11707 arg1 = reinterpret_cast< wxFont * >(argp1);
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = ((wxFont const *)arg1)->GetPixelSize();
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 SWIGINTERN PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722 PyObject *resultobj = 0;
11723 wxFont *arg1 = (wxFont *) 0 ;
11724 bool result;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsUsingSizeInPixels" "', expected argument " "1"" of type '" "wxFont const *""'");
11734 }
11735 arg1 = reinterpret_cast< wxFont * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_Font_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxFont *arg1 = (wxFont *) 0 ;
11754 int result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamily" "', expected argument " "1"" of type '" "wxFont const *""'");
11764 }
11765 arg1 = reinterpret_cast< wxFont * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (int)((wxFont const *)arg1)->GetFamily();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 resultobj = SWIG_From_int(static_cast< int >(result));
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 SWIGINTERN PyObject *_wrap_Font_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11780 PyObject *resultobj = 0;
11781 wxFont *arg1 = (wxFont *) 0 ;
11782 int result;
11783 void *argp1 = 0 ;
11784 int res1 = 0 ;
11785 PyObject *swig_obj[1] ;
11786
11787 if (!args) SWIG_fail;
11788 swig_obj[0] = args;
11789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11790 if (!SWIG_IsOK(res1)) {
11791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyle" "', expected argument " "1"" of type '" "wxFont const *""'");
11792 }
11793 arg1 = reinterpret_cast< wxFont * >(argp1);
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (int)((wxFont const *)arg1)->GetStyle();
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 resultobj = SWIG_From_int(static_cast< int >(result));
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 SWIGINTERN PyObject *_wrap_Font_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 PyObject *resultobj = 0;
11809 wxFont *arg1 = (wxFont *) 0 ;
11810 int result;
11811 void *argp1 = 0 ;
11812 int res1 = 0 ;
11813 PyObject *swig_obj[1] ;
11814
11815 if (!args) SWIG_fail;
11816 swig_obj[0] = args;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeight" "', expected argument " "1"" of type '" "wxFont const *""'");
11820 }
11821 arg1 = reinterpret_cast< wxFont * >(argp1);
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (int)((wxFont const *)arg1)->GetWeight();
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_From_int(static_cast< int >(result));
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_Font_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxFont *arg1 = (wxFont *) 0 ;
11838 bool result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 PyObject *swig_obj[1] ;
11842
11843 if (!args) SWIG_fail;
11844 swig_obj[0] = args;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetUnderlined" "', expected argument " "1"" of type '" "wxFont const *""'");
11848 }
11849 arg1 = reinterpret_cast< wxFont * >(argp1);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (bool)((wxFont const *)arg1)->GetUnderlined();
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_Font_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxFont *arg1 = (wxFont *) 0 ;
11868 wxString result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFaceName" "', expected argument " "1"" of type '" "wxFont const *""'");
11878 }
11879 arg1 = reinterpret_cast< wxFont * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = ((wxFont const *)arg1)->GetFaceName();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 {
11887 #if wxUSE_UNICODE
11888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11889 #else
11890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11891 #endif
11892 }
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 SWIGINTERN PyObject *_wrap_Font_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11900 PyObject *resultobj = 0;
11901 wxFont *arg1 = (wxFont *) 0 ;
11902 wxFontEncoding result;
11903 void *argp1 = 0 ;
11904 int res1 = 0 ;
11905 PyObject *swig_obj[1] ;
11906
11907 if (!args) SWIG_fail;
11908 swig_obj[0] = args;
11909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11910 if (!SWIG_IsOK(res1)) {
11911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetEncoding" "', expected argument " "1"" of type '" "wxFont const *""'");
11912 }
11913 arg1 = reinterpret_cast< wxFont * >(argp1);
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 resultobj = SWIG_From_int(static_cast< int >(result));
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11928 PyObject *resultobj = 0;
11929 wxFont *arg1 = (wxFont *) 0 ;
11930 wxNativeFontInfo *result = 0 ;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 PyObject *swig_obj[1] ;
11934
11935 if (!args) SWIG_fail;
11936 swig_obj[0] = args;
11937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11938 if (!SWIG_IsOK(res1)) {
11939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont const *""'");
11940 }
11941 arg1 = reinterpret_cast< wxFont * >(argp1);
11942 {
11943 PyThreadState* __tstate = wxPyBeginAllowThreads();
11944 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11949 return resultobj;
11950 fail:
11951 return NULL;
11952 }
11953
11954
11955 SWIGINTERN PyObject *_wrap_Font_IsFixedWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11956 PyObject *resultobj = 0;
11957 wxFont *arg1 = (wxFont *) 0 ;
11958 bool result;
11959 void *argp1 = 0 ;
11960 int res1 = 0 ;
11961 PyObject *swig_obj[1] ;
11962
11963 if (!args) SWIG_fail;
11964 swig_obj[0] = args;
11965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11966 if (!SWIG_IsOK(res1)) {
11967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsFixedWidth" "', expected argument " "1"" of type '" "wxFont const *""'");
11968 }
11969 arg1 = reinterpret_cast< wxFont * >(argp1);
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 {
11977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11978 }
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 PyObject *resultobj = 0;
11987 wxFont *arg1 = (wxFont *) 0 ;
11988 wxString result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 PyObject *swig_obj[1] ;
11992
11993 if (!args) SWIG_fail;
11994 swig_obj[0] = args;
11995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
11996 if (!SWIG_IsOK(res1)) {
11997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
11998 }
11999 arg1 = reinterpret_cast< wxFont * >(argp1);
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 {
12007 #if wxUSE_UNICODE
12008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12009 #else
12010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12011 #endif
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020 PyObject *resultobj = 0;
12021 wxFont *arg1 = (wxFont *) 0 ;
12022 wxString result;
12023 void *argp1 = 0 ;
12024 int res1 = 0 ;
12025 PyObject *swig_obj[1] ;
12026
12027 if (!args) SWIG_fail;
12028 swig_obj[0] = args;
12029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
12032 }
12033 arg1 = reinterpret_cast< wxFont * >(argp1);
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 #if wxUSE_UNICODE
12042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12043 #else
12044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12045 #endif
12046 }
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 SWIGINTERN PyObject *_wrap_Font_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj = 0;
12055 wxFont *arg1 = (wxFont *) 0 ;
12056 int arg2 ;
12057 void *argp1 = 0 ;
12058 int res1 = 0 ;
12059 int val2 ;
12060 int ecode2 = 0 ;
12061 PyObject * obj0 = 0 ;
12062 PyObject * obj1 = 0 ;
12063 char * kwnames[] = {
12064 (char *) "self",(char *) "pointSize", NULL
12065 };
12066
12067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
12068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12069 if (!SWIG_IsOK(res1)) {
12070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPointSize" "', expected argument " "1"" of type '" "wxFont *""'");
12071 }
12072 arg1 = reinterpret_cast< wxFont * >(argp1);
12073 ecode2 = SWIG_AsVal_int(obj1, &val2);
12074 if (!SWIG_IsOK(ecode2)) {
12075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetPointSize" "', expected argument " "2"" of type '" "int""'");
12076 }
12077 arg2 = static_cast< int >(val2);
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 (arg1)->SetPointSize(arg2);
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 resultobj = SWIG_Py_Void();
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 SWIGINTERN PyObject *_wrap_Font_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = 0;
12093 wxFont *arg1 = (wxFont *) 0 ;
12094 wxSize *arg2 = 0 ;
12095 void *argp1 = 0 ;
12096 int res1 = 0 ;
12097 wxSize temp2 ;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "self",(char *) "pixelSize", NULL
12102 };
12103
12104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
12105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12106 if (!SWIG_IsOK(res1)) {
12107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPixelSize" "', expected argument " "1"" of type '" "wxFont *""'");
12108 }
12109 arg1 = reinterpret_cast< wxFont * >(argp1);
12110 {
12111 arg2 = &temp2;
12112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12113 }
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 (arg1)->SetPixelSize((wxSize const &)*arg2);
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 resultobj = SWIG_Py_Void();
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 SWIGINTERN PyObject *_wrap_Font_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj = 0;
12129 wxFont *arg1 = (wxFont *) 0 ;
12130 int arg2 ;
12131 void *argp1 = 0 ;
12132 int res1 = 0 ;
12133 int val2 ;
12134 int ecode2 = 0 ;
12135 PyObject * obj0 = 0 ;
12136 PyObject * obj1 = 0 ;
12137 char * kwnames[] = {
12138 (char *) "self",(char *) "family", NULL
12139 };
12140
12141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
12142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFamily" "', expected argument " "1"" of type '" "wxFont *""'");
12145 }
12146 arg1 = reinterpret_cast< wxFont * >(argp1);
12147 ecode2 = SWIG_AsVal_int(obj1, &val2);
12148 if (!SWIG_IsOK(ecode2)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetFamily" "', expected argument " "2"" of type '" "int""'");
12150 }
12151 arg2 = static_cast< int >(val2);
12152 {
12153 PyThreadState* __tstate = wxPyBeginAllowThreads();
12154 (arg1)->SetFamily(arg2);
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 resultobj = SWIG_Py_Void();
12159 return resultobj;
12160 fail:
12161 return NULL;
12162 }
12163
12164
12165 SWIGINTERN PyObject *_wrap_Font_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12166 PyObject *resultobj = 0;
12167 wxFont *arg1 = (wxFont *) 0 ;
12168 int arg2 ;
12169 void *argp1 = 0 ;
12170 int res1 = 0 ;
12171 int val2 ;
12172 int ecode2 = 0 ;
12173 PyObject * obj0 = 0 ;
12174 PyObject * obj1 = 0 ;
12175 char * kwnames[] = {
12176 (char *) "self",(char *) "style", NULL
12177 };
12178
12179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
12180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12181 if (!SWIG_IsOK(res1)) {
12182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetStyle" "', expected argument " "1"" of type '" "wxFont *""'");
12183 }
12184 arg1 = reinterpret_cast< wxFont * >(argp1);
12185 ecode2 = SWIG_AsVal_int(obj1, &val2);
12186 if (!SWIG_IsOK(ecode2)) {
12187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetStyle" "', expected argument " "2"" of type '" "int""'");
12188 }
12189 arg2 = static_cast< int >(val2);
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 (arg1)->SetStyle(arg2);
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 resultobj = SWIG_Py_Void();
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *_wrap_Font_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12204 PyObject *resultobj = 0;
12205 wxFont *arg1 = (wxFont *) 0 ;
12206 int arg2 ;
12207 void *argp1 = 0 ;
12208 int res1 = 0 ;
12209 int val2 ;
12210 int ecode2 = 0 ;
12211 PyObject * obj0 = 0 ;
12212 PyObject * obj1 = 0 ;
12213 char * kwnames[] = {
12214 (char *) "self",(char *) "weight", NULL
12215 };
12216
12217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
12218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12219 if (!SWIG_IsOK(res1)) {
12220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetWeight" "', expected argument " "1"" of type '" "wxFont *""'");
12221 }
12222 arg1 = reinterpret_cast< wxFont * >(argp1);
12223 ecode2 = SWIG_AsVal_int(obj1, &val2);
12224 if (!SWIG_IsOK(ecode2)) {
12225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetWeight" "', expected argument " "2"" of type '" "int""'");
12226 }
12227 arg2 = static_cast< int >(val2);
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 (arg1)->SetWeight(arg2);
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 resultobj = SWIG_Py_Void();
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 SWIGINTERN PyObject *_wrap_Font_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj = 0;
12243 wxFont *arg1 = (wxFont *) 0 ;
12244 wxString *arg2 = 0 ;
12245 bool result;
12246 void *argp1 = 0 ;
12247 int res1 = 0 ;
12248 bool temp2 = false ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "faceName", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFaceName" "', expected argument " "1"" of type '" "wxFont *""'");
12259 }
12260 arg1 = reinterpret_cast< wxFont * >(argp1);
12261 {
12262 arg2 = wxString_in_helper(obj1);
12263 if (arg2 == NULL) SWIG_fail;
12264 temp2 = true;
12265 }
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (bool)(arg1)->SetFaceName((wxString const &)*arg2);
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12274 }
12275 {
12276 if (temp2)
12277 delete arg2;
12278 }
12279 return resultobj;
12280 fail:
12281 {
12282 if (temp2)
12283 delete arg2;
12284 }
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_Font_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 wxFont *arg1 = (wxFont *) 0 ;
12292 bool arg2 ;
12293 void *argp1 = 0 ;
12294 int res1 = 0 ;
12295 bool val2 ;
12296 int ecode2 = 0 ;
12297 PyObject * obj0 = 0 ;
12298 PyObject * obj1 = 0 ;
12299 char * kwnames[] = {
12300 (char *) "self",(char *) "underlined", NULL
12301 };
12302
12303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
12304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12305 if (!SWIG_IsOK(res1)) {
12306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetUnderlined" "', expected argument " "1"" of type '" "wxFont *""'");
12307 }
12308 arg1 = reinterpret_cast< wxFont * >(argp1);
12309 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12310 if (!SWIG_IsOK(ecode2)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
12312 }
12313 arg2 = static_cast< bool >(val2);
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 (arg1)->SetUnderlined(arg2);
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 resultobj = SWIG_Py_Void();
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 SWIGINTERN PyObject *_wrap_Font_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj = 0;
12329 wxFont *arg1 = (wxFont *) 0 ;
12330 wxFontEncoding arg2 ;
12331 void *argp1 = 0 ;
12332 int res1 = 0 ;
12333 int val2 ;
12334 int ecode2 = 0 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 char * kwnames[] = {
12338 (char *) "self",(char *) "encoding", NULL
12339 };
12340
12341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
12342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12343 if (!SWIG_IsOK(res1)) {
12344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetEncoding" "', expected argument " "1"" of type '" "wxFont *""'");
12345 }
12346 arg1 = reinterpret_cast< wxFont * >(argp1);
12347 ecode2 = SWIG_AsVal_int(obj1, &val2);
12348 if (!SWIG_IsOK(ecode2)) {
12349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12350 }
12351 arg2 = static_cast< wxFontEncoding >(val2);
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 (arg1)->SetEncoding(arg2);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj = 0;
12367 wxFont *arg1 = (wxFont *) 0 ;
12368 wxNativeFontInfo *arg2 = 0 ;
12369 void *argp1 = 0 ;
12370 int res1 = 0 ;
12371 void *argp2 = 0 ;
12372 int res2 = 0 ;
12373 PyObject * obj0 = 0 ;
12374 PyObject * obj1 = 0 ;
12375 char * kwnames[] = {
12376 (char *) "self",(char *) "info", NULL
12377 };
12378
12379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) SWIG_fail;
12380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12381 if (!SWIG_IsOK(res1)) {
12382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont *""'");
12383 }
12384 arg1 = reinterpret_cast< wxFont * >(argp1);
12385 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
12386 if (!SWIG_IsOK(res2)) {
12387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
12388 }
12389 if (!argp2) {
12390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
12391 }
12392 arg2 = reinterpret_cast< wxNativeFontInfo * >(argp2);
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 resultobj = SWIG_Py_Void();
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12407 PyObject *resultobj = 0;
12408 wxFont *arg1 = (wxFont *) 0 ;
12409 wxString *arg2 = 0 ;
12410 bool result;
12411 void *argp1 = 0 ;
12412 int res1 = 0 ;
12413 bool temp2 = false ;
12414 PyObject * obj0 = 0 ;
12415 PyObject * obj1 = 0 ;
12416 char * kwnames[] = {
12417 (char *) "self",(char *) "info", NULL
12418 };
12419
12420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) SWIG_fail;
12421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12422 if (!SWIG_IsOK(res1)) {
12423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoFromString" "', expected argument " "1"" of type '" "wxFont *""'");
12424 }
12425 arg1 = reinterpret_cast< wxFont * >(argp1);
12426 {
12427 arg2 = wxString_in_helper(obj1);
12428 if (arg2 == NULL) SWIG_fail;
12429 temp2 = true;
12430 }
12431 {
12432 PyThreadState* __tstate = wxPyBeginAllowThreads();
12433 result = (bool)(arg1)->SetNativeFontInfo((wxString const &)*arg2);
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 {
12438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12439 }
12440 {
12441 if (temp2)
12442 delete arg2;
12443 }
12444 return resultobj;
12445 fail:
12446 {
12447 if (temp2)
12448 delete arg2;
12449 }
12450 return NULL;
12451 }
12452
12453
12454 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj = 0;
12456 wxFont *arg1 = (wxFont *) 0 ;
12457 wxString *arg2 = 0 ;
12458 bool result;
12459 void *argp1 = 0 ;
12460 int res1 = 0 ;
12461 bool temp2 = false ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 char * kwnames[] = {
12465 (char *) "self",(char *) "info", NULL
12466 };
12467
12468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) SWIG_fail;
12469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12470 if (!SWIG_IsOK(res1)) {
12471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont *""'");
12472 }
12473 arg1 = reinterpret_cast< wxFont * >(argp1);
12474 {
12475 arg2 = wxString_in_helper(obj1);
12476 if (arg2 == NULL) SWIG_fail;
12477 temp2 = true;
12478 }
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (bool)(arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 {
12486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12487 }
12488 {
12489 if (temp2)
12490 delete arg2;
12491 }
12492 return resultobj;
12493 fail:
12494 {
12495 if (temp2)
12496 delete arg2;
12497 }
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_Font_GetFamilyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12503 PyObject *resultobj = 0;
12504 wxFont *arg1 = (wxFont *) 0 ;
12505 wxString result;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject *swig_obj[1] ;
12509
12510 if (!args) SWIG_fail;
12511 swig_obj[0] = args;
12512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamilyString" "', expected argument " "1"" of type '" "wxFont const *""'");
12515 }
12516 arg1 = reinterpret_cast< wxFont * >(argp1);
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 result = ((wxFont const *)arg1)->GetFamilyString();
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 {
12524 #if wxUSE_UNICODE
12525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12526 #else
12527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12528 #endif
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_Font_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12537 PyObject *resultobj = 0;
12538 wxFont *arg1 = (wxFont *) 0 ;
12539 wxString result;
12540 void *argp1 = 0 ;
12541 int res1 = 0 ;
12542 PyObject *swig_obj[1] ;
12543
12544 if (!args) SWIG_fail;
12545 swig_obj[0] = args;
12546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12547 if (!SWIG_IsOK(res1)) {
12548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyleString" "', expected argument " "1"" of type '" "wxFont const *""'");
12549 }
12550 arg1 = reinterpret_cast< wxFont * >(argp1);
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = ((wxFont const *)arg1)->GetStyleString();
12554 wxPyEndAllowThreads(__tstate);
12555 if (PyErr_Occurred()) SWIG_fail;
12556 }
12557 {
12558 #if wxUSE_UNICODE
12559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12560 #else
12561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12562 #endif
12563 }
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *_wrap_Font_GetWeightString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12571 PyObject *resultobj = 0;
12572 wxFont *arg1 = (wxFont *) 0 ;
12573 wxString result;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 PyObject *swig_obj[1] ;
12577
12578 if (!args) SWIG_fail;
12579 swig_obj[0] = args;
12580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12581 if (!SWIG_IsOK(res1)) {
12582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeightString" "', expected argument " "1"" of type '" "wxFont const *""'");
12583 }
12584 arg1 = reinterpret_cast< wxFont * >(argp1);
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = ((wxFont const *)arg1)->GetWeightString();
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 #if wxUSE_UNICODE
12593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12594 #else
12595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12596 #endif
12597 }
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 SWIGINTERN PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj = 0;
12606 wxFont *arg1 = (wxFont *) 0 ;
12607 bool arg2 = (bool) true ;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 bool val2 ;
12611 int ecode2 = 0 ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "self",(char *) "no", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;
12619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12620 if (!SWIG_IsOK(res1)) {
12621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont *""'");
12622 }
12623 arg1 = reinterpret_cast< wxFont * >(argp1);
12624 if (obj1) {
12625 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12626 if (!SWIG_IsOK(ecode2)) {
12627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "2"" of type '" "bool""'");
12628 }
12629 arg2 = static_cast< bool >(val2);
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 (arg1)->SetNoAntiAliasing(arg2);
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 resultobj = SWIG_Py_Void();
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 PyObject *resultobj = 0;
12646 wxFont *arg1 = (wxFont *) 0 ;
12647 bool result;
12648 void *argp1 = 0 ;
12649 int res1 = 0 ;
12650 PyObject *swig_obj[1] ;
12651
12652 if (!args) SWIG_fail;
12653 swig_obj[0] = args;
12654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
12655 if (!SWIG_IsOK(res1)) {
12656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont const *""'");
12657 }
12658 arg1 = reinterpret_cast< wxFont * >(argp1);
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 {
12666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12667 }
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Font_GetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676 wxFontEncoding result;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Font_GetDefaultEncoding",0,0,0)) SWIG_fail;
12679 {
12680 if (!wxPyCheckForApp()) SWIG_fail;
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 resultobj = SWIG_From_int(static_cast< int >(result));
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 SWIGINTERN PyObject *_wrap_Font_SetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj = 0;
12695 wxFontEncoding arg1 ;
12696 int val1 ;
12697 int ecode1 = 0 ;
12698 PyObject * obj0 = 0 ;
12699 char * kwnames[] = {
12700 (char *) "encoding", NULL
12701 };
12702
12703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) SWIG_fail;
12704 ecode1 = SWIG_AsVal_int(obj0, &val1);
12705 if (!SWIG_IsOK(ecode1)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Font_SetDefaultEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12707 }
12708 arg1 = static_cast< wxFontEncoding >(val1);
12709 {
12710 if (!wxPyCheckForApp()) SWIG_fail;
12711 PyThreadState* __tstate = wxPyBeginAllowThreads();
12712 wxFont::SetDefaultEncoding(arg1);
12713 wxPyEndAllowThreads(__tstate);
12714 if (PyErr_Occurred()) SWIG_fail;
12715 }
12716 resultobj = SWIG_Py_Void();
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *Font_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *obj;
12725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12726 SWIG_TypeNewClientData(SWIGTYPE_p_wxFont, SWIG_NewClientData(obj));
12727 return SWIG_Py_Void();
12728 }
12729
12730 SWIGINTERN PyObject *Font_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12731 return SWIG_Python_InitShadowInstance(args);
12732 }
12733
12734 SWIGINTERN PyObject *_wrap_new_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12735 PyObject *resultobj = 0;
12736 wxPyFontEnumerator *result = 0 ;
12737
12738 if (!SWIG_Python_UnpackTuple(args,"new_FontEnumerator",0,0,0)) SWIG_fail;
12739 {
12740 if (!wxPyCheckForApp()) SWIG_fail;
12741 PyThreadState* __tstate = wxPyBeginAllowThreads();
12742 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_NEW | 0 );
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 SWIGINTERN PyObject *_wrap_delete_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12754 PyObject *resultobj = 0;
12755 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 PyObject *swig_obj[1] ;
12759
12760 if (!args) SWIG_fail;
12761 swig_obj[0] = args;
12762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_DISOWN | 0 );
12763 if (!SWIG_IsOK(res1)) {
12764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontEnumerator" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12765 }
12766 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 delete arg1;
12770
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_Py_Void();
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12784 PyObject *arg2 = (PyObject *) 0 ;
12785 PyObject *arg3 = (PyObject *) 0 ;
12786 bool arg4 ;
12787 void *argp1 = 0 ;
12788 int res1 = 0 ;
12789 bool val4 ;
12790 int ecode4 = 0 ;
12791 PyObject * obj0 = 0 ;
12792 PyObject * obj1 = 0 ;
12793 PyObject * obj2 = 0 ;
12794 PyObject * obj3 = 0 ;
12795 char * kwnames[] = {
12796 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
12797 };
12798
12799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12803 }
12804 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12805 arg2 = obj1;
12806 arg3 = obj2;
12807 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12808 if (!SWIG_IsOK(ecode4)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
12810 }
12811 arg4 = static_cast< bool >(val4);
12812 {
12813 PyThreadState* __tstate = wxPyBeginAllowThreads();
12814 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 resultobj = SWIG_Py_Void();
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj = 0;
12827 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12828 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
12829 bool arg3 = (bool) false ;
12830 bool result;
12831 void *argp1 = 0 ;
12832 int res1 = 0 ;
12833 int val2 ;
12834 int ecode2 = 0 ;
12835 bool val3 ;
12836 int ecode3 = 0 ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 PyObject * obj2 = 0 ;
12840 char * kwnames[] = {
12841 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
12842 };
12843
12844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12848 }
12849 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12850 if (obj1) {
12851 ecode2 = SWIG_AsVal_int(obj1, &val2);
12852 if (!SWIG_IsOK(ecode2)) {
12853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12854 }
12855 arg2 = static_cast< wxFontEncoding >(val2);
12856 }
12857 if (obj2) {
12858 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12859 if (!SWIG_IsOK(ecode3)) {
12860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "3"" of type '" "bool""'");
12861 }
12862 arg3 = static_cast< bool >(val3);
12863 }
12864 {
12865 PyThreadState* __tstate = wxPyBeginAllowThreads();
12866 result = (bool)(arg1)->EnumerateFacenames(arg2,arg3);
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 {
12871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12872 }
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12880 PyObject *resultobj = 0;
12881 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
12882 wxString const &arg2_defvalue = wxPyEmptyString ;
12883 wxString *arg2 = (wxString *) &arg2_defvalue ;
12884 bool result;
12885 void *argp1 = 0 ;
12886 int res1 = 0 ;
12887 bool temp2 = false ;
12888 PyObject * obj0 = 0 ;
12889 PyObject * obj1 = 0 ;
12890 char * kwnames[] = {
12891 (char *) "self",(char *) "facename", NULL
12892 };
12893
12894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) SWIG_fail;
12895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
12896 if (!SWIG_IsOK(res1)) {
12897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
12898 }
12899 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
12900 if (obj1) {
12901 {
12902 arg2 = wxString_in_helper(obj1);
12903 if (arg2 == NULL) SWIG_fail;
12904 temp2 = true;
12905 }
12906 }
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 {
12914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12915 }
12916 {
12917 if (temp2)
12918 delete arg2;
12919 }
12920 return resultobj;
12921 fail:
12922 {
12923 if (temp2)
12924 delete arg2;
12925 }
12926 return NULL;
12927 }
12928
12929
12930 SWIGINTERN PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 PyObject *resultobj = 0;
12932 PyObject *result = 0 ;
12933
12934 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetEncodings",0,0,0)) SWIG_fail;
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (PyObject *)wxPyFontEnumerator_GetEncodings();
12938 wxPyEndAllowThreads(__tstate);
12939 if (PyErr_Occurred()) SWIG_fail;
12940 }
12941 resultobj = result;
12942 return resultobj;
12943 fail:
12944 return NULL;
12945 }
12946
12947
12948 SWIGINTERN PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12949 PyObject *resultobj = 0;
12950 PyObject *result = 0 ;
12951
12952 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetFacenames",0,0,0)) SWIG_fail;
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 result = (PyObject *)wxPyFontEnumerator_GetFacenames();
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 resultobj = result;
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *_wrap_FontEnumerator_IsValidFacename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj = 0;
12968 wxString *arg1 = 0 ;
12969 bool result;
12970 bool temp1 = false ;
12971 PyObject * obj0 = 0 ;
12972 char * kwnames[] = {
12973 (char *) "str", NULL
12974 };
12975
12976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_IsValidFacename",kwnames,&obj0)) SWIG_fail;
12977 {
12978 arg1 = wxString_in_helper(obj0);
12979 if (arg1 == NULL) SWIG_fail;
12980 temp1 = true;
12981 }
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (bool)wxPyFontEnumerator::IsValidFacename((wxString const &)*arg1);
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12990 }
12991 {
12992 if (temp1)
12993 delete arg1;
12994 }
12995 return resultobj;
12996 fail:
12997 {
12998 if (temp1)
12999 delete arg1;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *FontEnumerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 PyObject *obj;
13007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13008 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFontEnumerator, SWIG_NewClientData(obj));
13009 return SWIG_Py_Void();
13010 }
13011
13012 SWIGINTERN PyObject *FontEnumerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13013 return SWIG_Python_InitShadowInstance(args);
13014 }
13015
13016 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13017 PyObject *resultobj = 0;
13018 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13019 int arg2 ;
13020 void *argp1 = 0 ;
13021 int res1 = 0 ;
13022 int val2 ;
13023 int ecode2 = 0 ;
13024 PyObject *swig_obj[2] ;
13025
13026 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Language_set",2,2,swig_obj)) SWIG_fail;
13027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13028 if (!SWIG_IsOK(res1)) {
13029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13030 }
13031 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13032 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13033 if (!SWIG_IsOK(ecode2)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LanguageInfo_Language_set" "', expected argument " "2"" of type '" "int""'");
13035 }
13036 arg2 = static_cast< int >(val2);
13037 if (arg1) (arg1)->Language = arg2;
13038
13039 resultobj = SWIG_Py_Void();
13040 return resultobj;
13041 fail:
13042 return NULL;
13043 }
13044
13045
13046 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13047 PyObject *resultobj = 0;
13048 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13049 int result;
13050 void *argp1 = 0 ;
13051 int res1 = 0 ;
13052 PyObject *swig_obj[1] ;
13053
13054 if (!args) SWIG_fail;
13055 swig_obj[0] = args;
13056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13057 if (!SWIG_IsOK(res1)) {
13058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13059 }
13060 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13061 result = (int) ((arg1)->Language);
13062 resultobj = SWIG_From_int(static_cast< int >(result));
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13070 PyObject *resultobj = 0;
13071 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13072 wxString *arg2 = (wxString *) 0 ;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 bool temp2 = false ;
13076 PyObject *swig_obj[2] ;
13077
13078 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_CanonicalName_set",2,2,swig_obj)) SWIG_fail;
13079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13082 }
13083 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13084 {
13085 arg2 = wxString_in_helper(swig_obj[1]);
13086 if (arg2 == NULL) SWIG_fail;
13087 temp2 = true;
13088 }
13089 if (arg1) (arg1)->CanonicalName = *arg2;
13090
13091 resultobj = SWIG_Py_Void();
13092 {
13093 if (temp2)
13094 delete arg2;
13095 }
13096 return resultobj;
13097 fail:
13098 {
13099 if (temp2)
13100 delete arg2;
13101 }
13102 return NULL;
13103 }
13104
13105
13106 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 PyObject *resultobj = 0;
13108 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13109 wxString *result = 0 ;
13110 void *argp1 = 0 ;
13111 int res1 = 0 ;
13112 PyObject *swig_obj[1] ;
13113
13114 if (!args) SWIG_fail;
13115 swig_obj[0] = args;
13116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13117 if (!SWIG_IsOK(res1)) {
13118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13119 }
13120 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13121 result = (wxString *)& ((arg1)->CanonicalName);
13122 {
13123 #if wxUSE_UNICODE
13124 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13125 #else
13126 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13127 #endif
13128 }
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13136 PyObject *resultobj = 0;
13137 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13138 wxString *arg2 = (wxString *) 0 ;
13139 void *argp1 = 0 ;
13140 int res1 = 0 ;
13141 bool temp2 = false ;
13142 PyObject *swig_obj[2] ;
13143
13144 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Description_set",2,2,swig_obj)) SWIG_fail;
13145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13146 if (!SWIG_IsOK(res1)) {
13147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13148 }
13149 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13150 {
13151 arg2 = wxString_in_helper(swig_obj[1]);
13152 if (arg2 == NULL) SWIG_fail;
13153 temp2 = true;
13154 }
13155 if (arg1) (arg1)->Description = *arg2;
13156
13157 resultobj = SWIG_Py_Void();
13158 {
13159 if (temp2)
13160 delete arg2;
13161 }
13162 return resultobj;
13163 fail:
13164 {
13165 if (temp2)
13166 delete arg2;
13167 }
13168 return NULL;
13169 }
13170
13171
13172 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13173 PyObject *resultobj = 0;
13174 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
13175 wxString *result = 0 ;
13176 void *argp1 = 0 ;
13177 int res1 = 0 ;
13178 PyObject *swig_obj[1] ;
13179
13180 if (!args) SWIG_fail;
13181 swig_obj[0] = args;
13182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13183 if (!SWIG_IsOK(res1)) {
13184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
13185 }
13186 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13187 result = (wxString *)& ((arg1)->Description);
13188 {
13189 #if wxUSE_UNICODE
13190 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13191 #else
13192 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13193 #endif
13194 }
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *LanguageInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13202 PyObject *obj;
13203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13204 SWIG_TypeNewClientData(SWIGTYPE_p_wxLanguageInfo, SWIG_NewClientData(obj));
13205 return SWIG_Py_Void();
13206 }
13207
13208 SWIGINTERN PyObject *_wrap_new_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = 0;
13210 int arg1 = (int) -1 ;
13211 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
13212 wxLocale *result = 0 ;
13213 int val1 ;
13214 int ecode1 = 0 ;
13215 int val2 ;
13216 int ecode2 = 0 ;
13217 PyObject * obj0 = 0 ;
13218 PyObject * obj1 = 0 ;
13219 char * kwnames[] = {
13220 (char *) "language",(char *) "flags", NULL
13221 };
13222
13223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) SWIG_fail;
13224 if (obj0) {
13225 ecode1 = SWIG_AsVal_int(obj0, &val1);
13226 if (!SWIG_IsOK(ecode1)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Locale" "', expected argument " "1"" of type '" "int""'");
13228 }
13229 arg1 = static_cast< int >(val1);
13230 }
13231 if (obj1) {
13232 ecode2 = SWIG_AsVal_int(obj1, &val2);
13233 if (!SWIG_IsOK(ecode2)) {
13234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Locale" "', expected argument " "2"" of type '" "int""'");
13235 }
13236 arg2 = static_cast< int >(val2);
13237 }
13238 {
13239 PyThreadState* __tstate = wxPyBeginAllowThreads();
13240 result = (wxLocale *)new_wxLocale(arg1,arg2);
13241 wxPyEndAllowThreads(__tstate);
13242 if (PyErr_Occurred()) SWIG_fail;
13243 }
13244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, SWIG_POINTER_NEW | 0 );
13245 return resultobj;
13246 fail:
13247 return NULL;
13248 }
13249
13250
13251 SWIGINTERN PyObject *_wrap_delete_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13252 PyObject *resultobj = 0;
13253 wxLocale *arg1 = (wxLocale *) 0 ;
13254 void *argp1 = 0 ;
13255 int res1 = 0 ;
13256 PyObject *swig_obj[1] ;
13257
13258 if (!args) SWIG_fail;
13259 swig_obj[0] = args;
13260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, SWIG_POINTER_DISOWN | 0 );
13261 if (!SWIG_IsOK(res1)) {
13262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locale" "', expected argument " "1"" of type '" "wxLocale *""'");
13263 }
13264 arg1 = reinterpret_cast< wxLocale * >(argp1);
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 delete arg1;
13268
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 resultobj = SWIG_Py_Void();
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 SWIGINTERN PyObject *_wrap_Locale_Init1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj = 0;
13281 wxLocale *arg1 = (wxLocale *) 0 ;
13282 wxString *arg2 = 0 ;
13283 wxString const &arg3_defvalue = wxPyEmptyString ;
13284 wxString *arg3 = (wxString *) &arg3_defvalue ;
13285 wxString const &arg4_defvalue = wxPyEmptyString ;
13286 wxString *arg4 = (wxString *) &arg4_defvalue ;
13287 bool arg5 = (bool) true ;
13288 bool arg6 = (bool) false ;
13289 bool result;
13290 void *argp1 = 0 ;
13291 int res1 = 0 ;
13292 bool temp2 = false ;
13293 bool temp3 = false ;
13294 bool temp4 = false ;
13295 bool val5 ;
13296 int ecode5 = 0 ;
13297 bool val6 ;
13298 int ecode6 = 0 ;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 PyObject * obj2 = 0 ;
13302 PyObject * obj3 = 0 ;
13303 PyObject * obj4 = 0 ;
13304 PyObject * obj5 = 0 ;
13305 char * kwnames[] = {
13306 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
13307 };
13308
13309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13311 if (!SWIG_IsOK(res1)) {
13312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init1" "', expected argument " "1"" of type '" "wxLocale *""'");
13313 }
13314 arg1 = reinterpret_cast< wxLocale * >(argp1);
13315 {
13316 arg2 = wxString_in_helper(obj1);
13317 if (arg2 == NULL) SWIG_fail;
13318 temp2 = true;
13319 }
13320 if (obj2) {
13321 {
13322 arg3 = wxString_in_helper(obj2);
13323 if (arg3 == NULL) SWIG_fail;
13324 temp3 = true;
13325 }
13326 }
13327 if (obj3) {
13328 {
13329 arg4 = wxString_in_helper(obj3);
13330 if (arg4 == NULL) SWIG_fail;
13331 temp4 = true;
13332 }
13333 }
13334 if (obj4) {
13335 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13336 if (!SWIG_IsOK(ecode5)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Locale_Init1" "', expected argument " "5"" of type '" "bool""'");
13338 }
13339 arg5 = static_cast< bool >(val5);
13340 }
13341 if (obj5) {
13342 ecode6 = SWIG_AsVal_bool(obj5, &val6);
13343 if (!SWIG_IsOK(ecode6)) {
13344 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Locale_Init1" "', expected argument " "6"" of type '" "bool""'");
13345 }
13346 arg6 = static_cast< bool >(val6);
13347 }
13348 {
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
13351 wxPyEndAllowThreads(__tstate);
13352 if (PyErr_Occurred()) SWIG_fail;
13353 }
13354 {
13355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13356 }
13357 {
13358 if (temp2)
13359 delete arg2;
13360 }
13361 {
13362 if (temp3)
13363 delete arg3;
13364 }
13365 {
13366 if (temp4)
13367 delete arg4;
13368 }
13369 return resultobj;
13370 fail:
13371 {
13372 if (temp2)
13373 delete arg2;
13374 }
13375 {
13376 if (temp3)
13377 delete arg3;
13378 }
13379 {
13380 if (temp4)
13381 delete arg4;
13382 }
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_Locale_Init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj = 0;
13389 wxLocale *arg1 = (wxLocale *) 0 ;
13390 int arg2 = (int) wxLANGUAGE_DEFAULT ;
13391 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
13392 bool result;
13393 void *argp1 = 0 ;
13394 int res1 = 0 ;
13395 int val2 ;
13396 int ecode2 = 0 ;
13397 int val3 ;
13398 int ecode3 = 0 ;
13399 PyObject * obj0 = 0 ;
13400 PyObject * obj1 = 0 ;
13401 PyObject * obj2 = 0 ;
13402 char * kwnames[] = {
13403 (char *) "self",(char *) "language",(char *) "flags", NULL
13404 };
13405
13406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13408 if (!SWIG_IsOK(res1)) {
13409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init2" "', expected argument " "1"" of type '" "wxLocale *""'");
13410 }
13411 arg1 = reinterpret_cast< wxLocale * >(argp1);
13412 if (obj1) {
13413 ecode2 = SWIG_AsVal_int(obj1, &val2);
13414 if (!SWIG_IsOK(ecode2)) {
13415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Locale_Init2" "', expected argument " "2"" of type '" "int""'");
13416 }
13417 arg2 = static_cast< int >(val2);
13418 }
13419 if (obj2) {
13420 ecode3 = SWIG_AsVal_int(obj2, &val3);
13421 if (!SWIG_IsOK(ecode3)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Locale_Init2" "', expected argument " "3"" of type '" "int""'");
13423 }
13424 arg3 = static_cast< int >(val3);
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13434 }
13435 return resultobj;
13436 fail:
13437 return NULL;
13438 }
13439
13440
13441 SWIGINTERN PyObject *_wrap_Locale_GetSystemLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13442 PyObject *resultobj = 0;
13443 int result;
13444
13445 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemLanguage",0,0,0)) SWIG_fail;
13446 {
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (int)wxLocale::GetSystemLanguage();
13449 wxPyEndAllowThreads(__tstate);
13450 if (PyErr_Occurred()) SWIG_fail;
13451 }
13452 resultobj = SWIG_From_int(static_cast< int >(result));
13453 return resultobj;
13454 fail:
13455 return NULL;
13456 }
13457
13458
13459 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13460 PyObject *resultobj = 0;
13461 wxFontEncoding result;
13462
13463 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncoding",0,0,0)) SWIG_fail;
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_From_int(static_cast< int >(result));
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13478 PyObject *resultobj = 0;
13479 wxString result;
13480
13481 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncodingName",0,0,0)) SWIG_fail;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = wxLocale::GetSystemEncodingName();
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 {
13489 #if wxUSE_UNICODE
13490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13491 #else
13492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13493 #endif
13494 }
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 SWIGINTERN PyObject *_wrap_Locale_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13502 PyObject *resultobj = 0;
13503 wxLocale *arg1 = (wxLocale *) 0 ;
13504 bool result;
13505 void *argp1 = 0 ;
13506 int res1 = 0 ;
13507 PyObject *swig_obj[1] ;
13508
13509 if (!args) SWIG_fail;
13510 swig_obj[0] = args;
13511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13512 if (!SWIG_IsOK(res1)) {
13513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsOk" "', expected argument " "1"" of type '" "wxLocale const *""'");
13514 }
13515 arg1 = reinterpret_cast< wxLocale * >(argp1);
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (bool)((wxLocale const *)arg1)->IsOk();
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 {
13523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13524 }
13525 return resultobj;
13526 fail:
13527 return NULL;
13528 }
13529
13530
13531 SWIGINTERN PyObject *_wrap_Locale_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13532 PyObject *resultobj = 0;
13533 wxLocale *arg1 = (wxLocale *) 0 ;
13534 wxString result;
13535 void *argp1 = 0 ;
13536 int res1 = 0 ;
13537 PyObject *swig_obj[1] ;
13538
13539 if (!args) SWIG_fail;
13540 swig_obj[0] = args;
13541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13542 if (!SWIG_IsOK(res1)) {
13543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLocale" "', expected argument " "1"" of type '" "wxLocale const *""'");
13544 }
13545 arg1 = reinterpret_cast< wxLocale * >(argp1);
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = ((wxLocale const *)arg1)->GetLocale();
13549 wxPyEndAllowThreads(__tstate);
13550 if (PyErr_Occurred()) SWIG_fail;
13551 }
13552 {
13553 #if wxUSE_UNICODE
13554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13555 #else
13556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13557 #endif
13558 }
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 SWIGINTERN PyObject *_wrap_Locale_GetLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13566 PyObject *resultobj = 0;
13567 wxLocale *arg1 = (wxLocale *) 0 ;
13568 int result;
13569 void *argp1 = 0 ;
13570 int res1 = 0 ;
13571 PyObject *swig_obj[1] ;
13572
13573 if (!args) SWIG_fail;
13574 swig_obj[0] = args;
13575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13576 if (!SWIG_IsOK(res1)) {
13577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLanguage" "', expected argument " "1"" of type '" "wxLocale const *""'");
13578 }
13579 arg1 = reinterpret_cast< wxLocale * >(argp1);
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 result = (int)((wxLocale const *)arg1)->GetLanguage();
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 resultobj = SWIG_From_int(static_cast< int >(result));
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *_wrap_Locale_GetSysName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 PyObject *resultobj = 0;
13595 wxLocale *arg1 = (wxLocale *) 0 ;
13596 wxString result;
13597 void *argp1 = 0 ;
13598 int res1 = 0 ;
13599 PyObject *swig_obj[1] ;
13600
13601 if (!args) SWIG_fail;
13602 swig_obj[0] = args;
13603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13604 if (!SWIG_IsOK(res1)) {
13605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetSysName" "', expected argument " "1"" of type '" "wxLocale const *""'");
13606 }
13607 arg1 = reinterpret_cast< wxLocale * >(argp1);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = ((wxLocale const *)arg1)->GetSysName();
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 {
13615 #if wxUSE_UNICODE
13616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13617 #else
13618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13619 #endif
13620 }
13621 return resultobj;
13622 fail:
13623 return NULL;
13624 }
13625
13626
13627 SWIGINTERN PyObject *_wrap_Locale_GetCanonicalName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13628 PyObject *resultobj = 0;
13629 wxLocale *arg1 = (wxLocale *) 0 ;
13630 wxString result;
13631 void *argp1 = 0 ;
13632 int res1 = 0 ;
13633 PyObject *swig_obj[1] ;
13634
13635 if (!args) SWIG_fail;
13636 swig_obj[0] = args;
13637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13638 if (!SWIG_IsOK(res1)) {
13639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetCanonicalName" "', expected argument " "1"" of type '" "wxLocale const *""'");
13640 }
13641 arg1 = reinterpret_cast< wxLocale * >(argp1);
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = ((wxLocale const *)arg1)->GetCanonicalName();
13645 wxPyEndAllowThreads(__tstate);
13646 if (PyErr_Occurred()) SWIG_fail;
13647 }
13648 {
13649 #if wxUSE_UNICODE
13650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13651 #else
13652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13653 #endif
13654 }
13655 return resultobj;
13656 fail:
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj = 0;
13663 wxString *arg1 = 0 ;
13664 bool temp1 = false ;
13665 PyObject * obj0 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "prefix", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) SWIG_fail;
13671 {
13672 arg1 = wxString_in_helper(obj0);
13673 if (arg1 == NULL) SWIG_fail;
13674 temp1 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_Py_Void();
13683 {
13684 if (temp1)
13685 delete arg1;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp1)
13691 delete arg1;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Locale_AddCatalog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxLocale *arg1 = (wxLocale *) 0 ;
13700 wxString *arg2 = 0 ;
13701 bool result;
13702 void *argp1 = 0 ;
13703 int res1 = 0 ;
13704 bool temp2 = false ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 char * kwnames[] = {
13708 (char *) "self",(char *) "szDomain", NULL
13709 };
13710
13711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) SWIG_fail;
13712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13713 if (!SWIG_IsOK(res1)) {
13714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddCatalog" "', expected argument " "1"" of type '" "wxLocale *""'");
13715 }
13716 arg1 = reinterpret_cast< wxLocale * >(argp1);
13717 {
13718 arg2 = wxString_in_helper(obj1);
13719 if (arg2 == NULL) SWIG_fail;
13720 temp2 = true;
13721 }
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 {
13729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13730 }
13731 {
13732 if (temp2)
13733 delete arg2;
13734 }
13735 return resultobj;
13736 fail:
13737 {
13738 if (temp2)
13739 delete arg2;
13740 }
13741 return NULL;
13742 }
13743
13744
13745 SWIGINTERN PyObject *_wrap_Locale_IsLoaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj = 0;
13747 wxLocale *arg1 = (wxLocale *) 0 ;
13748 wxString *arg2 = 0 ;
13749 bool result;
13750 void *argp1 = 0 ;
13751 int res1 = 0 ;
13752 bool temp2 = false ;
13753 PyObject * obj0 = 0 ;
13754 PyObject * obj1 = 0 ;
13755 char * kwnames[] = {
13756 (char *) "self",(char *) "szDomain", NULL
13757 };
13758
13759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) SWIG_fail;
13760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13761 if (!SWIG_IsOK(res1)) {
13762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsLoaded" "', expected argument " "1"" of type '" "wxLocale const *""'");
13763 }
13764 arg1 = reinterpret_cast< wxLocale * >(argp1);
13765 {
13766 arg2 = wxString_in_helper(obj1);
13767 if (arg2 == NULL) SWIG_fail;
13768 temp2 = true;
13769 }
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
13773 wxPyEndAllowThreads(__tstate);
13774 if (PyErr_Occurred()) SWIG_fail;
13775 }
13776 {
13777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13778 }
13779 {
13780 if (temp2)
13781 delete arg2;
13782 }
13783 return resultobj;
13784 fail:
13785 {
13786 if (temp2)
13787 delete arg2;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *_wrap_Locale_GetLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 int arg1 ;
13796 wxLanguageInfo *result = 0 ;
13797 int val1 ;
13798 int ecode1 = 0 ;
13799 PyObject * obj0 = 0 ;
13800 char * kwnames[] = {
13801 (char *) "lang", NULL
13802 };
13803
13804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) SWIG_fail;
13805 ecode1 = SWIG_AsVal_int(obj0, &val1);
13806 if (!SWIG_IsOK(ecode1)) {
13807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageInfo" "', expected argument " "1"" of type '" "int""'");
13808 }
13809 arg1 = static_cast< int >(val1);
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_Locale_GetLanguageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13824 PyObject *resultobj = 0;
13825 int arg1 ;
13826 wxString result;
13827 int val1 ;
13828 int ecode1 = 0 ;
13829 PyObject * obj0 = 0 ;
13830 char * kwnames[] = {
13831 (char *) "lang", NULL
13832 };
13833
13834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) SWIG_fail;
13835 ecode1 = SWIG_AsVal_int(obj0, &val1);
13836 if (!SWIG_IsOK(ecode1)) {
13837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageName" "', expected argument " "1"" of type '" "int""'");
13838 }
13839 arg1 = static_cast< int >(val1);
13840 {
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 result = wxLocale::GetLanguageName(arg1);
13843 wxPyEndAllowThreads(__tstate);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 }
13846 {
13847 #if wxUSE_UNICODE
13848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13849 #else
13850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13851 #endif
13852 }
13853 return resultobj;
13854 fail:
13855 return NULL;
13856 }
13857
13858
13859 SWIGINTERN PyObject *_wrap_Locale_FindLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13860 PyObject *resultobj = 0;
13861 wxString *arg1 = 0 ;
13862 wxLanguageInfo *result = 0 ;
13863 bool temp1 = false ;
13864 PyObject * obj0 = 0 ;
13865 char * kwnames[] = {
13866 (char *) "locale", NULL
13867 };
13868
13869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) SWIG_fail;
13870 {
13871 arg1 = wxString_in_helper(obj0);
13872 if (arg1 == NULL) SWIG_fail;
13873 temp1 = true;
13874 }
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
13882 {
13883 if (temp1)
13884 delete arg1;
13885 }
13886 return resultobj;
13887 fail:
13888 {
13889 if (temp1)
13890 delete arg1;
13891 }
13892 return NULL;
13893 }
13894
13895
13896 SWIGINTERN PyObject *_wrap_Locale_AddLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13897 PyObject *resultobj = 0;
13898 wxLanguageInfo *arg1 = 0 ;
13899 void *argp1 = 0 ;
13900 int res1 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "info", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) SWIG_fail;
13907 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxLanguageInfo, 0 | 0);
13908 if (!SWIG_IsOK(res1)) {
13909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
13910 }
13911 if (!argp1) {
13912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
13913 }
13914 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 resultobj = SWIG_Py_Void();
13922 return resultobj;
13923 fail:
13924 return NULL;
13925 }
13926
13927
13928 SWIGINTERN PyObject *_wrap_Locale_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13929 PyObject *resultobj = 0;
13930 wxLocale *arg1 = (wxLocale *) 0 ;
13931 wxString *arg2 = 0 ;
13932 wxString const &arg3_defvalue = wxPyEmptyString ;
13933 wxString *arg3 = (wxString *) &arg3_defvalue ;
13934 wxString result;
13935 void *argp1 = 0 ;
13936 int res1 = 0 ;
13937 bool temp2 = false ;
13938 bool temp3 = false ;
13939 PyObject * obj0 = 0 ;
13940 PyObject * obj1 = 0 ;
13941 PyObject * obj2 = 0 ;
13942 char * kwnames[] = {
13943 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
13944 };
13945
13946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
13948 if (!SWIG_IsOK(res1)) {
13949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetString" "', expected argument " "1"" of type '" "wxLocale const *""'");
13950 }
13951 arg1 = reinterpret_cast< wxLocale * >(argp1);
13952 {
13953 arg2 = wxString_in_helper(obj1);
13954 if (arg2 == NULL) SWIG_fail;
13955 temp2 = true;
13956 }
13957 if (obj2) {
13958 {
13959 arg3 = wxString_in_helper(obj2);
13960 if (arg3 == NULL) SWIG_fail;
13961 temp3 = true;
13962 }
13963 }
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 {
13971 #if wxUSE_UNICODE
13972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13973 #else
13974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13975 #endif
13976 }
13977 {
13978 if (temp2)
13979 delete arg2;
13980 }
13981 {
13982 if (temp3)
13983 delete arg3;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 {
13992 if (temp3)
13993 delete arg3;
13994 }
13995 return NULL;
13996 }
13997
13998
13999 SWIGINTERN PyObject *_wrap_Locale_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14000 PyObject *resultobj = 0;
14001 wxLocale *arg1 = (wxLocale *) 0 ;
14002 wxString *result = 0 ;
14003 void *argp1 = 0 ;
14004 int res1 = 0 ;
14005 PyObject *swig_obj[1] ;
14006
14007 if (!args) SWIG_fail;
14008 swig_obj[0] = args;
14009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
14010 if (!SWIG_IsOK(res1)) {
14011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetName" "', expected argument " "1"" of type '" "wxLocale const *""'");
14012 }
14013 arg1 = reinterpret_cast< wxLocale * >(argp1);
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 {
14017 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
14018 result = (wxString *) &_result_ref;
14019 }
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 {
14024 #if wxUSE_UNICODE
14025 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14026 #else
14027 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14028 #endif
14029 }
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *Locale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14037 PyObject *obj;
14038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14039 SWIG_TypeNewClientData(SWIGTYPE_p_wxLocale, SWIG_NewClientData(obj));
14040 return SWIG_Py_Void();
14041 }
14042
14043 SWIGINTERN PyObject *Locale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 return SWIG_Python_InitShadowInstance(args);
14045 }
14046
14047 SWIGINTERN PyObject *_wrap_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14048 PyObject *resultobj = 0;
14049 wxLocale *result = 0 ;
14050
14051 if (!SWIG_Python_UnpackTuple(args,"GetLocale",0,0,0)) SWIG_fail;
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 result = (wxLocale *)wxGetLocale();
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, 0 | 0 );
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14066 PyObject *resultobj = 0;
14067 wxString *arg1 = 0 ;
14068 wxString result;
14069 bool temp1 = false ;
14070
14071 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
14072 {
14073 arg1 = wxString_in_helper(swig_obj[0]);
14074 if (arg1 == NULL) SWIG_fail;
14075 temp1 = true;
14076 }
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = wxGetTranslation((wxString const &)*arg1);
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 {
14084 #if wxUSE_UNICODE
14085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14086 #else
14087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14088 #endif
14089 }
14090 {
14091 if (temp1)
14092 delete arg1;
14093 }
14094 return resultobj;
14095 fail:
14096 {
14097 if (temp1)
14098 delete arg1;
14099 }
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14105 PyObject *resultobj = 0;
14106 wxString *arg1 = 0 ;
14107 wxString *arg2 = 0 ;
14108 size_t arg3 ;
14109 wxString result;
14110 bool temp1 = false ;
14111 bool temp2 = false ;
14112 size_t val3 ;
14113 int ecode3 = 0 ;
14114
14115 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
14116 {
14117 arg1 = wxString_in_helper(swig_obj[0]);
14118 if (arg1 == NULL) SWIG_fail;
14119 temp1 = true;
14120 }
14121 {
14122 arg2 = wxString_in_helper(swig_obj[1]);
14123 if (arg2 == NULL) SWIG_fail;
14124 temp2 = true;
14125 }
14126 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
14127 if (!SWIG_IsOK(ecode3)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
14129 }
14130 arg3 = static_cast< size_t >(val3);
14131 {
14132 PyThreadState* __tstate = wxPyBeginAllowThreads();
14133 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 #if wxUSE_UNICODE
14139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14140 #else
14141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14142 #endif
14143 }
14144 {
14145 if (temp1)
14146 delete arg1;
14147 }
14148 {
14149 if (temp2)
14150 delete arg2;
14151 }
14152 return resultobj;
14153 fail:
14154 {
14155 if (temp1)
14156 delete arg1;
14157 }
14158 {
14159 if (temp2)
14160 delete arg2;
14161 }
14162 return NULL;
14163 }
14164
14165
14166 SWIGINTERN PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
14167 int argc;
14168 PyObject *argv[4];
14169
14170 if (!(argc = SWIG_Python_UnpackTuple(args,"GetTranslation",0,3,argv))) SWIG_fail;
14171 --argc;
14172 if (argc == 1) {
14173 return _wrap_GetTranslation__SWIG_0(self, argc, argv);
14174 }
14175 if (argc == 3) {
14176 return _wrap_GetTranslation__SWIG_1(self, argc, argv);
14177 }
14178
14179 fail:
14180 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
14181 return NULL;
14182 }
14183
14184
14185 SWIGINTERN PyObject *_wrap_new_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14186 PyObject *resultobj = 0;
14187 wxEncodingConverter *result = 0 ;
14188
14189 if (!SWIG_Python_UnpackTuple(args,"new_EncodingConverter",0,0,0)) SWIG_fail;
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 result = (wxEncodingConverter *)new wxEncodingConverter();
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_NEW | 0 );
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 SWIGINTERN PyObject *_wrap_delete_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14204 PyObject *resultobj = 0;
14205 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14206 void *argp1 = 0 ;
14207 int res1 = 0 ;
14208 PyObject *swig_obj[1] ;
14209
14210 if (!args) SWIG_fail;
14211 swig_obj[0] = args;
14212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_DISOWN | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingConverter" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14215 }
14216 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 delete arg1;
14220
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 resultobj = SWIG_Py_Void();
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *_wrap_EncodingConverter_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14232 PyObject *resultobj = 0;
14233 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14234 wxFontEncoding arg2 ;
14235 wxFontEncoding arg3 ;
14236 int arg4 = (int) wxCONVERT_STRICT ;
14237 bool result;
14238 void *argp1 = 0 ;
14239 int res1 = 0 ;
14240 int val2 ;
14241 int ecode2 = 0 ;
14242 int val3 ;
14243 int ecode3 = 0 ;
14244 int val4 ;
14245 int ecode4 = 0 ;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 PyObject * obj2 = 0 ;
14249 PyObject * obj3 = 0 ;
14250 char * kwnames[] = {
14251 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
14252 };
14253
14254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
14256 if (!SWIG_IsOK(res1)) {
14257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Init" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14258 }
14259 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14260 ecode2 = SWIG_AsVal_int(obj1, &val2);
14261 if (!SWIG_IsOK(ecode2)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_Init" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14263 }
14264 arg2 = static_cast< wxFontEncoding >(val2);
14265 ecode3 = SWIG_AsVal_int(obj2, &val3);
14266 if (!SWIG_IsOK(ecode3)) {
14267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EncodingConverter_Init" "', expected argument " "3"" of type '" "wxFontEncoding""'");
14268 }
14269 arg3 = static_cast< wxFontEncoding >(val3);
14270 if (obj3) {
14271 ecode4 = SWIG_AsVal_int(obj3, &val4);
14272 if (!SWIG_IsOK(ecode4)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EncodingConverter_Init" "', expected argument " "4"" of type '" "int""'");
14274 }
14275 arg4 = static_cast< int >(val4);
14276 }
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 result = (bool)(arg1)->Init(arg2,arg3,arg4);
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_EncodingConverter_Convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj = 0;
14294 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
14295 wxString *arg2 = 0 ;
14296 wxString result;
14297 void *argp1 = 0 ;
14298 int res1 = 0 ;
14299 bool temp2 = false ;
14300 PyObject * obj0 = 0 ;
14301 PyObject * obj1 = 0 ;
14302 char * kwnames[] = {
14303 (char *) "self",(char *) "input", NULL
14304 };
14305
14306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) SWIG_fail;
14307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
14308 if (!SWIG_IsOK(res1)) {
14309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Convert" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
14310 }
14311 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
14312 {
14313 arg2 = wxString_in_helper(obj1);
14314 if (arg2 == NULL) SWIG_fail;
14315 temp2 = true;
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (arg1)->Convert((wxString const &)*arg2);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 #if wxUSE_UNICODE
14325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14326 #else
14327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14328 #endif
14329 }
14330 {
14331 if (temp2)
14332 delete arg2;
14333 }
14334 return resultobj;
14335 fail:
14336 {
14337 if (temp2)
14338 delete arg2;
14339 }
14340 return NULL;
14341 }
14342
14343
14344 SWIGINTERN PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14345 PyObject *resultobj = 0;
14346 wxFontEncoding arg1 ;
14347 int arg2 = (int) wxPLATFORM_CURRENT ;
14348 wxFontEncodingArray result;
14349 int val1 ;
14350 int ecode1 = 0 ;
14351 int val2 ;
14352 int ecode2 = 0 ;
14353 PyObject * obj0 = 0 ;
14354 PyObject * obj1 = 0 ;
14355 char * kwnames[] = {
14356 (char *) "enc",(char *) "platform", NULL
14357 };
14358
14359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) SWIG_fail;
14360 ecode1 = SWIG_AsVal_int(obj0, &val1);
14361 if (!SWIG_IsOK(ecode1)) {
14362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14363 }
14364 arg1 = static_cast< wxFontEncoding >(val1);
14365 if (obj1) {
14366 ecode2 = SWIG_AsVal_int(obj1, &val2);
14367 if (!SWIG_IsOK(ecode2)) {
14368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "2"" of type '" "int""'");
14369 }
14370 arg2 = static_cast< int >(val2);
14371 }
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = wxEncodingConverter::GetPlatformEquivalents(arg1,arg2);
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 {
14379 resultobj = PyList_New(0);
14380 for (size_t i=0; i < (&result)->GetCount(); i++) {
14381 PyObject* number = PyInt_FromLong((&result)->Item(i));
14382 PyList_Append(resultobj, number);
14383 Py_DECREF(number);
14384 }
14385 }
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 SWIGINTERN PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14393 PyObject *resultobj = 0;
14394 wxFontEncoding arg1 ;
14395 wxFontEncodingArray result;
14396 int val1 ;
14397 int ecode1 = 0 ;
14398 PyObject * obj0 = 0 ;
14399 char * kwnames[] = {
14400 (char *) "enc", NULL
14401 };
14402
14403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) SWIG_fail;
14404 ecode1 = SWIG_AsVal_int(obj0, &val1);
14405 if (!SWIG_IsOK(ecode1)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetAllEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14407 }
14408 arg1 = static_cast< wxFontEncoding >(val1);
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = wxEncodingConverter::GetAllEquivalents(arg1);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 resultobj = PyList_New(0);
14417 for (size_t i=0; i < (&result)->GetCount(); i++) {
14418 PyObject* number = PyInt_FromLong((&result)->Item(i));
14419 PyList_Append(resultobj, number);
14420 Py_DECREF(number);
14421 }
14422 }
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_EncodingConverter_CanConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj = 0;
14431 wxFontEncoding arg1 ;
14432 wxFontEncoding arg2 ;
14433 bool result;
14434 int val1 ;
14435 int ecode1 = 0 ;
14436 int val2 ;
14437 int ecode2 = 0 ;
14438 PyObject * obj0 = 0 ;
14439 PyObject * obj1 = 0 ;
14440 char * kwnames[] = {
14441 (char *) "encIn",(char *) "encOut", NULL
14442 };
14443
14444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) SWIG_fail;
14445 ecode1 = SWIG_AsVal_int(obj0, &val1);
14446 if (!SWIG_IsOK(ecode1)) {
14447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_CanConvert" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14448 }
14449 arg1 = static_cast< wxFontEncoding >(val1);
14450 ecode2 = SWIG_AsVal_int(obj1, &val2);
14451 if (!SWIG_IsOK(ecode2)) {
14452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_CanConvert" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14453 }
14454 arg2 = static_cast< wxFontEncoding >(val2);
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (bool)wxEncodingConverter::CanConvert(arg1,arg2);
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14463 }
14464 return resultobj;
14465 fail:
14466 return NULL;
14467 }
14468
14469
14470 SWIGINTERN PyObject *EncodingConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14471 PyObject *obj;
14472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14473 SWIG_TypeNewClientData(SWIGTYPE_p_wxEncodingConverter, SWIG_NewClientData(obj));
14474 return SWIG_Py_Void();
14475 }
14476
14477 SWIGINTERN PyObject *EncodingConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14478 return SWIG_Python_InitShadowInstance(args);
14479 }
14480
14481 SWIGINTERN PyObject *_wrap_delete_DC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14482 PyObject *resultobj = 0;
14483 wxDC *arg1 = (wxDC *) 0 ;
14484 void *argp1 = 0 ;
14485 int res1 = 0 ;
14486 PyObject *swig_obj[1] ;
14487
14488 if (!args) SWIG_fail;
14489 swig_obj[0] = args;
14490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, SWIG_POINTER_DISOWN | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DC" "', expected argument " "1"" of type '" "wxDC *""'");
14493 }
14494 arg1 = reinterpret_cast< wxDC * >(argp1);
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 delete arg1;
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_Py_Void();
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 SWIGINTERN PyObject *_wrap_DC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj = 0;
14511 wxDC *arg1 = (wxDC *) 0 ;
14512 int arg2 ;
14513 int arg3 ;
14514 wxColour *arg4 = 0 ;
14515 int arg5 = (int) wxFLOOD_SURFACE ;
14516 bool result;
14517 void *argp1 = 0 ;
14518 int res1 = 0 ;
14519 int val2 ;
14520 int ecode2 = 0 ;
14521 int val3 ;
14522 int ecode3 = 0 ;
14523 wxColour temp4 ;
14524 int val5 ;
14525 int ecode5 = 0 ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 PyObject * obj2 = 0 ;
14529 PyObject * obj3 = 0 ;
14530 PyObject * obj4 = 0 ;
14531 char * kwnames[] = {
14532 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
14533 };
14534
14535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFill" "', expected argument " "1"" of type '" "wxDC *""'");
14539 }
14540 arg1 = reinterpret_cast< wxDC * >(argp1);
14541 ecode2 = SWIG_AsVal_int(obj1, &val2);
14542 if (!SWIG_IsOK(ecode2)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_FloodFill" "', expected argument " "2"" of type '" "int""'");
14544 }
14545 arg2 = static_cast< int >(val2);
14546 ecode3 = SWIG_AsVal_int(obj2, &val3);
14547 if (!SWIG_IsOK(ecode3)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_FloodFill" "', expected argument " "3"" of type '" "int""'");
14549 }
14550 arg3 = static_cast< int >(val3);
14551 {
14552 arg4 = &temp4;
14553 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14554 }
14555 if (obj4) {
14556 ecode5 = SWIG_AsVal_int(obj4, &val5);
14557 if (!SWIG_IsOK(ecode5)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_FloodFill" "', expected argument " "5"" of type '" "int""'");
14559 }
14560 arg5 = static_cast< int >(val5);
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 {
14569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14570 }
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_DC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14578 PyObject *resultobj = 0;
14579 wxDC *arg1 = (wxDC *) 0 ;
14580 wxPoint *arg2 = 0 ;
14581 wxColour *arg3 = 0 ;
14582 int arg4 = (int) wxFLOOD_SURFACE ;
14583 bool result;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 wxPoint temp2 ;
14587 wxColour temp3 ;
14588 int val4 ;
14589 int ecode4 = 0 ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 PyObject * obj2 = 0 ;
14593 PyObject * obj3 = 0 ;
14594 char * kwnames[] = {
14595 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
14596 };
14597
14598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14600 if (!SWIG_IsOK(res1)) {
14601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFillPoint" "', expected argument " "1"" of type '" "wxDC *""'");
14602 }
14603 arg1 = reinterpret_cast< wxDC * >(argp1);
14604 {
14605 arg2 = &temp2;
14606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14607 }
14608 {
14609 arg3 = &temp3;
14610 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14611 }
14612 if (obj3) {
14613 ecode4 = SWIG_AsVal_int(obj3, &val4);
14614 if (!SWIG_IsOK(ecode4)) {
14615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
14616 }
14617 arg4 = static_cast< int >(val4);
14618 }
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 {
14626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14627 }
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_DC_GradientFillConcentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxDC *arg1 = (wxDC *) 0 ;
14637 wxRect *arg2 = 0 ;
14638 wxColour *arg3 = 0 ;
14639 wxColour *arg4 = 0 ;
14640 wxPoint *arg5 = 0 ;
14641 void *argp1 = 0 ;
14642 int res1 = 0 ;
14643 wxRect temp2 ;
14644 wxColour temp3 ;
14645 wxColour temp4 ;
14646 wxPoint temp5 ;
14647 PyObject * obj0 = 0 ;
14648 PyObject * obj1 = 0 ;
14649 PyObject * obj2 = 0 ;
14650 PyObject * obj3 = 0 ;
14651 PyObject * obj4 = 0 ;
14652 char * kwnames[] = {
14653 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "circleCenter", NULL
14654 };
14655
14656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_GradientFillConcentric",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14658 if (!SWIG_IsOK(res1)) {
14659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillConcentric" "', expected argument " "1"" of type '" "wxDC *""'");
14660 }
14661 arg1 = reinterpret_cast< wxDC * >(argp1);
14662 {
14663 arg2 = &temp2;
14664 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14665 }
14666 {
14667 arg3 = &temp3;
14668 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14669 }
14670 {
14671 arg4 = &temp4;
14672 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14673 }
14674 {
14675 arg5 = &temp5;
14676 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14677 }
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 (arg1)->GradientFillConcentric((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 resultobj = SWIG_Py_Void();
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 SWIGINTERN PyObject *_wrap_DC_GradientFillLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj = 0;
14693 wxDC *arg1 = (wxDC *) 0 ;
14694 wxRect *arg2 = 0 ;
14695 wxColour *arg3 = 0 ;
14696 wxColour *arg4 = 0 ;
14697 wxDirection arg5 = (wxDirection) wxEAST ;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 wxRect temp2 ;
14701 wxColour temp3 ;
14702 wxColour temp4 ;
14703 int val5 ;
14704 int ecode5 = 0 ;
14705 PyObject * obj0 = 0 ;
14706 PyObject * obj1 = 0 ;
14707 PyObject * obj2 = 0 ;
14708 PyObject * obj3 = 0 ;
14709 PyObject * obj4 = 0 ;
14710 char * kwnames[] = {
14711 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "nDirection", NULL
14712 };
14713
14714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_GradientFillLinear",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14716 if (!SWIG_IsOK(res1)) {
14717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillLinear" "', expected argument " "1"" of type '" "wxDC *""'");
14718 }
14719 arg1 = reinterpret_cast< wxDC * >(argp1);
14720 {
14721 arg2 = &temp2;
14722 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14723 }
14724 {
14725 arg3 = &temp3;
14726 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
14727 }
14728 {
14729 arg4 = &temp4;
14730 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
14731 }
14732 if (obj4) {
14733 ecode5 = SWIG_AsVal_int(obj4, &val5);
14734 if (!SWIG_IsOK(ecode5)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_GradientFillLinear" "', expected argument " "5"" of type '" "wxDirection""'");
14736 }
14737 arg5 = static_cast< wxDirection >(val5);
14738 }
14739 {
14740 PyThreadState* __tstate = wxPyBeginAllowThreads();
14741 (arg1)->GradientFillLinear((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,arg5);
14742 wxPyEndAllowThreads(__tstate);
14743 if (PyErr_Occurred()) SWIG_fail;
14744 }
14745 resultobj = SWIG_Py_Void();
14746 return resultobj;
14747 fail:
14748 return NULL;
14749 }
14750
14751
14752 SWIGINTERN PyObject *_wrap_DC_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14753 PyObject *resultobj = 0;
14754 wxDC *arg1 = (wxDC *) 0 ;
14755 int arg2 ;
14756 int arg3 ;
14757 wxColour result;
14758 void *argp1 = 0 ;
14759 int res1 = 0 ;
14760 int val2 ;
14761 int ecode2 = 0 ;
14762 int val3 ;
14763 int ecode3 = 0 ;
14764 PyObject * obj0 = 0 ;
14765 PyObject * obj1 = 0 ;
14766 PyObject * obj2 = 0 ;
14767 char * kwnames[] = {
14768 (char *) "self",(char *) "x",(char *) "y", NULL
14769 };
14770
14771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14773 if (!SWIG_IsOK(res1)) {
14774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixel" "', expected argument " "1"" of type '" "wxDC *""'");
14775 }
14776 arg1 = reinterpret_cast< wxDC * >(argp1);
14777 ecode2 = SWIG_AsVal_int(obj1, &val2);
14778 if (!SWIG_IsOK(ecode2)) {
14779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_GetPixel" "', expected argument " "2"" of type '" "int""'");
14780 }
14781 arg2 = static_cast< int >(val2);
14782 ecode3 = SWIG_AsVal_int(obj2, &val3);
14783 if (!SWIG_IsOK(ecode3)) {
14784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_GetPixel" "', expected argument " "3"" of type '" "int""'");
14785 }
14786 arg3 = static_cast< int >(val3);
14787 {
14788 PyThreadState* __tstate = wxPyBeginAllowThreads();
14789 result = wxDC_GetPixel(arg1,arg2,arg3);
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14794 return resultobj;
14795 fail:
14796 return NULL;
14797 }
14798
14799
14800 SWIGINTERN PyObject *_wrap_DC_GetPixelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14801 PyObject *resultobj = 0;
14802 wxDC *arg1 = (wxDC *) 0 ;
14803 wxPoint *arg2 = 0 ;
14804 wxColour result;
14805 void *argp1 = 0 ;
14806 int res1 = 0 ;
14807 wxPoint temp2 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 char * kwnames[] = {
14811 (char *) "self",(char *) "pt", NULL
14812 };
14813
14814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) SWIG_fail;
14815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixelPoint" "', expected argument " "1"" of type '" "wxDC *""'");
14818 }
14819 arg1 = reinterpret_cast< wxDC * >(argp1);
14820 {
14821 arg2 = &temp2;
14822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14823 }
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
14827 wxPyEndAllowThreads(__tstate);
14828 if (PyErr_Occurred()) SWIG_fail;
14829 }
14830 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14831 return resultobj;
14832 fail:
14833 return NULL;
14834 }
14835
14836
14837 SWIGINTERN PyObject *_wrap_DC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14838 PyObject *resultobj = 0;
14839 wxDC *arg1 = (wxDC *) 0 ;
14840 int arg2 ;
14841 int arg3 ;
14842 int arg4 ;
14843 int arg5 ;
14844 void *argp1 = 0 ;
14845 int res1 = 0 ;
14846 int val2 ;
14847 int ecode2 = 0 ;
14848 int val3 ;
14849 int ecode3 = 0 ;
14850 int val4 ;
14851 int ecode4 = 0 ;
14852 int val5 ;
14853 int ecode5 = 0 ;
14854 PyObject * obj0 = 0 ;
14855 PyObject * obj1 = 0 ;
14856 PyObject * obj2 = 0 ;
14857 PyObject * obj3 = 0 ;
14858 PyObject * obj4 = 0 ;
14859 char * kwnames[] = {
14860 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
14861 };
14862
14863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14865 if (!SWIG_IsOK(res1)) {
14866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLine" "', expected argument " "1"" of type '" "wxDC *""'");
14867 }
14868 arg1 = reinterpret_cast< wxDC * >(argp1);
14869 ecode2 = SWIG_AsVal_int(obj1, &val2);
14870 if (!SWIG_IsOK(ecode2)) {
14871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawLine" "', expected argument " "2"" of type '" "int""'");
14872 }
14873 arg2 = static_cast< int >(val2);
14874 ecode3 = SWIG_AsVal_int(obj2, &val3);
14875 if (!SWIG_IsOK(ecode3)) {
14876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawLine" "', expected argument " "3"" of type '" "int""'");
14877 }
14878 arg3 = static_cast< int >(val3);
14879 ecode4 = SWIG_AsVal_int(obj3, &val4);
14880 if (!SWIG_IsOK(ecode4)) {
14881 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLine" "', expected argument " "4"" of type '" "int""'");
14882 }
14883 arg4 = static_cast< int >(val4);
14884 ecode5 = SWIG_AsVal_int(obj4, &val5);
14885 if (!SWIG_IsOK(ecode5)) {
14886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLine" "', expected argument " "5"" of type '" "int""'");
14887 }
14888 arg5 = static_cast< int >(val5);
14889 {
14890 PyThreadState* __tstate = wxPyBeginAllowThreads();
14891 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
14892 wxPyEndAllowThreads(__tstate);
14893 if (PyErr_Occurred()) SWIG_fail;
14894 }
14895 resultobj = SWIG_Py_Void();
14896 return resultobj;
14897 fail:
14898 return NULL;
14899 }
14900
14901
14902 SWIGINTERN PyObject *_wrap_DC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14903 PyObject *resultobj = 0;
14904 wxDC *arg1 = (wxDC *) 0 ;
14905 wxPoint *arg2 = 0 ;
14906 wxPoint *arg3 = 0 ;
14907 void *argp1 = 0 ;
14908 int res1 = 0 ;
14909 wxPoint temp2 ;
14910 wxPoint temp3 ;
14911 PyObject * obj0 = 0 ;
14912 PyObject * obj1 = 0 ;
14913 PyObject * obj2 = 0 ;
14914 char * kwnames[] = {
14915 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
14916 };
14917
14918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14920 if (!SWIG_IsOK(res1)) {
14921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLinePoint" "', expected argument " "1"" of type '" "wxDC *""'");
14922 }
14923 arg1 = reinterpret_cast< wxDC * >(argp1);
14924 {
14925 arg2 = &temp2;
14926 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14927 }
14928 {
14929 arg3 = &temp3;
14930 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 resultobj = SWIG_Py_Void();
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 SWIGINTERN PyObject *_wrap_DC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj = 0;
14947 wxDC *arg1 = (wxDC *) 0 ;
14948 int arg2 ;
14949 int arg3 ;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 int val2 ;
14953 int ecode2 = 0 ;
14954 int val3 ;
14955 int ecode3 = 0 ;
14956 PyObject * obj0 = 0 ;
14957 PyObject * obj1 = 0 ;
14958 PyObject * obj2 = 0 ;
14959 char * kwnames[] = {
14960 (char *) "self",(char *) "x",(char *) "y", NULL
14961 };
14962
14963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
14965 if (!SWIG_IsOK(res1)) {
14966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHair" "', expected argument " "1"" of type '" "wxDC *""'");
14967 }
14968 arg1 = reinterpret_cast< wxDC * >(argp1);
14969 ecode2 = SWIG_AsVal_int(obj1, &val2);
14970 if (!SWIG_IsOK(ecode2)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CrossHair" "', expected argument " "2"" of type '" "int""'");
14972 }
14973 arg2 = static_cast< int >(val2);
14974 ecode3 = SWIG_AsVal_int(obj2, &val3);
14975 if (!SWIG_IsOK(ecode3)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CrossHair" "', expected argument " "3"" of type '" "int""'");
14977 }
14978 arg3 = static_cast< int >(val3);
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 (arg1)->CrossHair(arg2,arg3);
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 resultobj = SWIG_Py_Void();
14986 return resultobj;
14987 fail:
14988 return NULL;
14989 }
14990
14991
14992 SWIGINTERN PyObject *_wrap_DC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14993 PyObject *resultobj = 0;
14994 wxDC *arg1 = (wxDC *) 0 ;
14995 wxPoint *arg2 = 0 ;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 wxPoint temp2 ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 char * kwnames[] = {
15002 (char *) "self",(char *) "pt", NULL
15003 };
15004
15005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
15006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15007 if (!SWIG_IsOK(res1)) {
15008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHairPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15009 }
15010 arg1 = reinterpret_cast< wxDC * >(argp1);
15011 {
15012 arg2 = &temp2;
15013 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15014 }
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 (arg1)->CrossHair((wxPoint const &)*arg2);
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_Py_Void();
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_DC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxDC *arg1 = (wxDC *) 0 ;
15031 int arg2 ;
15032 int arg3 ;
15033 int arg4 ;
15034 int arg5 ;
15035 int arg6 ;
15036 int arg7 ;
15037 void *argp1 = 0 ;
15038 int res1 = 0 ;
15039 int val2 ;
15040 int ecode2 = 0 ;
15041 int val3 ;
15042 int ecode3 = 0 ;
15043 int val4 ;
15044 int ecode4 = 0 ;
15045 int val5 ;
15046 int ecode5 = 0 ;
15047 int val6 ;
15048 int ecode6 = 0 ;
15049 int val7 ;
15050 int ecode7 = 0 ;
15051 PyObject * obj0 = 0 ;
15052 PyObject * obj1 = 0 ;
15053 PyObject * obj2 = 0 ;
15054 PyObject * obj3 = 0 ;
15055 PyObject * obj4 = 0 ;
15056 PyObject * obj5 = 0 ;
15057 PyObject * obj6 = 0 ;
15058 char * kwnames[] = {
15059 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
15060 };
15061
15062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15064 if (!SWIG_IsOK(res1)) {
15065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArc" "', expected argument " "1"" of type '" "wxDC *""'");
15066 }
15067 arg1 = reinterpret_cast< wxDC * >(argp1);
15068 ecode2 = SWIG_AsVal_int(obj1, &val2);
15069 if (!SWIG_IsOK(ecode2)) {
15070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawArc" "', expected argument " "2"" of type '" "int""'");
15071 }
15072 arg2 = static_cast< int >(val2);
15073 ecode3 = SWIG_AsVal_int(obj2, &val3);
15074 if (!SWIG_IsOK(ecode3)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawArc" "', expected argument " "3"" of type '" "int""'");
15076 }
15077 arg3 = static_cast< int >(val3);
15078 ecode4 = SWIG_AsVal_int(obj3, &val4);
15079 if (!SWIG_IsOK(ecode4)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawArc" "', expected argument " "4"" of type '" "int""'");
15081 }
15082 arg4 = static_cast< int >(val4);
15083 ecode5 = SWIG_AsVal_int(obj4, &val5);
15084 if (!SWIG_IsOK(ecode5)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawArc" "', expected argument " "5"" of type '" "int""'");
15086 }
15087 arg5 = static_cast< int >(val5);
15088 ecode6 = SWIG_AsVal_int(obj5, &val6);
15089 if (!SWIG_IsOK(ecode6)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawArc" "', expected argument " "6"" of type '" "int""'");
15091 }
15092 arg6 = static_cast< int >(val6);
15093 ecode7 = SWIG_AsVal_int(obj6, &val7);
15094 if (!SWIG_IsOK(ecode7)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawArc" "', expected argument " "7"" of type '" "int""'");
15096 }
15097 arg7 = static_cast< int >(val7);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 resultobj = SWIG_Py_Void();
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 SWIGINTERN PyObject *_wrap_DC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj = 0;
15113 wxDC *arg1 = (wxDC *) 0 ;
15114 wxPoint *arg2 = 0 ;
15115 wxPoint *arg3 = 0 ;
15116 wxPoint *arg4 = 0 ;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 wxPoint temp2 ;
15120 wxPoint temp3 ;
15121 wxPoint temp4 ;
15122 PyObject * obj0 = 0 ;
15123 PyObject * obj1 = 0 ;
15124 PyObject * obj2 = 0 ;
15125 PyObject * obj3 = 0 ;
15126 char * kwnames[] = {
15127 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
15128 };
15129
15130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArcPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15134 }
15135 arg1 = reinterpret_cast< wxDC * >(argp1);
15136 {
15137 arg2 = &temp2;
15138 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15139 }
15140 {
15141 arg3 = &temp3;
15142 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15143 }
15144 {
15145 arg4 = &temp4;
15146 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 resultobj = SWIG_Py_Void();
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 SWIGINTERN PyObject *_wrap_DC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj = 0;
15163 wxDC *arg1 = (wxDC *) 0 ;
15164 int arg2 ;
15165 int arg3 ;
15166 int arg4 ;
15167 int arg5 ;
15168 void *argp1 = 0 ;
15169 int res1 = 0 ;
15170 int val2 ;
15171 int ecode2 = 0 ;
15172 int val3 ;
15173 int ecode3 = 0 ;
15174 int val4 ;
15175 int ecode4 = 0 ;
15176 int val5 ;
15177 int ecode5 = 0 ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 PyObject * obj3 = 0 ;
15182 PyObject * obj4 = 0 ;
15183 char * kwnames[] = {
15184 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15185 };
15186
15187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15189 if (!SWIG_IsOK(res1)) {
15190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMark" "', expected argument " "1"" of type '" "wxDC *""'");
15191 }
15192 arg1 = reinterpret_cast< wxDC * >(argp1);
15193 ecode2 = SWIG_AsVal_int(obj1, &val2);
15194 if (!SWIG_IsOK(ecode2)) {
15195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
15196 }
15197 arg2 = static_cast< int >(val2);
15198 ecode3 = SWIG_AsVal_int(obj2, &val3);
15199 if (!SWIG_IsOK(ecode3)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
15201 }
15202 arg3 = static_cast< int >(val3);
15203 ecode4 = SWIG_AsVal_int(obj3, &val4);
15204 if (!SWIG_IsOK(ecode4)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
15206 }
15207 arg4 = static_cast< int >(val4);
15208 ecode5 = SWIG_AsVal_int(obj4, &val5);
15209 if (!SWIG_IsOK(ecode5)) {
15210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
15211 }
15212 arg5 = static_cast< int >(val5);
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
15216 wxPyEndAllowThreads(__tstate);
15217 if (PyErr_Occurred()) SWIG_fail;
15218 }
15219 resultobj = SWIG_Py_Void();
15220 return resultobj;
15221 fail:
15222 return NULL;
15223 }
15224
15225
15226 SWIGINTERN PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj = 0;
15228 wxDC *arg1 = (wxDC *) 0 ;
15229 wxRect *arg2 = 0 ;
15230 void *argp1 = 0 ;
15231 int res1 = 0 ;
15232 wxRect temp2 ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 char * kwnames[] = {
15236 (char *) "self",(char *) "rect", NULL
15237 };
15238
15239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
15240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxDC *""'");
15243 }
15244 arg1 = reinterpret_cast< wxDC * >(argp1);
15245 {
15246 arg2 = &temp2;
15247 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15248 }
15249 {
15250 PyThreadState* __tstate = wxPyBeginAllowThreads();
15251 (arg1)->DrawCheckMark((wxRect const &)*arg2);
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 resultobj = SWIG_Py_Void();
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = 0;
15264 wxDC *arg1 = (wxDC *) 0 ;
15265 int arg2 ;
15266 int arg3 ;
15267 int arg4 ;
15268 int arg5 ;
15269 double arg6 ;
15270 double arg7 ;
15271 void *argp1 = 0 ;
15272 int res1 = 0 ;
15273 int val2 ;
15274 int ecode2 = 0 ;
15275 int val3 ;
15276 int ecode3 = 0 ;
15277 int val4 ;
15278 int ecode4 = 0 ;
15279 int val5 ;
15280 int ecode5 = 0 ;
15281 double val6 ;
15282 int ecode6 = 0 ;
15283 double val7 ;
15284 int ecode7 = 0 ;
15285 PyObject * obj0 = 0 ;
15286 PyObject * obj1 = 0 ;
15287 PyObject * obj2 = 0 ;
15288 PyObject * obj3 = 0 ;
15289 PyObject * obj4 = 0 ;
15290 PyObject * obj5 = 0 ;
15291 PyObject * obj6 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxDC *""'");
15300 }
15301 arg1 = reinterpret_cast< wxDC * >(argp1);
15302 ecode2 = SWIG_AsVal_int(obj1, &val2);
15303 if (!SWIG_IsOK(ecode2)) {
15304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
15305 }
15306 arg2 = static_cast< int >(val2);
15307 ecode3 = SWIG_AsVal_int(obj2, &val3);
15308 if (!SWIG_IsOK(ecode3)) {
15309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
15310 }
15311 arg3 = static_cast< int >(val3);
15312 ecode4 = SWIG_AsVal_int(obj3, &val4);
15313 if (!SWIG_IsOK(ecode4)) {
15314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
15315 }
15316 arg4 = static_cast< int >(val4);
15317 ecode5 = SWIG_AsVal_int(obj4, &val5);
15318 if (!SWIG_IsOK(ecode5)) {
15319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
15320 }
15321 arg5 = static_cast< int >(val5);
15322 ecode6 = SWIG_AsVal_double(obj5, &val6);
15323 if (!SWIG_IsOK(ecode6)) {
15324 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
15325 }
15326 arg6 = static_cast< double >(val6);
15327 ecode7 = SWIG_AsVal_double(obj6, &val7);
15328 if (!SWIG_IsOK(ecode7)) {
15329 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
15330 }
15331 arg7 = static_cast< double >(val7);
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 resultobj = SWIG_Py_Void();
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15346 PyObject *resultobj = 0;
15347 wxDC *arg1 = (wxDC *) 0 ;
15348 wxPoint *arg2 = 0 ;
15349 wxSize *arg3 = 0 ;
15350 double arg4 ;
15351 double arg5 ;
15352 void *argp1 = 0 ;
15353 int res1 = 0 ;
15354 wxPoint temp2 ;
15355 wxSize temp3 ;
15356 double val4 ;
15357 int ecode4 = 0 ;
15358 double val5 ;
15359 int ecode5 = 0 ;
15360 PyObject * obj0 = 0 ;
15361 PyObject * obj1 = 0 ;
15362 PyObject * obj2 = 0 ;
15363 PyObject * obj3 = 0 ;
15364 PyObject * obj4 = 0 ;
15365 char * kwnames[] = {
15366 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
15367 };
15368
15369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15371 if (!SWIG_IsOK(res1)) {
15372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15373 }
15374 arg1 = reinterpret_cast< wxDC * >(argp1);
15375 {
15376 arg2 = &temp2;
15377 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15378 }
15379 {
15380 arg3 = &temp3;
15381 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15382 }
15383 ecode4 = SWIG_AsVal_double(obj3, &val4);
15384 if (!SWIG_IsOK(ecode4)) {
15385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
15386 }
15387 arg4 = static_cast< double >(val4);
15388 ecode5 = SWIG_AsVal_double(obj4, &val5);
15389 if (!SWIG_IsOK(ecode5)) {
15390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
15391 }
15392 arg5 = static_cast< double >(val5);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_Py_Void();
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_DC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj = 0;
15408 wxDC *arg1 = (wxDC *) 0 ;
15409 int arg2 ;
15410 int arg3 ;
15411 void *argp1 = 0 ;
15412 int res1 = 0 ;
15413 int val2 ;
15414 int ecode2 = 0 ;
15415 int val3 ;
15416 int ecode3 = 0 ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 PyObject * obj2 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "x",(char *) "y", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15428 }
15429 arg1 = reinterpret_cast< wxDC * >(argp1);
15430 ecode2 = SWIG_AsVal_int(obj1, &val2);
15431 if (!SWIG_IsOK(ecode2)) {
15432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
15433 }
15434 arg2 = static_cast< int >(val2);
15435 ecode3 = SWIG_AsVal_int(obj2, &val3);
15436 if (!SWIG_IsOK(ecode3)) {
15437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
15438 }
15439 arg3 = static_cast< int >(val3);
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 (arg1)->DrawPoint(arg2,arg3);
15443 wxPyEndAllowThreads(__tstate);
15444 if (PyErr_Occurred()) SWIG_fail;
15445 }
15446 resultobj = SWIG_Py_Void();
15447 return resultobj;
15448 fail:
15449 return NULL;
15450 }
15451
15452
15453 SWIGINTERN PyObject *_wrap_DC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15454 PyObject *resultobj = 0;
15455 wxDC *arg1 = (wxDC *) 0 ;
15456 wxPoint *arg2 = 0 ;
15457 void *argp1 = 0 ;
15458 int res1 = 0 ;
15459 wxPoint temp2 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 char * kwnames[] = {
15463 (char *) "self",(char *) "pt", NULL
15464 };
15465
15466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
15467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15468 if (!SWIG_IsOK(res1)) {
15469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPointPoint" "', expected argument " "1"" of type '" "wxDC *""'");
15470 }
15471 arg1 = reinterpret_cast< wxDC * >(argp1);
15472 {
15473 arg2 = &temp2;
15474 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15475 }
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 (arg1)->DrawPoint((wxPoint const &)*arg2);
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 resultobj = SWIG_Py_Void();
15483 return resultobj;
15484 fail:
15485 return NULL;
15486 }
15487
15488
15489 SWIGINTERN PyObject *_wrap_DC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15490 PyObject *resultobj = 0;
15491 wxDC *arg1 = (wxDC *) 0 ;
15492 int arg2 ;
15493 int arg3 ;
15494 int arg4 ;
15495 int arg5 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 int val2 ;
15499 int ecode2 = 0 ;
15500 int val3 ;
15501 int ecode3 = 0 ;
15502 int val4 ;
15503 int ecode4 = 0 ;
15504 int val5 ;
15505 int ecode5 = 0 ;
15506 PyObject * obj0 = 0 ;
15507 PyObject * obj1 = 0 ;
15508 PyObject * obj2 = 0 ;
15509 PyObject * obj3 = 0 ;
15510 PyObject * obj4 = 0 ;
15511 char * kwnames[] = {
15512 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15513 };
15514
15515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15517 if (!SWIG_IsOK(res1)) {
15518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
15519 }
15520 arg1 = reinterpret_cast< wxDC * >(argp1);
15521 ecode2 = SWIG_AsVal_int(obj1, &val2);
15522 if (!SWIG_IsOK(ecode2)) {
15523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
15524 }
15525 arg2 = static_cast< int >(val2);
15526 ecode3 = SWIG_AsVal_int(obj2, &val3);
15527 if (!SWIG_IsOK(ecode3)) {
15528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
15529 }
15530 arg3 = static_cast< int >(val3);
15531 ecode4 = SWIG_AsVal_int(obj3, &val4);
15532 if (!SWIG_IsOK(ecode4)) {
15533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
15534 }
15535 arg4 = static_cast< int >(val4);
15536 ecode5 = SWIG_AsVal_int(obj4, &val5);
15537 if (!SWIG_IsOK(ecode5)) {
15538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
15539 }
15540 arg5 = static_cast< int >(val5);
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
15544 wxPyEndAllowThreads(__tstate);
15545 if (PyErr_Occurred()) SWIG_fail;
15546 }
15547 resultobj = SWIG_Py_Void();
15548 return resultobj;
15549 fail:
15550 return NULL;
15551 }
15552
15553
15554 SWIGINTERN PyObject *_wrap_DC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15555 PyObject *resultobj = 0;
15556 wxDC *arg1 = (wxDC *) 0 ;
15557 wxRect *arg2 = 0 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 wxRect temp2 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char * kwnames[] = {
15564 (char *) "self",(char *) "rect", NULL
15565 };
15566
15567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
15568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
15571 }
15572 arg1 = reinterpret_cast< wxDC * >(argp1);
15573 {
15574 arg2 = &temp2;
15575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15576 }
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 (arg1)->DrawRectangle((wxRect const &)*arg2);
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 resultobj = SWIG_Py_Void();
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 SWIGINTERN PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15591 PyObject *resultobj = 0;
15592 wxDC *arg1 = (wxDC *) 0 ;
15593 wxPoint *arg2 = 0 ;
15594 wxSize *arg3 = 0 ;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 wxPoint temp2 ;
15598 wxSize temp3 ;
15599 PyObject * obj0 = 0 ;
15600 PyObject * obj1 = 0 ;
15601 PyObject * obj2 = 0 ;
15602 char * kwnames[] = {
15603 (char *) "self",(char *) "pt",(char *) "sz", NULL
15604 };
15605
15606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15610 }
15611 arg1 = reinterpret_cast< wxDC * >(argp1);
15612 {
15613 arg2 = &temp2;
15614 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15615 }
15616 {
15617 arg3 = &temp3;
15618 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15619 }
15620 {
15621 PyThreadState* __tstate = wxPyBeginAllowThreads();
15622 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_Py_Void();
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj = 0;
15635 wxDC *arg1 = (wxDC *) 0 ;
15636 int arg2 ;
15637 int arg3 ;
15638 int arg4 ;
15639 int arg5 ;
15640 double arg6 ;
15641 void *argp1 = 0 ;
15642 int res1 = 0 ;
15643 int val2 ;
15644 int ecode2 = 0 ;
15645 int val3 ;
15646 int ecode3 = 0 ;
15647 int val4 ;
15648 int ecode4 = 0 ;
15649 int val5 ;
15650 int ecode5 = 0 ;
15651 double val6 ;
15652 int ecode6 = 0 ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 PyObject * obj2 = 0 ;
15656 PyObject * obj3 = 0 ;
15657 PyObject * obj4 = 0 ;
15658 PyObject * obj5 = 0 ;
15659 char * kwnames[] = {
15660 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
15661 };
15662
15663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15665 if (!SWIG_IsOK(res1)) {
15666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
15667 }
15668 arg1 = reinterpret_cast< wxDC * >(argp1);
15669 ecode2 = SWIG_AsVal_int(obj1, &val2);
15670 if (!SWIG_IsOK(ecode2)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
15672 }
15673 arg2 = static_cast< int >(val2);
15674 ecode3 = SWIG_AsVal_int(obj2, &val3);
15675 if (!SWIG_IsOK(ecode3)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
15677 }
15678 arg3 = static_cast< int >(val3);
15679 ecode4 = SWIG_AsVal_int(obj3, &val4);
15680 if (!SWIG_IsOK(ecode4)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
15682 }
15683 arg4 = static_cast< int >(val4);
15684 ecode5 = SWIG_AsVal_int(obj4, &val5);
15685 if (!SWIG_IsOK(ecode5)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
15687 }
15688 arg5 = static_cast< int >(val5);
15689 ecode6 = SWIG_AsVal_double(obj5, &val6);
15690 if (!SWIG_IsOK(ecode6)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
15692 }
15693 arg6 = static_cast< double >(val6);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj = 0;
15709 wxDC *arg1 = (wxDC *) 0 ;
15710 wxRect *arg2 = 0 ;
15711 double arg3 ;
15712 void *argp1 = 0 ;
15713 int res1 = 0 ;
15714 wxRect temp2 ;
15715 double val3 ;
15716 int ecode3 = 0 ;
15717 PyObject * obj0 = 0 ;
15718 PyObject * obj1 = 0 ;
15719 PyObject * obj2 = 0 ;
15720 char * kwnames[] = {
15721 (char *) "self",(char *) "r",(char *) "radius", NULL
15722 };
15723
15724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15726 if (!SWIG_IsOK(res1)) {
15727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
15728 }
15729 arg1 = reinterpret_cast< wxDC * >(argp1);
15730 {
15731 arg2 = &temp2;
15732 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15733 }
15734 ecode3 = SWIG_AsVal_double(obj2, &val3);
15735 if (!SWIG_IsOK(ecode3)) {
15736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
15737 }
15738 arg3 = static_cast< double >(val3);
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 resultobj = SWIG_Py_Void();
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15753 PyObject *resultobj = 0;
15754 wxDC *arg1 = (wxDC *) 0 ;
15755 wxPoint *arg2 = 0 ;
15756 wxSize *arg3 = 0 ;
15757 double arg4 ;
15758 void *argp1 = 0 ;
15759 int res1 = 0 ;
15760 wxPoint temp2 ;
15761 wxSize temp3 ;
15762 double val4 ;
15763 int ecode4 = 0 ;
15764 PyObject * obj0 = 0 ;
15765 PyObject * obj1 = 0 ;
15766 PyObject * obj2 = 0 ;
15767 PyObject * obj3 = 0 ;
15768 char * kwnames[] = {
15769 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
15770 };
15771
15772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15774 if (!SWIG_IsOK(res1)) {
15775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
15776 }
15777 arg1 = reinterpret_cast< wxDC * >(argp1);
15778 {
15779 arg2 = &temp2;
15780 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15781 }
15782 {
15783 arg3 = &temp3;
15784 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
15785 }
15786 ecode4 = SWIG_AsVal_double(obj3, &val4);
15787 if (!SWIG_IsOK(ecode4)) {
15788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
15789 }
15790 arg4 = static_cast< double >(val4);
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 resultobj = SWIG_Py_Void();
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 SWIGINTERN PyObject *_wrap_DC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj = 0;
15806 wxDC *arg1 = (wxDC *) 0 ;
15807 int arg2 ;
15808 int arg3 ;
15809 int arg4 ;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 int val2 ;
15813 int ecode2 = 0 ;
15814 int val3 ;
15815 int ecode3 = 0 ;
15816 int val4 ;
15817 int ecode4 = 0 ;
15818 PyObject * obj0 = 0 ;
15819 PyObject * obj1 = 0 ;
15820 PyObject * obj2 = 0 ;
15821 PyObject * obj3 = 0 ;
15822 char * kwnames[] = {
15823 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
15824 };
15825
15826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15828 if (!SWIG_IsOK(res1)) {
15829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCircle" "', expected argument " "1"" of type '" "wxDC *""'");
15830 }
15831 arg1 = reinterpret_cast< wxDC * >(argp1);
15832 ecode2 = SWIG_AsVal_int(obj1, &val2);
15833 if (!SWIG_IsOK(ecode2)) {
15834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
15835 }
15836 arg2 = static_cast< int >(val2);
15837 ecode3 = SWIG_AsVal_int(obj2, &val3);
15838 if (!SWIG_IsOK(ecode3)) {
15839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
15840 }
15841 arg3 = static_cast< int >(val3);
15842 ecode4 = SWIG_AsVal_int(obj3, &val4);
15843 if (!SWIG_IsOK(ecode4)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
15845 }
15846 arg4 = static_cast< int >(val4);
15847 {
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 (arg1)->DrawCircle(arg2,arg3,arg4);
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = SWIG_Py_Void();
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_DC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15861 PyObject *resultobj = 0;
15862 wxDC *arg1 = (wxDC *) 0 ;
15863 wxPoint *arg2 = 0 ;
15864 int arg3 ;
15865 void *argp1 = 0 ;
15866 int res1 = 0 ;
15867 wxPoint temp2 ;
15868 int val3 ;
15869 int ecode3 = 0 ;
15870 PyObject * obj0 = 0 ;
15871 PyObject * obj1 = 0 ;
15872 PyObject * obj2 = 0 ;
15873 char * kwnames[] = {
15874 (char *) "self",(char *) "pt",(char *) "radius", NULL
15875 };
15876
15877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15879 if (!SWIG_IsOK(res1)) {
15880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxDC *""'");
15881 }
15882 arg1 = reinterpret_cast< wxDC * >(argp1);
15883 {
15884 arg2 = &temp2;
15885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15886 }
15887 ecode3 = SWIG_AsVal_int(obj2, &val3);
15888 if (!SWIG_IsOK(ecode3)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
15890 }
15891 arg3 = static_cast< int >(val3);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_Py_Void();
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_DC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj = 0;
15907 wxDC *arg1 = (wxDC *) 0 ;
15908 int arg2 ;
15909 int arg3 ;
15910 int arg4 ;
15911 int arg5 ;
15912 void *argp1 = 0 ;
15913 int res1 = 0 ;
15914 int val2 ;
15915 int ecode2 = 0 ;
15916 int val3 ;
15917 int ecode3 = 0 ;
15918 int val4 ;
15919 int ecode4 = 0 ;
15920 int val5 ;
15921 int ecode5 = 0 ;
15922 PyObject * obj0 = 0 ;
15923 PyObject * obj1 = 0 ;
15924 PyObject * obj2 = 0 ;
15925 PyObject * obj3 = 0 ;
15926 PyObject * obj4 = 0 ;
15927 char * kwnames[] = {
15928 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
15929 };
15930
15931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipse" "', expected argument " "1"" of type '" "wxDC *""'");
15935 }
15936 arg1 = reinterpret_cast< wxDC * >(argp1);
15937 ecode2 = SWIG_AsVal_int(obj1, &val2);
15938 if (!SWIG_IsOK(ecode2)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
15940 }
15941 arg2 = static_cast< int >(val2);
15942 ecode3 = SWIG_AsVal_int(obj2, &val3);
15943 if (!SWIG_IsOK(ecode3)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
15945 }
15946 arg3 = static_cast< int >(val3);
15947 ecode4 = SWIG_AsVal_int(obj3, &val4);
15948 if (!SWIG_IsOK(ecode4)) {
15949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
15950 }
15951 arg4 = static_cast< int >(val4);
15952 ecode5 = SWIG_AsVal_int(obj4, &val5);
15953 if (!SWIG_IsOK(ecode5)) {
15954 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
15955 }
15956 arg5 = static_cast< int >(val5);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_Py_Void();
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_DC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15971 PyObject *resultobj = 0;
15972 wxDC *arg1 = (wxDC *) 0 ;
15973 wxRect *arg2 = 0 ;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 wxRect temp2 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 char * kwnames[] = {
15980 (char *) "self",(char *) "rect", NULL
15981 };
15982
15983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
15984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
15985 if (!SWIG_IsOK(res1)) {
15986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxDC *""'");
15987 }
15988 arg1 = reinterpret_cast< wxDC * >(argp1);
15989 {
15990 arg2 = &temp2;
15991 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15992 }
15993 {
15994 PyThreadState* __tstate = wxPyBeginAllowThreads();
15995 (arg1)->DrawEllipse((wxRect const &)*arg2);
15996 wxPyEndAllowThreads(__tstate);
15997 if (PyErr_Occurred()) SWIG_fail;
15998 }
15999 resultobj = SWIG_Py_Void();
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16007 PyObject *resultobj = 0;
16008 wxDC *arg1 = (wxDC *) 0 ;
16009 wxPoint *arg2 = 0 ;
16010 wxSize *arg3 = 0 ;
16011 void *argp1 = 0 ;
16012 int res1 = 0 ;
16013 wxPoint temp2 ;
16014 wxSize temp3 ;
16015 PyObject * obj0 = 0 ;
16016 PyObject * obj1 = 0 ;
16017 PyObject * obj2 = 0 ;
16018 char * kwnames[] = {
16019 (char *) "self",(char *) "pt",(char *) "sz", NULL
16020 };
16021
16022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16024 if (!SWIG_IsOK(res1)) {
16025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
16026 }
16027 arg1 = reinterpret_cast< wxDC * >(argp1);
16028 {
16029 arg2 = &temp2;
16030 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16031 }
16032 {
16033 arg3 = &temp3;
16034 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16035 }
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 resultobj = SWIG_Py_Void();
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_DC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj = 0;
16051 wxDC *arg1 = (wxDC *) 0 ;
16052 wxIcon *arg2 = 0 ;
16053 int arg3 ;
16054 int arg4 ;
16055 void *argp1 = 0 ;
16056 int res1 = 0 ;
16057 void *argp2 = 0 ;
16058 int res2 = 0 ;
16059 int val3 ;
16060 int ecode3 = 0 ;
16061 int val4 ;
16062 int ecode4 = 0 ;
16063 PyObject * obj0 = 0 ;
16064 PyObject * obj1 = 0 ;
16065 PyObject * obj2 = 0 ;
16066 PyObject * obj3 = 0 ;
16067 char * kwnames[] = {
16068 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
16069 };
16070
16071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16073 if (!SWIG_IsOK(res1)) {
16074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIcon" "', expected argument " "1"" of type '" "wxDC *""'");
16075 }
16076 arg1 = reinterpret_cast< wxDC * >(argp1);
16077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
16078 if (!SWIG_IsOK(res2)) {
16079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
16080 }
16081 if (!argp2) {
16082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
16083 }
16084 arg2 = reinterpret_cast< wxIcon * >(argp2);
16085 ecode3 = SWIG_AsVal_int(obj2, &val3);
16086 if (!SWIG_IsOK(ecode3)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
16088 }
16089 arg3 = static_cast< int >(val3);
16090 ecode4 = SWIG_AsVal_int(obj3, &val4);
16091 if (!SWIG_IsOK(ecode4)) {
16092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
16093 }
16094 arg4 = static_cast< int >(val4);
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_Py_Void();
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_DC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxDC *arg1 = (wxDC *) 0 ;
16111 wxIcon *arg2 = 0 ;
16112 wxPoint *arg3 = 0 ;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 void *argp2 = 0 ;
16116 int res2 = 0 ;
16117 wxPoint temp3 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 char * kwnames[] = {
16122 (char *) "self",(char *) "icon",(char *) "pt", NULL
16123 };
16124
16125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIconPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16129 }
16130 arg1 = reinterpret_cast< wxDC * >(argp1);
16131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
16132 if (!SWIG_IsOK(res2)) {
16133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
16134 }
16135 if (!argp2) {
16136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
16137 }
16138 arg2 = reinterpret_cast< wxIcon * >(argp2);
16139 {
16140 arg3 = &temp3;
16141 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_Py_Void();
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_DC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = 0;
16158 wxDC *arg1 = (wxDC *) 0 ;
16159 wxBitmap *arg2 = 0 ;
16160 int arg3 ;
16161 int arg4 ;
16162 bool arg5 = (bool) false ;
16163 void *argp1 = 0 ;
16164 int res1 = 0 ;
16165 void *argp2 = 0 ;
16166 int res2 = 0 ;
16167 int val3 ;
16168 int ecode3 = 0 ;
16169 int val4 ;
16170 int ecode4 = 0 ;
16171 bool val5 ;
16172 int ecode5 = 0 ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 PyObject * obj2 = 0 ;
16176 PyObject * obj3 = 0 ;
16177 PyObject * obj4 = 0 ;
16178 char * kwnames[] = {
16179 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
16180 };
16181
16182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16184 if (!SWIG_IsOK(res1)) {
16185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmap" "', expected argument " "1"" of type '" "wxDC *""'");
16186 }
16187 arg1 = reinterpret_cast< wxDC * >(argp1);
16188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
16189 if (!SWIG_IsOK(res2)) {
16190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16191 }
16192 if (!argp2) {
16193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16194 }
16195 arg2 = reinterpret_cast< wxBitmap * >(argp2);
16196 ecode3 = SWIG_AsVal_int(obj2, &val3);
16197 if (!SWIG_IsOK(ecode3)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
16199 }
16200 arg3 = static_cast< int >(val3);
16201 ecode4 = SWIG_AsVal_int(obj3, &val4);
16202 if (!SWIG_IsOK(ecode4)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
16204 }
16205 arg4 = static_cast< int >(val4);
16206 if (obj4) {
16207 ecode5 = SWIG_AsVal_bool(obj4, &val5);
16208 if (!SWIG_IsOK(ecode5)) {
16209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
16210 }
16211 arg5 = static_cast< bool >(val5);
16212 }
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
16216 wxPyEndAllowThreads(__tstate);
16217 if (PyErr_Occurred()) SWIG_fail;
16218 }
16219 resultobj = SWIG_Py_Void();
16220 return resultobj;
16221 fail:
16222 return NULL;
16223 }
16224
16225
16226 SWIGINTERN PyObject *_wrap_DC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16227 PyObject *resultobj = 0;
16228 wxDC *arg1 = (wxDC *) 0 ;
16229 wxBitmap *arg2 = 0 ;
16230 wxPoint *arg3 = 0 ;
16231 bool arg4 = (bool) false ;
16232 void *argp1 = 0 ;
16233 int res1 = 0 ;
16234 void *argp2 = 0 ;
16235 int res2 = 0 ;
16236 wxPoint temp3 ;
16237 bool val4 ;
16238 int ecode4 = 0 ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 PyObject * obj2 = 0 ;
16242 PyObject * obj3 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16251 }
16252 arg1 = reinterpret_cast< wxDC * >(argp1);
16253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
16254 if (!SWIG_IsOK(res2)) {
16255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16256 }
16257 if (!argp2) {
16258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
16259 }
16260 arg2 = reinterpret_cast< wxBitmap * >(argp2);
16261 {
16262 arg3 = &temp3;
16263 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16264 }
16265 if (obj3) {
16266 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16267 if (!SWIG_IsOK(ecode4)) {
16268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
16269 }
16270 arg4 = static_cast< bool >(val4);
16271 }
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 resultobj = SWIG_Py_Void();
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 SWIGINTERN PyObject *_wrap_DC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj = 0;
16287 wxDC *arg1 = (wxDC *) 0 ;
16288 wxString *arg2 = 0 ;
16289 int arg3 ;
16290 int arg4 ;
16291 void *argp1 = 0 ;
16292 int res1 = 0 ;
16293 bool temp2 = false ;
16294 int val3 ;
16295 int ecode3 = 0 ;
16296 int val4 ;
16297 int ecode4 = 0 ;
16298 PyObject * obj0 = 0 ;
16299 PyObject * obj1 = 0 ;
16300 PyObject * obj2 = 0 ;
16301 PyObject * obj3 = 0 ;
16302 char * kwnames[] = {
16303 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
16304 };
16305
16306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16308 if (!SWIG_IsOK(res1)) {
16309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawText" "', expected argument " "1"" of type '" "wxDC *""'");
16310 }
16311 arg1 = reinterpret_cast< wxDC * >(argp1);
16312 {
16313 arg2 = wxString_in_helper(obj1);
16314 if (arg2 == NULL) SWIG_fail;
16315 temp2 = true;
16316 }
16317 ecode3 = SWIG_AsVal_int(obj2, &val3);
16318 if (!SWIG_IsOK(ecode3)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawText" "', expected argument " "3"" of type '" "int""'");
16320 }
16321 arg3 = static_cast< int >(val3);
16322 ecode4 = SWIG_AsVal_int(obj3, &val4);
16323 if (!SWIG_IsOK(ecode4)) {
16324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawText" "', expected argument " "4"" of type '" "int""'");
16325 }
16326 arg4 = static_cast< int >(val4);
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
16330 wxPyEndAllowThreads(__tstate);
16331 if (PyErr_Occurred()) SWIG_fail;
16332 }
16333 resultobj = SWIG_Py_Void();
16334 {
16335 if (temp2)
16336 delete arg2;
16337 }
16338 return resultobj;
16339 fail:
16340 {
16341 if (temp2)
16342 delete arg2;
16343 }
16344 return NULL;
16345 }
16346
16347
16348 SWIGINTERN PyObject *_wrap_DC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj = 0;
16350 wxDC *arg1 = (wxDC *) 0 ;
16351 wxString *arg2 = 0 ;
16352 wxPoint *arg3 = 0 ;
16353 void *argp1 = 0 ;
16354 int res1 = 0 ;
16355 bool temp2 = false ;
16356 wxPoint temp3 ;
16357 PyObject * obj0 = 0 ;
16358 PyObject * obj1 = 0 ;
16359 PyObject * obj2 = 0 ;
16360 char * kwnames[] = {
16361 (char *) "self",(char *) "text",(char *) "pt", NULL
16362 };
16363
16364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16366 if (!SWIG_IsOK(res1)) {
16367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16368 }
16369 arg1 = reinterpret_cast< wxDC * >(argp1);
16370 {
16371 arg2 = wxString_in_helper(obj1);
16372 if (arg2 == NULL) SWIG_fail;
16373 temp2 = true;
16374 }
16375 {
16376 arg3 = &temp3;
16377 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16378 }
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 resultobj = SWIG_Py_Void();
16386 {
16387 if (temp2)
16388 delete arg2;
16389 }
16390 return resultobj;
16391 fail:
16392 {
16393 if (temp2)
16394 delete arg2;
16395 }
16396 return NULL;
16397 }
16398
16399
16400 SWIGINTERN PyObject *_wrap_DC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16401 PyObject *resultobj = 0;
16402 wxDC *arg1 = (wxDC *) 0 ;
16403 wxString *arg2 = 0 ;
16404 int arg3 ;
16405 int arg4 ;
16406 double arg5 ;
16407 void *argp1 = 0 ;
16408 int res1 = 0 ;
16409 bool temp2 = false ;
16410 int val3 ;
16411 int ecode3 = 0 ;
16412 int val4 ;
16413 int ecode4 = 0 ;
16414 double val5 ;
16415 int ecode5 = 0 ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 PyObject * obj2 = 0 ;
16419 PyObject * obj3 = 0 ;
16420 PyObject * obj4 = 0 ;
16421 char * kwnames[] = {
16422 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
16423 };
16424
16425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16427 if (!SWIG_IsOK(res1)) {
16428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedText" "', expected argument " "1"" of type '" "wxDC *""'");
16429 }
16430 arg1 = reinterpret_cast< wxDC * >(argp1);
16431 {
16432 arg2 = wxString_in_helper(obj1);
16433 if (arg2 == NULL) SWIG_fail;
16434 temp2 = true;
16435 }
16436 ecode3 = SWIG_AsVal_int(obj2, &val3);
16437 if (!SWIG_IsOK(ecode3)) {
16438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
16439 }
16440 arg3 = static_cast< int >(val3);
16441 ecode4 = SWIG_AsVal_int(obj3, &val4);
16442 if (!SWIG_IsOK(ecode4)) {
16443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
16444 }
16445 arg4 = static_cast< int >(val4);
16446 ecode5 = SWIG_AsVal_double(obj4, &val5);
16447 if (!SWIG_IsOK(ecode5)) {
16448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
16449 }
16450 arg5 = static_cast< double >(val5);
16451 {
16452 PyThreadState* __tstate = wxPyBeginAllowThreads();
16453 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
16454 wxPyEndAllowThreads(__tstate);
16455 if (PyErr_Occurred()) SWIG_fail;
16456 }
16457 resultobj = SWIG_Py_Void();
16458 {
16459 if (temp2)
16460 delete arg2;
16461 }
16462 return resultobj;
16463 fail:
16464 {
16465 if (temp2)
16466 delete arg2;
16467 }
16468 return NULL;
16469 }
16470
16471
16472 SWIGINTERN PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj = 0;
16474 wxDC *arg1 = (wxDC *) 0 ;
16475 wxString *arg2 = 0 ;
16476 wxPoint *arg3 = 0 ;
16477 double arg4 ;
16478 void *argp1 = 0 ;
16479 int res1 = 0 ;
16480 bool temp2 = false ;
16481 wxPoint temp3 ;
16482 double val4 ;
16483 int ecode4 = 0 ;
16484 PyObject * obj0 = 0 ;
16485 PyObject * obj1 = 0 ;
16486 PyObject * obj2 = 0 ;
16487 PyObject * obj3 = 0 ;
16488 char * kwnames[] = {
16489 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
16490 };
16491
16492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16494 if (!SWIG_IsOK(res1)) {
16495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
16496 }
16497 arg1 = reinterpret_cast< wxDC * >(argp1);
16498 {
16499 arg2 = wxString_in_helper(obj1);
16500 if (arg2 == NULL) SWIG_fail;
16501 temp2 = true;
16502 }
16503 {
16504 arg3 = &temp3;
16505 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16506 }
16507 ecode4 = SWIG_AsVal_double(obj3, &val4);
16508 if (!SWIG_IsOK(ecode4)) {
16509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
16510 }
16511 arg4 = static_cast< double >(val4);
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_Py_Void();
16519 {
16520 if (temp2)
16521 delete arg2;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp2)
16527 delete arg2;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_DC_Blit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxDC *arg1 = (wxDC *) 0 ;
16536 int arg2 ;
16537 int arg3 ;
16538 int arg4 ;
16539 int arg5 ;
16540 wxDC *arg6 = (wxDC *) 0 ;
16541 int arg7 ;
16542 int arg8 ;
16543 int arg9 = (int) wxCOPY ;
16544 bool arg10 = (bool) false ;
16545 int arg11 = (int) -1 ;
16546 int arg12 = (int) -1 ;
16547 bool result;
16548 void *argp1 = 0 ;
16549 int res1 = 0 ;
16550 int val2 ;
16551 int ecode2 = 0 ;
16552 int val3 ;
16553 int ecode3 = 0 ;
16554 int val4 ;
16555 int ecode4 = 0 ;
16556 int val5 ;
16557 int ecode5 = 0 ;
16558 void *argp6 = 0 ;
16559 int res6 = 0 ;
16560 int val7 ;
16561 int ecode7 = 0 ;
16562 int val8 ;
16563 int ecode8 = 0 ;
16564 int val9 ;
16565 int ecode9 = 0 ;
16566 bool val10 ;
16567 int ecode10 = 0 ;
16568 int val11 ;
16569 int ecode11 = 0 ;
16570 int val12 ;
16571 int ecode12 = 0 ;
16572 PyObject * obj0 = 0 ;
16573 PyObject * obj1 = 0 ;
16574 PyObject * obj2 = 0 ;
16575 PyObject * obj3 = 0 ;
16576 PyObject * obj4 = 0 ;
16577 PyObject * obj5 = 0 ;
16578 PyObject * obj6 = 0 ;
16579 PyObject * obj7 = 0 ;
16580 PyObject * obj8 = 0 ;
16581 PyObject * obj9 = 0 ;
16582 PyObject * obj10 = 0 ;
16583 PyObject * obj11 = 0 ;
16584 char * kwnames[] = {
16585 (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
16586 };
16587
16588 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;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Blit" "', expected argument " "1"" of type '" "wxDC *""'");
16592 }
16593 arg1 = reinterpret_cast< wxDC * >(argp1);
16594 ecode2 = SWIG_AsVal_int(obj1, &val2);
16595 if (!SWIG_IsOK(ecode2)) {
16596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_Blit" "', expected argument " "2"" of type '" "int""'");
16597 }
16598 arg2 = static_cast< int >(val2);
16599 ecode3 = SWIG_AsVal_int(obj2, &val3);
16600 if (!SWIG_IsOK(ecode3)) {
16601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_Blit" "', expected argument " "3"" of type '" "int""'");
16602 }
16603 arg3 = static_cast< int >(val3);
16604 ecode4 = SWIG_AsVal_int(obj3, &val4);
16605 if (!SWIG_IsOK(ecode4)) {
16606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_Blit" "', expected argument " "4"" of type '" "int""'");
16607 }
16608 arg4 = static_cast< int >(val4);
16609 ecode5 = SWIG_AsVal_int(obj4, &val5);
16610 if (!SWIG_IsOK(ecode5)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_Blit" "', expected argument " "5"" of type '" "int""'");
16612 }
16613 arg5 = static_cast< int >(val5);
16614 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );
16615 if (!SWIG_IsOK(res6)) {
16616 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_Blit" "', expected argument " "6"" of type '" "wxDC *""'");
16617 }
16618 arg6 = reinterpret_cast< wxDC * >(argp6);
16619 ecode7 = SWIG_AsVal_int(obj6, &val7);
16620 if (!SWIG_IsOK(ecode7)) {
16621 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_Blit" "', expected argument " "7"" of type '" "int""'");
16622 }
16623 arg7 = static_cast< int >(val7);
16624 ecode8 = SWIG_AsVal_int(obj7, &val8);
16625 if (!SWIG_IsOK(ecode8)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DC_Blit" "', expected argument " "8"" of type '" "int""'");
16627 }
16628 arg8 = static_cast< int >(val8);
16629 if (obj8) {
16630 ecode9 = SWIG_AsVal_int(obj8, &val9);
16631 if (!SWIG_IsOK(ecode9)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DC_Blit" "', expected argument " "9"" of type '" "int""'");
16633 }
16634 arg9 = static_cast< int >(val9);
16635 }
16636 if (obj9) {
16637 ecode10 = SWIG_AsVal_bool(obj9, &val10);
16638 if (!SWIG_IsOK(ecode10)) {
16639 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DC_Blit" "', expected argument " "10"" of type '" "bool""'");
16640 }
16641 arg10 = static_cast< bool >(val10);
16642 }
16643 if (obj10) {
16644 ecode11 = SWIG_AsVal_int(obj10, &val11);
16645 if (!SWIG_IsOK(ecode11)) {
16646 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DC_Blit" "', expected argument " "11"" of type '" "int""'");
16647 }
16648 arg11 = static_cast< int >(val11);
16649 }
16650 if (obj11) {
16651 ecode12 = SWIG_AsVal_int(obj11, &val12);
16652 if (!SWIG_IsOK(ecode12)) {
16653 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DC_Blit" "', expected argument " "12"" of type '" "int""'");
16654 }
16655 arg12 = static_cast< int >(val12);
16656 }
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 {
16664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 SWIGINTERN PyObject *_wrap_DC_BlitPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj = 0;
16674 wxDC *arg1 = (wxDC *) 0 ;
16675 wxPoint *arg2 = 0 ;
16676 wxSize *arg3 = 0 ;
16677 wxDC *arg4 = (wxDC *) 0 ;
16678 wxPoint *arg5 = 0 ;
16679 int arg6 = (int) wxCOPY ;
16680 bool arg7 = (bool) false ;
16681 wxPoint const &arg8_defvalue = wxDefaultPosition ;
16682 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
16683 bool result;
16684 void *argp1 = 0 ;
16685 int res1 = 0 ;
16686 wxPoint temp2 ;
16687 wxSize temp3 ;
16688 void *argp4 = 0 ;
16689 int res4 = 0 ;
16690 wxPoint temp5 ;
16691 int val6 ;
16692 int ecode6 = 0 ;
16693 bool val7 ;
16694 int ecode7 = 0 ;
16695 wxPoint temp8 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 PyObject * obj3 = 0 ;
16700 PyObject * obj4 = 0 ;
16701 PyObject * obj5 = 0 ;
16702 PyObject * obj6 = 0 ;
16703 PyObject * obj7 = 0 ;
16704 char * kwnames[] = {
16705 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
16706 };
16707
16708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
16709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16710 if (!SWIG_IsOK(res1)) {
16711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_BlitPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
16712 }
16713 arg1 = reinterpret_cast< wxDC * >(argp1);
16714 {
16715 arg2 = &temp2;
16716 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16717 }
16718 {
16719 arg3 = &temp3;
16720 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16721 }
16722 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxDC, 0 | 0 );
16723 if (!SWIG_IsOK(res4)) {
16724 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DC_BlitPointSize" "', expected argument " "4"" of type '" "wxDC *""'");
16725 }
16726 arg4 = reinterpret_cast< wxDC * >(argp4);
16727 {
16728 arg5 = &temp5;
16729 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
16730 }
16731 if (obj5) {
16732 ecode6 = SWIG_AsVal_int(obj5, &val6);
16733 if (!SWIG_IsOK(ecode6)) {
16734 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_BlitPointSize" "', expected argument " "6"" of type '" "int""'");
16735 }
16736 arg6 = static_cast< int >(val6);
16737 }
16738 if (obj6) {
16739 ecode7 = SWIG_AsVal_bool(obj6, &val7);
16740 if (!SWIG_IsOK(ecode7)) {
16741 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_BlitPointSize" "', expected argument " "7"" of type '" "bool""'");
16742 }
16743 arg7 = static_cast< bool >(val7);
16744 }
16745 if (obj7) {
16746 {
16747 arg8 = &temp8;
16748 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
16749 }
16750 }
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 {
16758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16759 }
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 SWIGINTERN PyObject *_wrap_DC_SetClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj = 0;
16768 wxDC *arg1 = (wxDC *) 0 ;
16769 int arg2 ;
16770 int arg3 ;
16771 int arg4 ;
16772 int arg5 ;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 int val2 ;
16776 int ecode2 = 0 ;
16777 int val3 ;
16778 int ecode3 = 0 ;
16779 int val4 ;
16780 int ecode4 = 0 ;
16781 int val5 ;
16782 int ecode5 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 PyObject * obj1 = 0 ;
16785 PyObject * obj2 = 0 ;
16786 PyObject * obj3 = 0 ;
16787 PyObject * obj4 = 0 ;
16788 char * kwnames[] = {
16789 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
16790 };
16791
16792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16794 if (!SWIG_IsOK(res1)) {
16795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
16796 }
16797 arg1 = reinterpret_cast< wxDC * >(argp1);
16798 ecode2 = SWIG_AsVal_int(obj1, &val2);
16799 if (!SWIG_IsOK(ecode2)) {
16800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetClippingRegion" "', expected argument " "2"" of type '" "int""'");
16801 }
16802 arg2 = static_cast< int >(val2);
16803 ecode3 = SWIG_AsVal_int(obj2, &val3);
16804 if (!SWIG_IsOK(ecode3)) {
16805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetClippingRegion" "', expected argument " "3"" of type '" "int""'");
16806 }
16807 arg3 = static_cast< int >(val3);
16808 ecode4 = SWIG_AsVal_int(obj3, &val4);
16809 if (!SWIG_IsOK(ecode4)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_SetClippingRegion" "', expected argument " "4"" of type '" "int""'");
16811 }
16812 arg4 = static_cast< int >(val4);
16813 ecode5 = SWIG_AsVal_int(obj4, &val5);
16814 if (!SWIG_IsOK(ecode5)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_SetClippingRegion" "', expected argument " "5"" of type '" "int""'");
16816 }
16817 arg5 = static_cast< int >(val5);
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 resultobj = SWIG_Py_Void();
16825 return resultobj;
16826 fail:
16827 return NULL;
16828 }
16829
16830
16831 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16832 PyObject *resultobj = 0;
16833 wxDC *arg1 = (wxDC *) 0 ;
16834 wxPoint *arg2 = 0 ;
16835 wxSize *arg3 = 0 ;
16836 void *argp1 = 0 ;
16837 int res1 = 0 ;
16838 wxPoint temp2 ;
16839 wxSize temp3 ;
16840 PyObject * obj0 = 0 ;
16841 PyObject * obj1 = 0 ;
16842 PyObject * obj2 = 0 ;
16843 char * kwnames[] = {
16844 (char *) "self",(char *) "pt",(char *) "sz", NULL
16845 };
16846
16847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) 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_SetClippingRegionPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
16851 }
16852 arg1 = reinterpret_cast< wxDC * >(argp1);
16853 {
16854 arg2 = &temp2;
16855 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16856 }
16857 {
16858 arg3 = &temp3;
16859 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16860 }
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
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_SetClippingRegionAsRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj = 0;
16876 wxDC *arg1 = (wxDC *) 0 ;
16877 wxRegion *arg2 = 0 ;
16878 void *argp1 = 0 ;
16879 int res1 = 0 ;
16880 void *argp2 = 0 ;
16881 int res2 = 0 ;
16882 PyObject * obj0 = 0 ;
16883 PyObject * obj1 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "self",(char *) "region", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) SWIG_fail;
16889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "1"" of type '" "wxDC *""'");
16892 }
16893 arg1 = reinterpret_cast< wxDC * >(argp1);
16894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
16895 if (!SWIG_IsOK(res2)) {
16896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
16897 }
16898 if (!argp2) {
16899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
16900 }
16901 arg2 = reinterpret_cast< wxRegion * >(argp2);
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 resultobj = SWIG_Py_Void();
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 SWIGINTERN PyObject *_wrap_DC_SetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj = 0;
16917 wxDC *arg1 = (wxDC *) 0 ;
16918 wxRect *arg2 = 0 ;
16919 void *argp1 = 0 ;
16920 int res1 = 0 ;
16921 wxRect temp2 ;
16922 PyObject * obj0 = 0 ;
16923 PyObject * obj1 = 0 ;
16924 char * kwnames[] = {
16925 (char *) "self",(char *) "rect", NULL
16926 };
16927
16928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) SWIG_fail;
16929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16930 if (!SWIG_IsOK(res1)) {
16931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
16932 }
16933 arg1 = reinterpret_cast< wxDC * >(argp1);
16934 {
16935 arg2 = &temp2;
16936 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16937 }
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 (arg1)->SetClippingRegion((wxRect const &)*arg2);
16941 wxPyEndAllowThreads(__tstate);
16942 if (PyErr_Occurred()) SWIG_fail;
16943 }
16944 resultobj = SWIG_Py_Void();
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 SWIGINTERN PyObject *_wrap_DC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16952 PyObject *resultobj = 0;
16953 wxDC *arg1 = (wxDC *) 0 ;
16954 int arg2 ;
16955 wxPoint *arg3 = (wxPoint *) 0 ;
16956 int arg4 = (int) 0 ;
16957 int arg5 = (int) 0 ;
16958 void *argp1 = 0 ;
16959 int res1 = 0 ;
16960 int val4 ;
16961 int ecode4 = 0 ;
16962 int val5 ;
16963 int ecode5 = 0 ;
16964 PyObject * obj0 = 0 ;
16965 PyObject * obj1 = 0 ;
16966 PyObject * obj2 = 0 ;
16967 PyObject * obj3 = 0 ;
16968 char * kwnames[] = {
16969 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
16970 };
16971
16972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
16974 if (!SWIG_IsOK(res1)) {
16975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLines" "', expected argument " "1"" of type '" "wxDC *""'");
16976 }
16977 arg1 = reinterpret_cast< wxDC * >(argp1);
16978 {
16979 arg3 = wxPoint_LIST_helper(obj1, &arg2);
16980 if (arg3 == NULL) SWIG_fail;
16981 }
16982 if (obj2) {
16983 ecode4 = SWIG_AsVal_int(obj2, &val4);
16984 if (!SWIG_IsOK(ecode4)) {
16985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLines" "', expected argument " "4"" of type '" "int""'");
16986 }
16987 arg4 = static_cast< int >(val4);
16988 }
16989 if (obj3) {
16990 ecode5 = SWIG_AsVal_int(obj3, &val5);
16991 if (!SWIG_IsOK(ecode5)) {
16992 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLines" "', expected argument " "5"" of type '" "int""'");
16993 }
16994 arg5 = static_cast< int >(val5);
16995 }
16996 {
16997 PyThreadState* __tstate = wxPyBeginAllowThreads();
16998 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_Py_Void();
17003 {
17004 if (arg3) delete [] arg3;
17005 }
17006 return resultobj;
17007 fail:
17008 {
17009 if (arg3) delete [] arg3;
17010 }
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_DC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxDC *arg1 = (wxDC *) 0 ;
17018 int arg2 ;
17019 wxPoint *arg3 = (wxPoint *) 0 ;
17020 int arg4 = (int) 0 ;
17021 int arg5 = (int) 0 ;
17022 int arg6 = (int) wxODDEVEN_RULE ;
17023 void *argp1 = 0 ;
17024 int res1 = 0 ;
17025 int val4 ;
17026 int ecode4 = 0 ;
17027 int val5 ;
17028 int ecode5 = 0 ;
17029 int val6 ;
17030 int ecode6 = 0 ;
17031 PyObject * obj0 = 0 ;
17032 PyObject * obj1 = 0 ;
17033 PyObject * obj2 = 0 ;
17034 PyObject * obj3 = 0 ;
17035 PyObject * obj4 = 0 ;
17036 char * kwnames[] = {
17037 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
17038 };
17039
17040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17042 if (!SWIG_IsOK(res1)) {
17043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPolygon" "', expected argument " "1"" of type '" "wxDC *""'");
17044 }
17045 arg1 = reinterpret_cast< wxDC * >(argp1);
17046 {
17047 arg3 = wxPoint_LIST_helper(obj1, &arg2);
17048 if (arg3 == NULL) SWIG_fail;
17049 }
17050 if (obj2) {
17051 ecode4 = SWIG_AsVal_int(obj2, &val4);
17052 if (!SWIG_IsOK(ecode4)) {
17053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
17054 }
17055 arg4 = static_cast< int >(val4);
17056 }
17057 if (obj3) {
17058 ecode5 = SWIG_AsVal_int(obj3, &val5);
17059 if (!SWIG_IsOK(ecode5)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
17061 }
17062 arg5 = static_cast< int >(val5);
17063 }
17064 if (obj4) {
17065 ecode6 = SWIG_AsVal_int(obj4, &val6);
17066 if (!SWIG_IsOK(ecode6)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
17068 }
17069 arg6 = static_cast< int >(val6);
17070 }
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 resultobj = SWIG_Py_Void();
17078 {
17079 if (arg3) delete [] arg3;
17080 }
17081 return resultobj;
17082 fail:
17083 {
17084 if (arg3) delete [] arg3;
17085 }
17086 return NULL;
17087 }
17088
17089
17090 SWIGINTERN PyObject *_wrap_DC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17091 PyObject *resultobj = 0;
17092 wxDC *arg1 = (wxDC *) 0 ;
17093 wxString *arg2 = 0 ;
17094 wxRect *arg3 = 0 ;
17095 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
17096 int arg5 = (int) -1 ;
17097 void *argp1 = 0 ;
17098 int res1 = 0 ;
17099 bool temp2 = false ;
17100 wxRect temp3 ;
17101 int val4 ;
17102 int ecode4 = 0 ;
17103 int val5 ;
17104 int ecode5 = 0 ;
17105 PyObject * obj0 = 0 ;
17106 PyObject * obj1 = 0 ;
17107 PyObject * obj2 = 0 ;
17108 PyObject * obj3 = 0 ;
17109 PyObject * obj4 = 0 ;
17110 char * kwnames[] = {
17111 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
17112 };
17113
17114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17116 if (!SWIG_IsOK(res1)) {
17117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLabel" "', expected argument " "1"" of type '" "wxDC *""'");
17118 }
17119 arg1 = reinterpret_cast< wxDC * >(argp1);
17120 {
17121 arg2 = wxString_in_helper(obj1);
17122 if (arg2 == NULL) SWIG_fail;
17123 temp2 = true;
17124 }
17125 {
17126 arg3 = &temp3;
17127 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
17128 }
17129 if (obj3) {
17130 ecode4 = SWIG_AsVal_int(obj3, &val4);
17131 if (!SWIG_IsOK(ecode4)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
17133 }
17134 arg4 = static_cast< int >(val4);
17135 }
17136 if (obj4) {
17137 ecode5 = SWIG_AsVal_int(obj4, &val5);
17138 if (!SWIG_IsOK(ecode5)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
17140 }
17141 arg5 = static_cast< int >(val5);
17142 }
17143 {
17144 PyThreadState* __tstate = wxPyBeginAllowThreads();
17145 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
17146 wxPyEndAllowThreads(__tstate);
17147 if (PyErr_Occurred()) SWIG_fail;
17148 }
17149 resultobj = SWIG_Py_Void();
17150 {
17151 if (temp2)
17152 delete arg2;
17153 }
17154 return resultobj;
17155 fail:
17156 {
17157 if (temp2)
17158 delete arg2;
17159 }
17160 return NULL;
17161 }
17162
17163
17164 SWIGINTERN PyObject *_wrap_DC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17165 PyObject *resultobj = 0;
17166 wxDC *arg1 = (wxDC *) 0 ;
17167 wxString *arg2 = 0 ;
17168 wxBitmap *arg3 = 0 ;
17169 wxRect *arg4 = 0 ;
17170 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
17171 int arg6 = (int) -1 ;
17172 wxRect result;
17173 void *argp1 = 0 ;
17174 int res1 = 0 ;
17175 bool temp2 = false ;
17176 void *argp3 = 0 ;
17177 int res3 = 0 ;
17178 wxRect temp4 ;
17179 int val5 ;
17180 int ecode5 = 0 ;
17181 int val6 ;
17182 int ecode6 = 0 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 PyObject * obj2 = 0 ;
17186 PyObject * obj3 = 0 ;
17187 PyObject * obj4 = 0 ;
17188 PyObject * obj5 = 0 ;
17189 char * kwnames[] = {
17190 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
17191 };
17192
17193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17195 if (!SWIG_IsOK(res1)) {
17196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawImageLabel" "', expected argument " "1"" of type '" "wxDC *""'");
17197 }
17198 arg1 = reinterpret_cast< wxDC * >(argp1);
17199 {
17200 arg2 = wxString_in_helper(obj1);
17201 if (arg2 == NULL) SWIG_fail;
17202 temp2 = true;
17203 }
17204 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
17205 if (!SWIG_IsOK(res3)) {
17206 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
17207 }
17208 if (!argp3) {
17209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
17210 }
17211 arg3 = reinterpret_cast< wxBitmap * >(argp3);
17212 {
17213 arg4 = &temp4;
17214 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
17215 }
17216 if (obj4) {
17217 ecode5 = SWIG_AsVal_int(obj4, &val5);
17218 if (!SWIG_IsOK(ecode5)) {
17219 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
17220 }
17221 arg5 = static_cast< int >(val5);
17222 }
17223 if (obj5) {
17224 ecode6 = SWIG_AsVal_int(obj5, &val6);
17225 if (!SWIG_IsOK(ecode6)) {
17226 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
17227 }
17228 arg6 = static_cast< int >(val6);
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17237 {
17238 if (temp2)
17239 delete arg2;
17240 }
17241 return resultobj;
17242 fail:
17243 {
17244 if (temp2)
17245 delete arg2;
17246 }
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *_wrap_DC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj = 0;
17253 wxDC *arg1 = (wxDC *) 0 ;
17254 int arg2 ;
17255 wxPoint *arg3 = (wxPoint *) 0 ;
17256 void *argp1 = 0 ;
17257 int res1 = 0 ;
17258 PyObject * obj0 = 0 ;
17259 PyObject * obj1 = 0 ;
17260 char * kwnames[] = {
17261 (char *) "self",(char *) "points", NULL
17262 };
17263
17264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
17265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17266 if (!SWIG_IsOK(res1)) {
17267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawSpline" "', expected argument " "1"" of type '" "wxDC *""'");
17268 }
17269 arg1 = reinterpret_cast< wxDC * >(argp1);
17270 {
17271 arg3 = wxPoint_LIST_helper(obj1, &arg2);
17272 if (arg3 == NULL) SWIG_fail;
17273 }
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 (arg1)->DrawSpline(arg2,arg3);
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 resultobj = SWIG_Py_Void();
17281 {
17282 if (arg3) delete [] arg3;
17283 }
17284 return resultobj;
17285 fail:
17286 {
17287 if (arg3) delete [] arg3;
17288 }
17289 return NULL;
17290 }
17291
17292
17293 SWIGINTERN PyObject *_wrap_DC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 PyObject *resultobj = 0;
17295 wxDC *arg1 = (wxDC *) 0 ;
17296 void *argp1 = 0 ;
17297 int res1 = 0 ;
17298 PyObject *swig_obj[1] ;
17299
17300 if (!args) SWIG_fail;
17301 swig_obj[0] = args;
17302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17303 if (!SWIG_IsOK(res1)) {
17304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Clear" "', expected argument " "1"" of type '" "wxDC *""'");
17305 }
17306 arg1 = reinterpret_cast< wxDC * >(argp1);
17307 {
17308 PyThreadState* __tstate = wxPyBeginAllowThreads();
17309 (arg1)->Clear();
17310 wxPyEndAllowThreads(__tstate);
17311 if (PyErr_Occurred()) SWIG_fail;
17312 }
17313 resultobj = SWIG_Py_Void();
17314 return resultobj;
17315 fail:
17316 return NULL;
17317 }
17318
17319
17320 SWIGINTERN PyObject *_wrap_DC_StartDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17321 PyObject *resultobj = 0;
17322 wxDC *arg1 = (wxDC *) 0 ;
17323 wxString *arg2 = 0 ;
17324 bool result;
17325 void *argp1 = 0 ;
17326 int res1 = 0 ;
17327 bool temp2 = false ;
17328 PyObject * obj0 = 0 ;
17329 PyObject * obj1 = 0 ;
17330 char * kwnames[] = {
17331 (char *) "self",(char *) "message", NULL
17332 };
17333
17334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) SWIG_fail;
17335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17336 if (!SWIG_IsOK(res1)) {
17337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartDoc" "', expected argument " "1"" of type '" "wxDC *""'");
17338 }
17339 arg1 = reinterpret_cast< wxDC * >(argp1);
17340 {
17341 arg2 = wxString_in_helper(obj1);
17342 if (arg2 == NULL) SWIG_fail;
17343 temp2 = true;
17344 }
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
17348 wxPyEndAllowThreads(__tstate);
17349 if (PyErr_Occurred()) SWIG_fail;
17350 }
17351 {
17352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17353 }
17354 {
17355 if (temp2)
17356 delete arg2;
17357 }
17358 return resultobj;
17359 fail:
17360 {
17361 if (temp2)
17362 delete arg2;
17363 }
17364 return NULL;
17365 }
17366
17367
17368 SWIGINTERN PyObject *_wrap_DC_EndDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17369 PyObject *resultobj = 0;
17370 wxDC *arg1 = (wxDC *) 0 ;
17371 void *argp1 = 0 ;
17372 int res1 = 0 ;
17373 PyObject *swig_obj[1] ;
17374
17375 if (!args) SWIG_fail;
17376 swig_obj[0] = args;
17377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17378 if (!SWIG_IsOK(res1)) {
17379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndDoc" "', expected argument " "1"" of type '" "wxDC *""'");
17380 }
17381 arg1 = reinterpret_cast< wxDC * >(argp1);
17382 {
17383 PyThreadState* __tstate = wxPyBeginAllowThreads();
17384 (arg1)->EndDoc();
17385 wxPyEndAllowThreads(__tstate);
17386 if (PyErr_Occurred()) SWIG_fail;
17387 }
17388 resultobj = SWIG_Py_Void();
17389 return resultobj;
17390 fail:
17391 return NULL;
17392 }
17393
17394
17395 SWIGINTERN PyObject *_wrap_DC_StartPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17396 PyObject *resultobj = 0;
17397 wxDC *arg1 = (wxDC *) 0 ;
17398 void *argp1 = 0 ;
17399 int res1 = 0 ;
17400 PyObject *swig_obj[1] ;
17401
17402 if (!args) SWIG_fail;
17403 swig_obj[0] = args;
17404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17405 if (!SWIG_IsOK(res1)) {
17406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartPage" "', expected argument " "1"" of type '" "wxDC *""'");
17407 }
17408 arg1 = reinterpret_cast< wxDC * >(argp1);
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 (arg1)->StartPage();
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_Py_Void();
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 SWIGINTERN PyObject *_wrap_DC_EndPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *resultobj = 0;
17424 wxDC *arg1 = (wxDC *) 0 ;
17425 void *argp1 = 0 ;
17426 int res1 = 0 ;
17427 PyObject *swig_obj[1] ;
17428
17429 if (!args) SWIG_fail;
17430 swig_obj[0] = args;
17431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17432 if (!SWIG_IsOK(res1)) {
17433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndPage" "', expected argument " "1"" of type '" "wxDC *""'");
17434 }
17435 arg1 = reinterpret_cast< wxDC * >(argp1);
17436 {
17437 PyThreadState* __tstate = wxPyBeginAllowThreads();
17438 (arg1)->EndPage();
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_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17450 PyObject *resultobj = 0;
17451 wxDC *arg1 = (wxDC *) 0 ;
17452 wxFont *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 *) "font", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",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_SetFont" "', expected argument " "1"" of type '" "wxDC *""'");
17467 }
17468 arg1 = reinterpret_cast< wxDC * >(argp1);
17469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
17470 if (!SWIG_IsOK(res2)) {
17471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
17472 }
17473 if (!argp2) {
17474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
17475 }
17476 arg2 = reinterpret_cast< wxFont * >(argp2);
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 (arg1)->SetFont((wxFont 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_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj = 0;
17492 wxDC *arg1 = (wxDC *) 0 ;
17493 wxPen *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 *) "pen", NULL
17502 };
17503
17504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",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_SetPen" "', expected argument " "1"" of type '" "wxDC *""'");
17508 }
17509 arg1 = reinterpret_cast< wxDC * >(argp1);
17510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
17511 if (!SWIG_IsOK(res2)) {
17512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
17513 }
17514 if (!argp2) {
17515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
17516 }
17517 arg2 = reinterpret_cast< wxPen * >(argp2);
17518 {
17519 PyThreadState* __tstate = wxPyBeginAllowThreads();
17520 (arg1)->SetPen((wxPen 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_SetBrush(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_SetBrush",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_SetBrush" "', 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_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
17554 }
17555 if (!argp2) {
17556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
17557 }
17558 arg2 = reinterpret_cast< wxBrush * >(argp2);
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 (arg1)->SetBrush((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_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = 0;
17574 wxDC *arg1 = (wxDC *) 0 ;
17575 wxBrush *arg2 = 0 ;
17576 void *argp1 = 0 ;
17577 int res1 = 0 ;
17578 void *argp2 = 0 ;
17579 int res2 = 0 ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 char * kwnames[] = {
17583 (char *) "self",(char *) "brush", NULL
17584 };
17585
17586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",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_SetBackground" "', expected argument " "1"" of type '" "wxDC *""'");
17590 }
17591 arg1 = reinterpret_cast< wxDC * >(argp1);
17592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
17593 if (!SWIG_IsOK(res2)) {
17594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
17595 }
17596 if (!argp2) {
17597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
17598 }
17599 arg2 = reinterpret_cast< wxBrush * >(argp2);
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 (arg1)->SetBackground((wxBrush const &)*arg2);
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 resultobj = SWIG_Py_Void();
17607 return resultobj;
17608 fail:
17609 return NULL;
17610 }
17611
17612
17613 SWIGINTERN PyObject *_wrap_DC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj = 0;
17615 wxDC *arg1 = (wxDC *) 0 ;
17616 int arg2 ;
17617 void *argp1 = 0 ;
17618 int res1 = 0 ;
17619 int val2 ;
17620 int ecode2 = 0 ;
17621 PyObject * obj0 = 0 ;
17622 PyObject * obj1 = 0 ;
17623 char * kwnames[] = {
17624 (char *) "self",(char *) "mode", NULL
17625 };
17626
17627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
17628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17629 if (!SWIG_IsOK(res1)) {
17630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxDC *""'");
17631 }
17632 arg1 = reinterpret_cast< wxDC * >(argp1);
17633 ecode2 = SWIG_AsVal_int(obj1, &val2);
17634 if (!SWIG_IsOK(ecode2)) {
17635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
17636 }
17637 arg2 = static_cast< int >(val2);
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 (arg1)->SetBackgroundMode(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_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxDC *arg1 = (wxDC *) 0 ;
17654 wxPalette *arg2 = 0 ;
17655 void *argp1 = 0 ;
17656 int res1 = 0 ;
17657 void *argp2 = 0 ;
17658 int res2 = 0 ;
17659 PyObject * obj0 = 0 ;
17660 PyObject * obj1 = 0 ;
17661 char * kwnames[] = {
17662 (char *) "self",(char *) "palette", NULL
17663 };
17664
17665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
17666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17667 if (!SWIG_IsOK(res1)) {
17668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPalette" "', expected argument " "1"" of type '" "wxDC *""'");
17669 }
17670 arg1 = reinterpret_cast< wxDC * >(argp1);
17671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
17672 if (!SWIG_IsOK(res2)) {
17673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
17674 }
17675 if (!argp2) {
17676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
17677 }
17678 arg2 = reinterpret_cast< wxPalette * >(argp2);
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 (arg1)->SetPalette((wxPalette const &)*arg2);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 resultobj = SWIG_Py_Void();
17686 return resultobj;
17687 fail:
17688 return NULL;
17689 }
17690
17691
17692 SWIGINTERN PyObject *_wrap_DC_DestroyClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17693 PyObject *resultobj = 0;
17694 wxDC *arg1 = (wxDC *) 0 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 PyObject *swig_obj[1] ;
17698
17699 if (!args) SWIG_fail;
17700 swig_obj[0] = args;
17701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17702 if (!SWIG_IsOK(res1)) {
17703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DestroyClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
17704 }
17705 arg1 = reinterpret_cast< wxDC * >(argp1);
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 (arg1)->DestroyClippingRegion();
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 resultobj = SWIG_Py_Void();
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 SWIGINTERN PyObject *_wrap_DC_GetClippingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17720 PyObject *resultobj = 0;
17721 wxDC *arg1 = (wxDC *) 0 ;
17722 int *arg2 = (int *) 0 ;
17723 int *arg3 = (int *) 0 ;
17724 int *arg4 = (int *) 0 ;
17725 int *arg5 = (int *) 0 ;
17726 void *argp1 = 0 ;
17727 int res1 = 0 ;
17728 int temp2 ;
17729 int res2 = SWIG_TMPOBJ ;
17730 int temp3 ;
17731 int res3 = SWIG_TMPOBJ ;
17732 int temp4 ;
17733 int res4 = SWIG_TMPOBJ ;
17734 int temp5 ;
17735 int res5 = SWIG_TMPOBJ ;
17736 PyObject *swig_obj[1] ;
17737
17738 arg2 = &temp2;
17739 arg3 = &temp3;
17740 arg4 = &temp4;
17741 arg5 = &temp5;
17742 if (!args) SWIG_fail;
17743 swig_obj[0] = args;
17744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17745 if (!SWIG_IsOK(res1)) {
17746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingBox" "', expected argument " "1"" of type '" "wxDC const *""'");
17747 }
17748 arg1 = reinterpret_cast< wxDC * >(argp1);
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 resultobj = SWIG_Py_Void();
17756 if (SWIG_IsTmpObj(res2)) {
17757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
17758 } else {
17759 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17761 }
17762 if (SWIG_IsTmpObj(res3)) {
17763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17764 } else {
17765 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17767 }
17768 if (SWIG_IsTmpObj(res4)) {
17769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
17770 } else {
17771 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17773 }
17774 if (SWIG_IsTmpObj(res5)) {
17775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
17776 } else {
17777 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17779 }
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 SWIGINTERN PyObject *_wrap_DC_GetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17787 PyObject *resultobj = 0;
17788 wxDC *arg1 = (wxDC *) 0 ;
17789 wxRect result;
17790 void *argp1 = 0 ;
17791 int res1 = 0 ;
17792 PyObject *swig_obj[1] ;
17793
17794 if (!args) SWIG_fail;
17795 swig_obj[0] = args;
17796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17797 if (!SWIG_IsOK(res1)) {
17798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
17799 }
17800 arg1 = reinterpret_cast< wxDC * >(argp1);
17801 {
17802 PyThreadState* __tstate = wxPyBeginAllowThreads();
17803 result = wxDC_GetClippingRect(arg1);
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 SWIGINTERN PyObject *_wrap_DC_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17815 PyObject *resultobj = 0;
17816 wxDC *arg1 = (wxDC *) 0 ;
17817 int result;
17818 void *argp1 = 0 ;
17819 int res1 = 0 ;
17820 PyObject *swig_obj[1] ;
17821
17822 if (!args) SWIG_fail;
17823 swig_obj[0] = args;
17824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17825 if (!SWIG_IsOK(res1)) {
17826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharHeight" "', expected argument " "1"" of type '" "wxDC const *""'");
17827 }
17828 arg1 = reinterpret_cast< wxDC * >(argp1);
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (int)((wxDC const *)arg1)->GetCharHeight();
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_From_int(static_cast< int >(result));
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_DC_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxDC *arg1 = (wxDC *) 0 ;
17845 int result;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharWidth" "', expected argument " "1"" of type '" "wxDC const *""'");
17855 }
17856 arg1 = reinterpret_cast< wxDC * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (int)((wxDC const *)arg1)->GetCharWidth();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 resultobj = SWIG_From_int(static_cast< int >(result));
17864 return resultobj;
17865 fail:
17866 return NULL;
17867 }
17868
17869
17870 SWIGINTERN PyObject *_wrap_DC_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17871 PyObject *resultobj = 0;
17872 wxDC *arg1 = (wxDC *) 0 ;
17873 wxString *arg2 = 0 ;
17874 int *arg3 = (int *) 0 ;
17875 int *arg4 = (int *) 0 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 bool temp2 = false ;
17879 int temp3 ;
17880 int res3 = SWIG_TMPOBJ ;
17881 int temp4 ;
17882 int res4 = SWIG_TMPOBJ ;
17883 PyObject * obj0 = 0 ;
17884 PyObject * obj1 = 0 ;
17885 char * kwnames[] = {
17886 (char *) "self",(char *) "string", NULL
17887 };
17888
17889 arg3 = &temp3;
17890 arg4 = &temp4;
17891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
17892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
17895 }
17896 arg1 = reinterpret_cast< wxDC * >(argp1);
17897 {
17898 arg2 = wxString_in_helper(obj1);
17899 if (arg2 == NULL) SWIG_fail;
17900 temp2 = true;
17901 }
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 resultobj = SWIG_Py_Void();
17909 if (SWIG_IsTmpObj(res3)) {
17910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17911 } else {
17912 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17914 }
17915 if (SWIG_IsTmpObj(res4)) {
17916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
17917 } else {
17918 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17920 }
17921 {
17922 if (temp2)
17923 delete arg2;
17924 }
17925 return resultobj;
17926 fail:
17927 {
17928 if (temp2)
17929 delete arg2;
17930 }
17931 return NULL;
17932 }
17933
17934
17935 SWIGINTERN PyObject *_wrap_DC_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj = 0;
17937 wxDC *arg1 = (wxDC *) 0 ;
17938 wxString *arg2 = 0 ;
17939 int *arg3 = (int *) 0 ;
17940 int *arg4 = (int *) 0 ;
17941 int *arg5 = (int *) 0 ;
17942 int *arg6 = (int *) 0 ;
17943 wxFont *arg7 = (wxFont *) NULL ;
17944 void *argp1 = 0 ;
17945 int res1 = 0 ;
17946 bool temp2 = false ;
17947 int temp3 ;
17948 int res3 = SWIG_TMPOBJ ;
17949 int temp4 ;
17950 int res4 = SWIG_TMPOBJ ;
17951 int temp5 ;
17952 int res5 = SWIG_TMPOBJ ;
17953 int temp6 ;
17954 int res6 = SWIG_TMPOBJ ;
17955 void *argp7 = 0 ;
17956 int res7 = 0 ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 PyObject * obj2 = 0 ;
17960 char * kwnames[] = {
17961 (char *) "self",(char *) "string",(char *) "font", NULL
17962 };
17963
17964 arg3 = &temp3;
17965 arg4 = &temp4;
17966 arg5 = &temp5;
17967 arg6 = &temp6;
17968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17970 if (!SWIG_IsOK(res1)) {
17971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFullTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
17972 }
17973 arg1 = reinterpret_cast< wxDC * >(argp1);
17974 {
17975 arg2 = wxString_in_helper(obj1);
17976 if (arg2 == NULL) SWIG_fail;
17977 temp2 = true;
17978 }
17979 if (obj2) {
17980 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
17981 if (!SWIG_IsOK(res7)) {
17982 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DC_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont *""'");
17983 }
17984 arg7 = reinterpret_cast< wxFont * >(argp7);
17985 }
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 resultobj = SWIG_Py_Void();
17993 if (SWIG_IsTmpObj(res3)) {
17994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
17995 } else {
17996 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17998 }
17999 if (SWIG_IsTmpObj(res4)) {
18000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
18001 } else {
18002 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18004 }
18005 if (SWIG_IsTmpObj(res5)) {
18006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
18007 } else {
18008 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18010 }
18011 if (SWIG_IsTmpObj(res6)) {
18012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
18013 } else {
18014 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
18016 }
18017 {
18018 if (temp2)
18019 delete arg2;
18020 }
18021 return resultobj;
18022 fail:
18023 {
18024 if (temp2)
18025 delete arg2;
18026 }
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxDC *arg1 = (wxDC *) 0 ;
18034 wxString *arg2 = 0 ;
18035 int *arg3 = (int *) 0 ;
18036 int *arg4 = (int *) 0 ;
18037 int *arg5 = (int *) 0 ;
18038 wxFont *arg6 = (wxFont *) NULL ;
18039 void *argp1 = 0 ;
18040 int res1 = 0 ;
18041 bool temp2 = false ;
18042 int temp3 ;
18043 int res3 = SWIG_TMPOBJ ;
18044 int temp4 ;
18045 int res4 = SWIG_TMPOBJ ;
18046 int temp5 ;
18047 int res5 = SWIG_TMPOBJ ;
18048 void *argp6 = 0 ;
18049 int res6 = 0 ;
18050 PyObject * obj0 = 0 ;
18051 PyObject * obj1 = 0 ;
18052 PyObject * obj2 = 0 ;
18053 char * kwnames[] = {
18054 (char *) "self",(char *) "text",(char *) "font", NULL
18055 };
18056
18057 arg3 = &temp3;
18058 arg4 = &temp4;
18059 arg5 = &temp5;
18060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18062 if (!SWIG_IsOK(res1)) {
18063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
18064 }
18065 arg1 = reinterpret_cast< wxDC * >(argp1);
18066 {
18067 arg2 = wxString_in_helper(obj1);
18068 if (arg2 == NULL) SWIG_fail;
18069 temp2 = true;
18070 }
18071 if (obj2) {
18072 res6 = SWIG_ConvertPtr(obj2, &argp6,SWIGTYPE_p_wxFont, 0 | 0 );
18073 if (!SWIG_IsOK(res6)) {
18074 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "6"" of type '" "wxFont *""'");
18075 }
18076 arg6 = reinterpret_cast< wxFont * >(argp6);
18077 }
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 resultobj = SWIG_Py_Void();
18085 if (SWIG_IsTmpObj(res3)) {
18086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18087 } else {
18088 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18090 }
18091 if (SWIG_IsTmpObj(res4)) {
18092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
18093 } else {
18094 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18096 }
18097 if (SWIG_IsTmpObj(res5)) {
18098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
18099 } else {
18100 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18102 }
18103 {
18104 if (temp2)
18105 delete arg2;
18106 }
18107 return resultobj;
18108 fail:
18109 {
18110 if (temp2)
18111 delete arg2;
18112 }
18113 return NULL;
18114 }
18115
18116
18117 SWIGINTERN PyObject *_wrap_DC_GetPartialTextExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj = 0;
18119 wxDC *arg1 = (wxDC *) 0 ;
18120 wxString *arg2 = 0 ;
18121 wxArrayInt result;
18122 void *argp1 = 0 ;
18123 int res1 = 0 ;
18124 bool temp2 = false ;
18125 PyObject * obj0 = 0 ;
18126 PyObject * obj1 = 0 ;
18127 char * kwnames[] = {
18128 (char *) "self",(char *) "text", NULL
18129 };
18130
18131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) SWIG_fail;
18132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18133 if (!SWIG_IsOK(res1)) {
18134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPartialTextExtents" "', expected argument " "1"" of type '" "wxDC *""'");
18135 }
18136 arg1 = reinterpret_cast< wxDC * >(argp1);
18137 {
18138 arg2 = wxString_in_helper(obj1);
18139 if (arg2 == NULL) SWIG_fail;
18140 temp2 = true;
18141 }
18142 {
18143 PyThreadState* __tstate = wxPyBeginAllowThreads();
18144 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
18145 wxPyEndAllowThreads(__tstate);
18146 if (PyErr_Occurred()) SWIG_fail;
18147 }
18148 {
18149 resultobj = PyList_New(0);
18150 size_t idx;
18151 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
18152 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
18153 PyList_Append(resultobj, val);
18154 Py_DECREF(val);
18155 }
18156 }
18157 {
18158 if (temp2)
18159 delete arg2;
18160 }
18161 return resultobj;
18162 fail:
18163 {
18164 if (temp2)
18165 delete arg2;
18166 }
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_DC_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxDC *arg1 = (wxDC *) 0 ;
18174 wxSize result;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSize" "', expected argument " "1"" of type '" "wxDC *""'");
18184 }
18185 arg1 = reinterpret_cast< wxDC * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (arg1)->GetSize();
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_DC_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxDC *arg1 = (wxDC *) 0 ;
18202 int *arg2 = (int *) 0 ;
18203 int *arg3 = (int *) 0 ;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 int temp2 ;
18207 int res2 = SWIG_TMPOBJ ;
18208 int temp3 ;
18209 int res3 = SWIG_TMPOBJ ;
18210 PyObject *swig_obj[1] ;
18211
18212 arg2 = &temp2;
18213 arg3 = &temp3;
18214 if (!args) SWIG_fail;
18215 swig_obj[0] = args;
18216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18217 if (!SWIG_IsOK(res1)) {
18218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeTuple" "', expected argument " "1"" of type '" "wxDC *""'");
18219 }
18220 arg1 = reinterpret_cast< wxDC * >(argp1);
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 (arg1)->GetSize(arg2,arg3);
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 resultobj = SWIG_Py_Void();
18228 if (SWIG_IsTmpObj(res2)) {
18229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
18230 } else {
18231 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18233 }
18234 if (SWIG_IsTmpObj(res3)) {
18235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18236 } else {
18237 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18239 }
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_DC_GetSizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 PyObject *resultobj = 0;
18248 wxDC *arg1 = (wxDC *) 0 ;
18249 wxSize result;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 PyObject *swig_obj[1] ;
18253
18254 if (!args) SWIG_fail;
18255 swig_obj[0] = args;
18256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18257 if (!SWIG_IsOK(res1)) {
18258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMM" "', expected argument " "1"" of type '" "wxDC const *""'");
18259 }
18260 arg1 = reinterpret_cast< wxDC * >(argp1);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = ((wxDC const *)arg1)->GetSizeMM();
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_DC_GetSizeMMTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 PyObject *resultobj = 0;
18276 wxDC *arg1 = (wxDC *) 0 ;
18277 int *arg2 = (int *) 0 ;
18278 int *arg3 = (int *) 0 ;
18279 void *argp1 = 0 ;
18280 int res1 = 0 ;
18281 int temp2 ;
18282 int res2 = SWIG_TMPOBJ ;
18283 int temp3 ;
18284 int res3 = SWIG_TMPOBJ ;
18285 PyObject *swig_obj[1] ;
18286
18287 arg2 = &temp2;
18288 arg3 = &temp3;
18289 if (!args) SWIG_fail;
18290 swig_obj[0] = args;
18291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18292 if (!SWIG_IsOK(res1)) {
18293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMMTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
18294 }
18295 arg1 = reinterpret_cast< wxDC * >(argp1);
18296 {
18297 PyThreadState* __tstate = wxPyBeginAllowThreads();
18298 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 resultobj = SWIG_Py_Void();
18303 if (SWIG_IsTmpObj(res2)) {
18304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
18305 } else {
18306 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18308 }
18309 if (SWIG_IsTmpObj(res3)) {
18310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
18311 } else {
18312 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18314 }
18315 return resultobj;
18316 fail:
18317 return NULL;
18318 }
18319
18320
18321 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18322 PyObject *resultobj = 0;
18323 wxDC *arg1 = (wxDC *) 0 ;
18324 int arg2 ;
18325 int result;
18326 void *argp1 = 0 ;
18327 int res1 = 0 ;
18328 int val2 ;
18329 int ecode2 = 0 ;
18330 PyObject * obj0 = 0 ;
18331 PyObject * obj1 = 0 ;
18332 char * kwnames[] = {
18333 (char *) "self",(char *) "x", NULL
18334 };
18335
18336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) SWIG_fail;
18337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18338 if (!SWIG_IsOK(res1)) {
18339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalX" "', expected argument " "1"" of type '" "wxDC const *""'");
18340 }
18341 arg1 = reinterpret_cast< wxDC * >(argp1);
18342 ecode2 = SWIG_AsVal_int(obj1, &val2);
18343 if (!SWIG_IsOK(ecode2)) {
18344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalX" "', expected argument " "2"" of type '" "int""'");
18345 }
18346 arg2 = static_cast< int >(val2);
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_From_int(static_cast< int >(result));
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj = 0;
18362 wxDC *arg1 = (wxDC *) 0 ;
18363 int arg2 ;
18364 int result;
18365 void *argp1 = 0 ;
18366 int res1 = 0 ;
18367 int val2 ;
18368 int ecode2 = 0 ;
18369 PyObject * obj0 = 0 ;
18370 PyObject * obj1 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "y", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalY" "', expected argument " "1"" of type '" "wxDC const *""'");
18379 }
18380 arg1 = reinterpret_cast< wxDC * >(argp1);
18381 ecode2 = SWIG_AsVal_int(obj1, &val2);
18382 if (!SWIG_IsOK(ecode2)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalY" "', expected argument " "2"" of type '" "int""'");
18384 }
18385 arg2 = static_cast< int >(val2);
18386 {
18387 PyThreadState* __tstate = wxPyBeginAllowThreads();
18388 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 resultobj = SWIG_From_int(static_cast< int >(result));
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18400 PyObject *resultobj = 0;
18401 wxDC *arg1 = (wxDC *) 0 ;
18402 int arg2 ;
18403 int result;
18404 void *argp1 = 0 ;
18405 int res1 = 0 ;
18406 int val2 ;
18407 int ecode2 = 0 ;
18408 PyObject * obj0 = 0 ;
18409 PyObject * obj1 = 0 ;
18410 char * kwnames[] = {
18411 (char *) "self",(char *) "x", NULL
18412 };
18413
18414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) SWIG_fail;
18415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18416 if (!SWIG_IsOK(res1)) {
18417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18418 }
18419 arg1 = reinterpret_cast< wxDC * >(argp1);
18420 ecode2 = SWIG_AsVal_int(obj1, &val2);
18421 if (!SWIG_IsOK(ecode2)) {
18422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "2"" of type '" "int""'");
18423 }
18424 arg2 = static_cast< int >(val2);
18425 {
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
18428 wxPyEndAllowThreads(__tstate);
18429 if (PyErr_Occurred()) SWIG_fail;
18430 }
18431 resultobj = SWIG_From_int(static_cast< int >(result));
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj = 0;
18440 wxDC *arg1 = (wxDC *) 0 ;
18441 int arg2 ;
18442 int result;
18443 void *argp1 = 0 ;
18444 int res1 = 0 ;
18445 int val2 ;
18446 int ecode2 = 0 ;
18447 PyObject * obj0 = 0 ;
18448 PyObject * obj1 = 0 ;
18449 char * kwnames[] = {
18450 (char *) "self",(char *) "y", NULL
18451 };
18452
18453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) SWIG_fail;
18454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18455 if (!SWIG_IsOK(res1)) {
18456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18457 }
18458 arg1 = reinterpret_cast< wxDC * >(argp1);
18459 ecode2 = SWIG_AsVal_int(obj1, &val2);
18460 if (!SWIG_IsOK(ecode2)) {
18461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "2"" of type '" "int""'");
18462 }
18463 arg2 = static_cast< int >(val2);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 resultobj = SWIG_From_int(static_cast< int >(result));
18471 return resultobj;
18472 fail:
18473 return NULL;
18474 }
18475
18476
18477 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18478 PyObject *resultobj = 0;
18479 wxDC *arg1 = (wxDC *) 0 ;
18480 int arg2 ;
18481 int result;
18482 void *argp1 = 0 ;
18483 int res1 = 0 ;
18484 int val2 ;
18485 int ecode2 = 0 ;
18486 PyObject * obj0 = 0 ;
18487 PyObject * obj1 = 0 ;
18488 char * kwnames[] = {
18489 (char *) "self",(char *) "x", NULL
18490 };
18491
18492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) SWIG_fail;
18493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18494 if (!SWIG_IsOK(res1)) {
18495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceX" "', expected argument " "1"" of type '" "wxDC const *""'");
18496 }
18497 arg1 = reinterpret_cast< wxDC * >(argp1);
18498 ecode2 = SWIG_AsVal_int(obj1, &val2);
18499 if (!SWIG_IsOK(ecode2)) {
18500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceX" "', expected argument " "2"" of type '" "int""'");
18501 }
18502 arg2 = static_cast< int >(val2);
18503 {
18504 PyThreadState* __tstate = wxPyBeginAllowThreads();
18505 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
18506 wxPyEndAllowThreads(__tstate);
18507 if (PyErr_Occurred()) SWIG_fail;
18508 }
18509 resultobj = SWIG_From_int(static_cast< int >(result));
18510 return resultobj;
18511 fail:
18512 return NULL;
18513 }
18514
18515
18516 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18517 PyObject *resultobj = 0;
18518 wxDC *arg1 = (wxDC *) 0 ;
18519 int arg2 ;
18520 int result;
18521 void *argp1 = 0 ;
18522 int res1 = 0 ;
18523 int val2 ;
18524 int ecode2 = 0 ;
18525 PyObject * obj0 = 0 ;
18526 PyObject * obj1 = 0 ;
18527 char * kwnames[] = {
18528 (char *) "self",(char *) "y", NULL
18529 };
18530
18531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) SWIG_fail;
18532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18533 if (!SWIG_IsOK(res1)) {
18534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceY" "', expected argument " "1"" of type '" "wxDC const *""'");
18535 }
18536 arg1 = reinterpret_cast< wxDC * >(argp1);
18537 ecode2 = SWIG_AsVal_int(obj1, &val2);
18538 if (!SWIG_IsOK(ecode2)) {
18539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceY" "', expected argument " "2"" of type '" "int""'");
18540 }
18541 arg2 = static_cast< int >(val2);
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 resultobj = SWIG_From_int(static_cast< int >(result));
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj = 0;
18557 wxDC *arg1 = (wxDC *) 0 ;
18558 int arg2 ;
18559 int result;
18560 void *argp1 = 0 ;
18561 int res1 = 0 ;
18562 int val2 ;
18563 int ecode2 = 0 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char * kwnames[] = {
18567 (char *) "self",(char *) "x", NULL
18568 };
18569
18570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) SWIG_fail;
18571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18572 if (!SWIG_IsOK(res1)) {
18573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18574 }
18575 arg1 = reinterpret_cast< wxDC * >(argp1);
18576 ecode2 = SWIG_AsVal_int(obj1, &val2);
18577 if (!SWIG_IsOK(ecode2)) {
18578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "2"" of type '" "int""'");
18579 }
18580 arg2 = static_cast< int >(val2);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_From_int(static_cast< int >(result));
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj = 0;
18596 wxDC *arg1 = (wxDC *) 0 ;
18597 int arg2 ;
18598 int result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 int val2 ;
18602 int ecode2 = 0 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char * kwnames[] = {
18606 (char *) "self",(char *) "y", NULL
18607 };
18608
18609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) SWIG_fail;
18610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18611 if (!SWIG_IsOK(res1)) {
18612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
18613 }
18614 arg1 = reinterpret_cast< wxDC * >(argp1);
18615 ecode2 = SWIG_AsVal_int(obj1, &val2);
18616 if (!SWIG_IsOK(ecode2)) {
18617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "2"" of type '" "int""'");
18618 }
18619 arg2 = static_cast< int >(val2);
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 resultobj = SWIG_From_int(static_cast< int >(result));
18627 return resultobj;
18628 fail:
18629 return NULL;
18630 }
18631
18632
18633 SWIGINTERN PyObject *_wrap_DC_CanDrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18634 PyObject *resultobj = 0;
18635 wxDC *arg1 = (wxDC *) 0 ;
18636 bool result;
18637 void *argp1 = 0 ;
18638 int res1 = 0 ;
18639 PyObject *swig_obj[1] ;
18640
18641 if (!args) SWIG_fail;
18642 swig_obj[0] = args;
18643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanDrawBitmap" "', expected argument " "1"" of type '" "wxDC const *""'");
18646 }
18647 arg1 = reinterpret_cast< wxDC * >(argp1);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 {
18655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18656 }
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_DC_CanGetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxDC *arg1 = (wxDC *) 0 ;
18666 bool result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanGetTextExtent" "', expected argument " "1"" of type '" "wxDC const *""'");
18676 }
18677 arg1 = reinterpret_cast< wxDC * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_DC_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxDC *arg1 = (wxDC *) 0 ;
18696 int result;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDepth" "', expected argument " "1"" of type '" "wxDC const *""'");
18706 }
18707 arg1 = reinterpret_cast< wxDC * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (int)((wxDC const *)arg1)->GetDepth();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_From_int(static_cast< int >(result));
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *_wrap_DC_GetPPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *resultobj = 0;
18723 wxDC *arg1 = (wxDC *) 0 ;
18724 wxSize result;
18725 void *argp1 = 0 ;
18726 int res1 = 0 ;
18727 PyObject *swig_obj[1] ;
18728
18729 if (!args) SWIG_fail;
18730 swig_obj[0] = args;
18731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18732 if (!SWIG_IsOK(res1)) {
18733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPPI" "', expected argument " "1"" of type '" "wxDC const *""'");
18734 }
18735 arg1 = reinterpret_cast< wxDC * >(argp1);
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = ((wxDC const *)arg1)->GetPPI();
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 SWIGINTERN PyObject *_wrap_DC_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18750 PyObject *resultobj = 0;
18751 wxDC *arg1 = (wxDC *) 0 ;
18752 bool result;
18753 void *argp1 = 0 ;
18754 int res1 = 0 ;
18755 PyObject *swig_obj[1] ;
18756
18757 if (!args) SWIG_fail;
18758 swig_obj[0] = args;
18759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18760 if (!SWIG_IsOK(res1)) {
18761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Ok" "', expected argument " "1"" of type '" "wxDC const *""'");
18762 }
18763 arg1 = reinterpret_cast< wxDC * >(argp1);
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (bool)((wxDC const *)arg1)->Ok();
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 {
18771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18772 }
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_DC_GetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18780 PyObject *resultobj = 0;
18781 wxDC *arg1 = (wxDC *) 0 ;
18782 int result;
18783 void *argp1 = 0 ;
18784 int res1 = 0 ;
18785 PyObject *swig_obj[1] ;
18786
18787 if (!args) SWIG_fail;
18788 swig_obj[0] = args;
18789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18790 if (!SWIG_IsOK(res1)) {
18791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackgroundMode" "', expected argument " "1"" of type '" "wxDC const *""'");
18792 }
18793 arg1 = reinterpret_cast< wxDC * >(argp1);
18794 {
18795 PyThreadState* __tstate = wxPyBeginAllowThreads();
18796 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
18797 wxPyEndAllowThreads(__tstate);
18798 if (PyErr_Occurred()) SWIG_fail;
18799 }
18800 resultobj = SWIG_From_int(static_cast< int >(result));
18801 return resultobj;
18802 fail:
18803 return NULL;
18804 }
18805
18806
18807 SWIGINTERN PyObject *_wrap_DC_GetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18808 PyObject *resultobj = 0;
18809 wxDC *arg1 = (wxDC *) 0 ;
18810 wxBrush *result = 0 ;
18811 void *argp1 = 0 ;
18812 int res1 = 0 ;
18813 PyObject *swig_obj[1] ;
18814
18815 if (!args) SWIG_fail;
18816 swig_obj[0] = args;
18817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
18820 }
18821 arg1 = reinterpret_cast< wxDC * >(argp1);
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 {
18825 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
18826 result = (wxBrush *) &_result_ref;
18827 }
18828 wxPyEndAllowThreads(__tstate);
18829 if (PyErr_Occurred()) SWIG_fail;
18830 }
18831 {
18832 wxBrush* resultptr = new wxBrush(*result);
18833 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
18834 }
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *_wrap_DC_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18842 PyObject *resultobj = 0;
18843 wxDC *arg1 = (wxDC *) 0 ;
18844 wxBrush *result = 0 ;
18845 void *argp1 = 0 ;
18846 int res1 = 0 ;
18847 PyObject *swig_obj[1] ;
18848
18849 if (!args) SWIG_fail;
18850 swig_obj[0] = args;
18851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18852 if (!SWIG_IsOK(res1)) {
18853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBrush" "', expected argument " "1"" of type '" "wxDC const *""'");
18854 }
18855 arg1 = reinterpret_cast< wxDC * >(argp1);
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 {
18859 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
18860 result = (wxBrush *) &_result_ref;
18861 }
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 {
18866 wxBrush* resultptr = new wxBrush(*result);
18867 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
18868 }
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *_wrap_DC_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18876 PyObject *resultobj = 0;
18877 wxDC *arg1 = (wxDC *) 0 ;
18878 wxFont *result = 0 ;
18879 void *argp1 = 0 ;
18880 int res1 = 0 ;
18881 PyObject *swig_obj[1] ;
18882
18883 if (!args) SWIG_fail;
18884 swig_obj[0] = args;
18885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18886 if (!SWIG_IsOK(res1)) {
18887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFont" "', expected argument " "1"" of type '" "wxDC const *""'");
18888 }
18889 arg1 = reinterpret_cast< wxDC * >(argp1);
18890 {
18891 PyThreadState* __tstate = wxPyBeginAllowThreads();
18892 {
18893 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
18894 result = (wxFont *) &_result_ref;
18895 }
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 {
18900 wxFont* resultptr = new wxFont(*result);
18901 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
18902 }
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 SWIGINTERN PyObject *_wrap_DC_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18910 PyObject *resultobj = 0;
18911 wxDC *arg1 = (wxDC *) 0 ;
18912 wxPen *result = 0 ;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 PyObject *swig_obj[1] ;
18916
18917 if (!args) SWIG_fail;
18918 swig_obj[0] = args;
18919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18920 if (!SWIG_IsOK(res1)) {
18921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPen" "', expected argument " "1"" of type '" "wxDC const *""'");
18922 }
18923 arg1 = reinterpret_cast< wxDC * >(argp1);
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 {
18927 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
18928 result = (wxPen *) &_result_ref;
18929 }
18930 wxPyEndAllowThreads(__tstate);
18931 if (PyErr_Occurred()) SWIG_fail;
18932 }
18933 {
18934 wxPen* resultptr = new wxPen(*result);
18935 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
18936 }
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *_wrap_DC_GetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18944 PyObject *resultobj = 0;
18945 wxDC *arg1 = (wxDC *) 0 ;
18946 wxColour *result = 0 ;
18947 void *argp1 = 0 ;
18948 int res1 = 0 ;
18949 PyObject *swig_obj[1] ;
18950
18951 if (!args) SWIG_fail;
18952 swig_obj[0] = args;
18953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18954 if (!SWIG_IsOK(res1)) {
18955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
18956 }
18957 arg1 = reinterpret_cast< wxDC * >(argp1);
18958 {
18959 PyThreadState* __tstate = wxPyBeginAllowThreads();
18960 {
18961 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
18962 result = (wxColour *) &_result_ref;
18963 }
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_DC_GetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975 PyObject *resultobj = 0;
18976 wxDC *arg1 = (wxDC *) 0 ;
18977 wxColour *result = 0 ;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 PyObject *swig_obj[1] ;
18981
18982 if (!args) SWIG_fail;
18983 swig_obj[0] = args;
18984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18985 if (!SWIG_IsOK(res1)) {
18986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextForeground" "', expected argument " "1"" of type '" "wxDC const *""'");
18987 }
18988 arg1 = reinterpret_cast< wxDC * >(argp1);
18989 {
18990 PyThreadState* __tstate = wxPyBeginAllowThreads();
18991 {
18992 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
18993 result = (wxColour *) &_result_ref;
18994 }
18995 wxPyEndAllowThreads(__tstate);
18996 if (PyErr_Occurred()) SWIG_fail;
18997 }
18998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
18999 return resultobj;
19000 fail:
19001 return NULL;
19002 }
19003
19004
19005 SWIGINTERN PyObject *_wrap_DC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19006 PyObject *resultobj = 0;
19007 wxDC *arg1 = (wxDC *) 0 ;
19008 wxColour *arg2 = 0 ;
19009 void *argp1 = 0 ;
19010 int res1 = 0 ;
19011 wxColour temp2 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 char * kwnames[] = {
19015 (char *) "self",(char *) "colour", NULL
19016 };
19017
19018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
19019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19020 if (!SWIG_IsOK(res1)) {
19021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextForeground" "', expected argument " "1"" of type '" "wxDC *""'");
19022 }
19023 arg1 = reinterpret_cast< wxDC * >(argp1);
19024 {
19025 arg2 = &temp2;
19026 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19027 }
19028 {
19029 PyThreadState* __tstate = wxPyBeginAllowThreads();
19030 (arg1)->SetTextForeground((wxColour const &)*arg2);
19031 wxPyEndAllowThreads(__tstate);
19032 if (PyErr_Occurred()) SWIG_fail;
19033 }
19034 resultobj = SWIG_Py_Void();
19035 return resultobj;
19036 fail:
19037 return NULL;
19038 }
19039
19040
19041 SWIGINTERN PyObject *_wrap_DC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj = 0;
19043 wxDC *arg1 = (wxDC *) 0 ;
19044 wxColour *arg2 = 0 ;
19045 void *argp1 = 0 ;
19046 int res1 = 0 ;
19047 wxColour temp2 ;
19048 PyObject * obj0 = 0 ;
19049 PyObject * obj1 = 0 ;
19050 char * kwnames[] = {
19051 (char *) "self",(char *) "colour", NULL
19052 };
19053
19054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
19055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19056 if (!SWIG_IsOK(res1)) {
19057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextBackground" "', expected argument " "1"" of type '" "wxDC *""'");
19058 }
19059 arg1 = reinterpret_cast< wxDC * >(argp1);
19060 {
19061 arg2 = &temp2;
19062 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19063 }
19064 {
19065 PyThreadState* __tstate = wxPyBeginAllowThreads();
19066 (arg1)->SetTextBackground((wxColour const &)*arg2);
19067 wxPyEndAllowThreads(__tstate);
19068 if (PyErr_Occurred()) SWIG_fail;
19069 }
19070 resultobj = SWIG_Py_Void();
19071 return resultobj;
19072 fail:
19073 return NULL;
19074 }
19075
19076
19077 SWIGINTERN PyObject *_wrap_DC_GetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19078 PyObject *resultobj = 0;
19079 wxDC *arg1 = (wxDC *) 0 ;
19080 int result;
19081 void *argp1 = 0 ;
19082 int res1 = 0 ;
19083 PyObject *swig_obj[1] ;
19084
19085 if (!args) SWIG_fail;
19086 swig_obj[0] = args;
19087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19088 if (!SWIG_IsOK(res1)) {
19089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMapMode" "', expected argument " "1"" of type '" "wxDC const *""'");
19090 }
19091 arg1 = reinterpret_cast< wxDC * >(argp1);
19092 {
19093 PyThreadState* __tstate = wxPyBeginAllowThreads();
19094 result = (int)((wxDC const *)arg1)->GetMapMode();
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 resultobj = SWIG_From_int(static_cast< int >(result));
19099 return resultobj;
19100 fail:
19101 return NULL;
19102 }
19103
19104
19105 SWIGINTERN PyObject *_wrap_DC_SetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj = 0;
19107 wxDC *arg1 = (wxDC *) 0 ;
19108 int arg2 ;
19109 void *argp1 = 0 ;
19110 int res1 = 0 ;
19111 int val2 ;
19112 int ecode2 = 0 ;
19113 PyObject * obj0 = 0 ;
19114 PyObject * obj1 = 0 ;
19115 char * kwnames[] = {
19116 (char *) "self",(char *) "mode", NULL
19117 };
19118
19119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) SWIG_fail;
19120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19121 if (!SWIG_IsOK(res1)) {
19122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetMapMode" "', expected argument " "1"" of type '" "wxDC *""'");
19123 }
19124 arg1 = reinterpret_cast< wxDC * >(argp1);
19125 ecode2 = SWIG_AsVal_int(obj1, &val2);
19126 if (!SWIG_IsOK(ecode2)) {
19127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetMapMode" "', expected argument " "2"" of type '" "int""'");
19128 }
19129 arg2 = static_cast< int >(val2);
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 (arg1)->SetMapMode(arg2);
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 resultobj = SWIG_Py_Void();
19137 return resultobj;
19138 fail:
19139 return NULL;
19140 }
19141
19142
19143 SWIGINTERN PyObject *_wrap_DC_GetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19144 PyObject *resultobj = 0;
19145 wxDC *arg1 = (wxDC *) 0 ;
19146 double *arg2 = (double *) 0 ;
19147 double *arg3 = (double *) 0 ;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 double temp2 ;
19151 int res2 = SWIG_TMPOBJ ;
19152 double temp3 ;
19153 int res3 = SWIG_TMPOBJ ;
19154 PyObject *swig_obj[1] ;
19155
19156 arg2 = &temp2;
19157 arg3 = &temp3;
19158 if (!args) SWIG_fail;
19159 swig_obj[0] = args;
19160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetUserScale" "', expected argument " "1"" of type '" "wxDC const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxDC * >(argp1);
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 resultobj = SWIG_Py_Void();
19172 if (SWIG_IsTmpObj(res2)) {
19173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
19174 } else {
19175 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19177 }
19178 if (SWIG_IsTmpObj(res3)) {
19179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
19180 } else {
19181 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_DC_SetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj = 0;
19192 wxDC *arg1 = (wxDC *) 0 ;
19193 double arg2 ;
19194 double arg3 ;
19195 void *argp1 = 0 ;
19196 int res1 = 0 ;
19197 double val2 ;
19198 int ecode2 = 0 ;
19199 double val3 ;
19200 int ecode3 = 0 ;
19201 PyObject * obj0 = 0 ;
19202 PyObject * obj1 = 0 ;
19203 PyObject * obj2 = 0 ;
19204 char * kwnames[] = {
19205 (char *) "self",(char *) "x",(char *) "y", NULL
19206 };
19207
19208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19210 if (!SWIG_IsOK(res1)) {
19211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetUserScale" "', expected argument " "1"" of type '" "wxDC *""'");
19212 }
19213 arg1 = reinterpret_cast< wxDC * >(argp1);
19214 ecode2 = SWIG_AsVal_double(obj1, &val2);
19215 if (!SWIG_IsOK(ecode2)) {
19216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetUserScale" "', expected argument " "2"" of type '" "double""'");
19217 }
19218 arg2 = static_cast< double >(val2);
19219 ecode3 = SWIG_AsVal_double(obj2, &val3);
19220 if (!SWIG_IsOK(ecode3)) {
19221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetUserScale" "', expected argument " "3"" of type '" "double""'");
19222 }
19223 arg3 = static_cast< double >(val3);
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 (arg1)->SetUserScale(arg2,arg3);
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 resultobj = SWIG_Py_Void();
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 SWIGINTERN PyObject *_wrap_DC_GetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19238 PyObject *resultobj = 0;
19239 wxDC *arg1 = (wxDC *) 0 ;
19240 double *arg2 = (double *) 0 ;
19241 double *arg3 = (double *) 0 ;
19242 void *argp1 = 0 ;
19243 int res1 = 0 ;
19244 double temp2 ;
19245 int res2 = SWIG_TMPOBJ ;
19246 double temp3 ;
19247 int res3 = SWIG_TMPOBJ ;
19248 PyObject *swig_obj[1] ;
19249
19250 arg2 = &temp2;
19251 arg3 = &temp3;
19252 if (!args) SWIG_fail;
19253 swig_obj[0] = args;
19254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
19257 }
19258 arg1 = reinterpret_cast< wxDC * >(argp1);
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 (arg1)->GetLogicalScale(arg2,arg3);
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 resultobj = SWIG_Py_Void();
19266 if (SWIG_IsTmpObj(res2)) {
19267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
19268 } else {
19269 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19271 }
19272 if (SWIG_IsTmpObj(res3)) {
19273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
19274 } else {
19275 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19277 }
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_DC_SetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxDC *arg1 = (wxDC *) 0 ;
19287 double arg2 ;
19288 double arg3 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 double val2 ;
19292 int ecode2 = 0 ;
19293 double val3 ;
19294 int ecode3 = 0 ;
19295 PyObject * obj0 = 0 ;
19296 PyObject * obj1 = 0 ;
19297 PyObject * obj2 = 0 ;
19298 char * kwnames[] = {
19299 (char *) "self",(char *) "x",(char *) "y", NULL
19300 };
19301
19302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19304 if (!SWIG_IsOK(res1)) {
19305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
19306 }
19307 arg1 = reinterpret_cast< wxDC * >(argp1);
19308 ecode2 = SWIG_AsVal_double(obj1, &val2);
19309 if (!SWIG_IsOK(ecode2)) {
19310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalScale" "', expected argument " "2"" of type '" "double""'");
19311 }
19312 arg2 = static_cast< double >(val2);
19313 ecode3 = SWIG_AsVal_double(obj2, &val3);
19314 if (!SWIG_IsOK(ecode3)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalScale" "', expected argument " "3"" of type '" "double""'");
19316 }
19317 arg3 = static_cast< double >(val3);
19318 {
19319 PyThreadState* __tstate = wxPyBeginAllowThreads();
19320 (arg1)->SetLogicalScale(arg2,arg3);
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 resultobj = SWIG_Py_Void();
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 SWIGINTERN PyObject *_wrap_DC_GetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19332 PyObject *resultobj = 0;
19333 wxDC *arg1 = (wxDC *) 0 ;
19334 wxPoint result;
19335 void *argp1 = 0 ;
19336 int res1 = 0 ;
19337 PyObject *swig_obj[1] ;
19338
19339 if (!args) SWIG_fail;
19340 swig_obj[0] = args;
19341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19342 if (!SWIG_IsOK(res1)) {
19343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
19344 }
19345 arg1 = reinterpret_cast< wxDC * >(argp1);
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = ((wxDC const *)arg1)->GetLogicalOrigin();
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 SWIGINTERN PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19360 PyObject *resultobj = 0;
19361 wxDC *arg1 = (wxDC *) 0 ;
19362 int *arg2 = (int *) 0 ;
19363 int *arg3 = (int *) 0 ;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 int temp2 ;
19367 int res2 = SWIG_TMPOBJ ;
19368 int temp3 ;
19369 int res3 = SWIG_TMPOBJ ;
19370 PyObject *swig_obj[1] ;
19371
19372 arg2 = &temp2;
19373 arg3 = &temp3;
19374 if (!args) SWIG_fail;
19375 swig_obj[0] = args;
19376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19377 if (!SWIG_IsOK(res1)) {
19378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
19379 }
19380 arg1 = reinterpret_cast< wxDC * >(argp1);
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 resultobj = SWIG_Py_Void();
19388 if (SWIG_IsTmpObj(res2)) {
19389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
19390 } else {
19391 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19393 }
19394 if (SWIG_IsTmpObj(res3)) {
19395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
19396 } else {
19397 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19399 }
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 SWIGINTERN PyObject *_wrap_DC_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj = 0;
19408 wxDC *arg1 = (wxDC *) 0 ;
19409 int arg2 ;
19410 int arg3 ;
19411 void *argp1 = 0 ;
19412 int res1 = 0 ;
19413 int val2 ;
19414 int ecode2 = 0 ;
19415 int val3 ;
19416 int ecode3 = 0 ;
19417 PyObject * obj0 = 0 ;
19418 PyObject * obj1 = 0 ;
19419 PyObject * obj2 = 0 ;
19420 char * kwnames[] = {
19421 (char *) "self",(char *) "x",(char *) "y", NULL
19422 };
19423
19424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19426 if (!SWIG_IsOK(res1)) {
19427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19428 }
19429 arg1 = reinterpret_cast< wxDC * >(argp1);
19430 ecode2 = SWIG_AsVal_int(obj1, &val2);
19431 if (!SWIG_IsOK(ecode2)) {
19432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
19433 }
19434 arg2 = static_cast< int >(val2);
19435 ecode3 = SWIG_AsVal_int(obj2, &val3);
19436 if (!SWIG_IsOK(ecode3)) {
19437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
19438 }
19439 arg3 = static_cast< int >(val3);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 (arg1)->SetLogicalOrigin(arg2,arg3);
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = SWIG_Py_Void();
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 SWIGINTERN PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj = 0;
19455 wxDC *arg1 = (wxDC *) 0 ;
19456 wxPoint *arg2 = 0 ;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 wxPoint temp2 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 char * kwnames[] = {
19463 (char *) "self",(char *) "point", NULL
19464 };
19465
19466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
19467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19470 }
19471 arg1 = reinterpret_cast< wxDC * >(argp1);
19472 {
19473 arg2 = &temp2;
19474 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19475 }
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_Py_Void();
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_DC_GetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxDC *arg1 = (wxDC *) 0 ;
19492 wxPoint result;
19493 void *argp1 = 0 ;
19494 int res1 = 0 ;
19495 PyObject *swig_obj[1] ;
19496
19497 if (!args) SWIG_fail;
19498 swig_obj[0] = args;
19499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19500 if (!SWIG_IsOK(res1)) {
19501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
19502 }
19503 arg1 = reinterpret_cast< wxDC * >(argp1);
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = ((wxDC const *)arg1)->GetDeviceOrigin();
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 SWIGINTERN PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19518 PyObject *resultobj = 0;
19519 wxDC *arg1 = (wxDC *) 0 ;
19520 int *arg2 = (int *) 0 ;
19521 int *arg3 = (int *) 0 ;
19522 void *argp1 = 0 ;
19523 int res1 = 0 ;
19524 int temp2 ;
19525 int res2 = SWIG_TMPOBJ ;
19526 int temp3 ;
19527 int res3 = SWIG_TMPOBJ ;
19528 PyObject *swig_obj[1] ;
19529
19530 arg2 = &temp2;
19531 arg3 = &temp3;
19532 if (!args) SWIG_fail;
19533 swig_obj[0] = args;
19534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19535 if (!SWIG_IsOK(res1)) {
19536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
19537 }
19538 arg1 = reinterpret_cast< wxDC * >(argp1);
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_Py_Void();
19546 if (SWIG_IsTmpObj(res2)) {
19547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
19548 } else {
19549 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19551 }
19552 if (SWIG_IsTmpObj(res3)) {
19553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
19554 } else {
19555 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19557 }
19558 return resultobj;
19559 fail:
19560 return NULL;
19561 }
19562
19563
19564 SWIGINTERN PyObject *_wrap_DC_SetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19565 PyObject *resultobj = 0;
19566 wxDC *arg1 = (wxDC *) 0 ;
19567 int arg2 ;
19568 int arg3 ;
19569 void *argp1 = 0 ;
19570 int res1 = 0 ;
19571 int val2 ;
19572 int ecode2 = 0 ;
19573 int val3 ;
19574 int ecode3 = 0 ;
19575 PyObject * obj0 = 0 ;
19576 PyObject * obj1 = 0 ;
19577 PyObject * obj2 = 0 ;
19578 char * kwnames[] = {
19579 (char *) "self",(char *) "x",(char *) "y", NULL
19580 };
19581
19582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19584 if (!SWIG_IsOK(res1)) {
19585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19586 }
19587 arg1 = reinterpret_cast< wxDC * >(argp1);
19588 ecode2 = SWIG_AsVal_int(obj1, &val2);
19589 if (!SWIG_IsOK(ecode2)) {
19590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetDeviceOrigin" "', expected argument " "2"" of type '" "int""'");
19591 }
19592 arg2 = static_cast< int >(val2);
19593 ecode3 = SWIG_AsVal_int(obj2, &val3);
19594 if (!SWIG_IsOK(ecode3)) {
19595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetDeviceOrigin" "', expected argument " "3"" of type '" "int""'");
19596 }
19597 arg3 = static_cast< int >(val3);
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 (arg1)->SetDeviceOrigin(arg2,arg3);
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_Py_Void();
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj = 0;
19613 wxDC *arg1 = (wxDC *) 0 ;
19614 wxPoint *arg2 = 0 ;
19615 void *argp1 = 0 ;
19616 int res1 = 0 ;
19617 wxPoint temp2 ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char * kwnames[] = {
19621 (char *) "self",(char *) "point", NULL
19622 };
19623
19624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) 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_SetDeviceOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19628 }
19629 arg1 = reinterpret_cast< wxDC * >(argp1);
19630 {
19631 arg2 = &temp2;
19632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19633 }
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 resultobj = SWIG_Py_Void();
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 SWIGINTERN PyObject *_wrap_DC_SetAxisOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19648 PyObject *resultobj = 0;
19649 wxDC *arg1 = (wxDC *) 0 ;
19650 bool arg2 ;
19651 bool arg3 ;
19652 void *argp1 = 0 ;
19653 int res1 = 0 ;
19654 bool val2 ;
19655 int ecode2 = 0 ;
19656 bool val3 ;
19657 int ecode3 = 0 ;
19658 PyObject * obj0 = 0 ;
19659 PyObject * obj1 = 0 ;
19660 PyObject * obj2 = 0 ;
19661 char * kwnames[] = {
19662 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
19663 };
19664
19665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetAxisOrientation" "', expected argument " "1"" of type '" "wxDC *""'");
19669 }
19670 arg1 = reinterpret_cast< wxDC * >(argp1);
19671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19672 if (!SWIG_IsOK(ecode2)) {
19673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetAxisOrientation" "', expected argument " "2"" of type '" "bool""'");
19674 }
19675 arg2 = static_cast< bool >(val2);
19676 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19677 if (!SWIG_IsOK(ecode3)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetAxisOrientation" "', expected argument " "3"" of type '" "bool""'");
19679 }
19680 arg3 = static_cast< bool >(val3);
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 (arg1)->SetAxisOrientation(arg2,arg3);
19684 wxPyEndAllowThreads(__tstate);
19685 if (PyErr_Occurred()) SWIG_fail;
19686 }
19687 resultobj = SWIG_Py_Void();
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 SWIGINTERN PyObject *_wrap_DC_GetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19695 PyObject *resultobj = 0;
19696 wxDC *arg1 = (wxDC *) 0 ;
19697 int result;
19698 void *argp1 = 0 ;
19699 int res1 = 0 ;
19700 PyObject *swig_obj[1] ;
19701
19702 if (!args) SWIG_fail;
19703 swig_obj[0] = args;
19704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19705 if (!SWIG_IsOK(res1)) {
19706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalFunction" "', expected argument " "1"" of type '" "wxDC const *""'");
19707 }
19708 arg1 = reinterpret_cast< wxDC * >(argp1);
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_From_int(static_cast< int >(result));
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 SWIGINTERN PyObject *_wrap_DC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19723 PyObject *resultobj = 0;
19724 wxDC *arg1 = (wxDC *) 0 ;
19725 int arg2 ;
19726 void *argp1 = 0 ;
19727 int res1 = 0 ;
19728 int val2 ;
19729 int ecode2 = 0 ;
19730 PyObject * obj0 = 0 ;
19731 PyObject * obj1 = 0 ;
19732 char * kwnames[] = {
19733 (char *) "self",(char *) "function", NULL
19734 };
19735
19736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
19737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19738 if (!SWIG_IsOK(res1)) {
19739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxDC *""'");
19740 }
19741 arg1 = reinterpret_cast< wxDC * >(argp1);
19742 ecode2 = SWIG_AsVal_int(obj1, &val2);
19743 if (!SWIG_IsOK(ecode2)) {
19744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
19745 }
19746 arg2 = static_cast< int >(val2);
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 (arg1)->SetLogicalFunction(arg2);
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 resultobj = SWIG_Py_Void();
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 SWIGINTERN PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19761 PyObject *resultobj = 0;
19762 wxDC *arg1 = (wxDC *) 0 ;
19763 void *argp1 = 0 ;
19764 int res1 = 0 ;
19765 PyObject *swig_obj[1] ;
19766
19767 if (!args) SWIG_fail;
19768 swig_obj[0] = args;
19769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19770 if (!SWIG_IsOK(res1)) {
19771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ComputeScaleAndOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
19772 }
19773 arg1 = reinterpret_cast< wxDC * >(argp1);
19774 {
19775 PyThreadState* __tstate = wxPyBeginAllowThreads();
19776 (arg1)->ComputeScaleAndOrigin();
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 resultobj = SWIG_Py_Void();
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj = 0;
19789 wxDC *arg1 = (wxDC *) 0 ;
19790 int arg2 ;
19791 int arg3 ;
19792 void *argp1 = 0 ;
19793 int res1 = 0 ;
19794 int val2 ;
19795 int ecode2 = 0 ;
19796 int val3 ;
19797 int ecode3 = 0 ;
19798 PyObject * obj0 = 0 ;
19799 PyObject * obj1 = 0 ;
19800 PyObject * obj2 = 0 ;
19801 char * kwnames[] = {
19802 (char *) "self",(char *) "x",(char *) "y", NULL
19803 };
19804
19805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19807 if (!SWIG_IsOK(res1)) {
19808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
19809 }
19810 arg1 = reinterpret_cast< wxDC * >(argp1);
19811 ecode2 = SWIG_AsVal_int(obj1, &val2);
19812 if (!SWIG_IsOK(ecode2)) {
19813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CalcBoundingBox" "', expected argument " "2"" of type '" "int""'");
19814 }
19815 arg2 = static_cast< int >(val2);
19816 ecode3 = SWIG_AsVal_int(obj2, &val3);
19817 if (!SWIG_IsOK(ecode3)) {
19818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CalcBoundingBox" "', expected argument " "3"" of type '" "int""'");
19819 }
19820 arg3 = static_cast< int >(val3);
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 (arg1)->CalcBoundingBox(arg2,arg3);
19824 wxPyEndAllowThreads(__tstate);
19825 if (PyErr_Occurred()) SWIG_fail;
19826 }
19827 resultobj = SWIG_Py_Void();
19828 return resultobj;
19829 fail:
19830 return NULL;
19831 }
19832
19833
19834 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19835 PyObject *resultobj = 0;
19836 wxDC *arg1 = (wxDC *) 0 ;
19837 wxPoint *arg2 = 0 ;
19838 void *argp1 = 0 ;
19839 int res1 = 0 ;
19840 wxPoint temp2 ;
19841 PyObject * obj0 = 0 ;
19842 PyObject * obj1 = 0 ;
19843 char * kwnames[] = {
19844 (char *) "self",(char *) "point", NULL
19845 };
19846
19847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) SWIG_fail;
19848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19849 if (!SWIG_IsOK(res1)) {
19850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBoxPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19851 }
19852 arg1 = reinterpret_cast< wxDC * >(argp1);
19853 {
19854 arg2 = &temp2;
19855 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19856 }
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 resultobj = SWIG_Py_Void();
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 SWIGINTERN PyObject *_wrap_DC_ResetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19871 PyObject *resultobj = 0;
19872 wxDC *arg1 = (wxDC *) 0 ;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 PyObject *swig_obj[1] ;
19876
19877 if (!args) SWIG_fail;
19878 swig_obj[0] = args;
19879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19880 if (!SWIG_IsOK(res1)) {
19881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ResetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
19882 }
19883 arg1 = reinterpret_cast< wxDC * >(argp1);
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 (arg1)->ResetBoundingBox();
19887 wxPyEndAllowThreads(__tstate);
19888 if (PyErr_Occurred()) SWIG_fail;
19889 }
19890 resultobj = SWIG_Py_Void();
19891 return resultobj;
19892 fail:
19893 return NULL;
19894 }
19895
19896
19897 SWIGINTERN PyObject *_wrap_DC_MinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19898 PyObject *resultobj = 0;
19899 wxDC *arg1 = (wxDC *) 0 ;
19900 int result;
19901 void *argp1 = 0 ;
19902 int res1 = 0 ;
19903 PyObject *swig_obj[1] ;
19904
19905 if (!args) SWIG_fail;
19906 swig_obj[0] = args;
19907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19908 if (!SWIG_IsOK(res1)) {
19909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinX" "', expected argument " "1"" of type '" "wxDC const *""'");
19910 }
19911 arg1 = reinterpret_cast< wxDC * >(argp1);
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (int)((wxDC const *)arg1)->MinX();
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_From_int(static_cast< int >(result));
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 SWIGINTERN PyObject *_wrap_DC_MaxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19926 PyObject *resultobj = 0;
19927 wxDC *arg1 = (wxDC *) 0 ;
19928 int result;
19929 void *argp1 = 0 ;
19930 int res1 = 0 ;
19931 PyObject *swig_obj[1] ;
19932
19933 if (!args) SWIG_fail;
19934 swig_obj[0] = args;
19935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxX" "', expected argument " "1"" of type '" "wxDC const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxDC * >(argp1);
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 result = (int)((wxDC const *)arg1)->MaxX();
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_From_int(static_cast< int >(result));
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_DC_MinY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19954 PyObject *resultobj = 0;
19955 wxDC *arg1 = (wxDC *) 0 ;
19956 int result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 PyObject *swig_obj[1] ;
19960
19961 if (!args) SWIG_fail;
19962 swig_obj[0] = args;
19963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19964 if (!SWIG_IsOK(res1)) {
19965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinY" "', expected argument " "1"" of type '" "wxDC const *""'");
19966 }
19967 arg1 = reinterpret_cast< wxDC * >(argp1);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (int)((wxDC const *)arg1)->MinY();
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_From_int(static_cast< int >(result));
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_DC_MaxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19982 PyObject *resultobj = 0;
19983 wxDC *arg1 = (wxDC *) 0 ;
19984 int result;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 PyObject *swig_obj[1] ;
19988
19989 if (!args) SWIG_fail;
19990 swig_obj[0] = args;
19991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxY" "', expected argument " "1"" of type '" "wxDC const *""'");
19994 }
19995 arg1 = reinterpret_cast< wxDC * >(argp1);
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (int)((wxDC const *)arg1)->MaxY();
19999 wxPyEndAllowThreads(__tstate);
20000 if (PyErr_Occurred()) SWIG_fail;
20001 }
20002 resultobj = SWIG_From_int(static_cast< int >(result));
20003 return resultobj;
20004 fail:
20005 return NULL;
20006 }
20007
20008
20009 SWIGINTERN PyObject *_wrap_DC_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20010 PyObject *resultobj = 0;
20011 wxDC *arg1 = (wxDC *) 0 ;
20012 int *arg2 = (int *) 0 ;
20013 int *arg3 = (int *) 0 ;
20014 int *arg4 = (int *) 0 ;
20015 int *arg5 = (int *) 0 ;
20016 void *argp1 = 0 ;
20017 int res1 = 0 ;
20018 int temp2 ;
20019 int res2 = SWIG_TMPOBJ ;
20020 int temp3 ;
20021 int res3 = SWIG_TMPOBJ ;
20022 int temp4 ;
20023 int res4 = SWIG_TMPOBJ ;
20024 int temp5 ;
20025 int res5 = SWIG_TMPOBJ ;
20026 PyObject *swig_obj[1] ;
20027
20028 arg2 = &temp2;
20029 arg3 = &temp3;
20030 arg4 = &temp4;
20031 arg5 = &temp5;
20032 if (!args) SWIG_fail;
20033 swig_obj[0] = args;
20034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20035 if (!SWIG_IsOK(res1)) {
20036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
20037 }
20038 arg1 = reinterpret_cast< wxDC * >(argp1);
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 resultobj = SWIG_Py_Void();
20046 if (SWIG_IsTmpObj(res2)) {
20047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20048 } else {
20049 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20051 }
20052 if (SWIG_IsTmpObj(res3)) {
20053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20054 } else {
20055 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20057 }
20058 if (SWIG_IsTmpObj(res4)) {
20059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20060 } else {
20061 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20063 }
20064 if (SWIG_IsTmpObj(res5)) {
20065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20066 } else {
20067 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20069 }
20070 return resultobj;
20071 fail:
20072 return NULL;
20073 }
20074
20075
20076 SWIGINTERN PyObject *_wrap_DC__DrawPointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20077 PyObject *resultobj = 0;
20078 wxDC *arg1 = (wxDC *) 0 ;
20079 PyObject *arg2 = (PyObject *) 0 ;
20080 PyObject *arg3 = (PyObject *) 0 ;
20081 PyObject *arg4 = (PyObject *) 0 ;
20082 PyObject *result = 0 ;
20083 void *argp1 = 0 ;
20084 int res1 = 0 ;
20085 PyObject * obj0 = 0 ;
20086 PyObject * obj1 = 0 ;
20087 PyObject * obj2 = 0 ;
20088 PyObject * obj3 = 0 ;
20089 char * kwnames[] = {
20090 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20091 };
20092
20093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20095 if (!SWIG_IsOK(res1)) {
20096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPointList" "', expected argument " "1"" of type '" "wxDC *""'");
20097 }
20098 arg1 = reinterpret_cast< wxDC * >(argp1);
20099 arg2 = obj1;
20100 arg3 = obj2;
20101 arg4 = obj3;
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 resultobj = result;
20109 return resultobj;
20110 fail:
20111 return NULL;
20112 }
20113
20114
20115 SWIGINTERN PyObject *_wrap_DC__DrawLineList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj = 0;
20117 wxDC *arg1 = (wxDC *) 0 ;
20118 PyObject *arg2 = (PyObject *) 0 ;
20119 PyObject *arg3 = (PyObject *) 0 ;
20120 PyObject *arg4 = (PyObject *) 0 ;
20121 PyObject *result = 0 ;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 PyObject * obj0 = 0 ;
20125 PyObject * obj1 = 0 ;
20126 PyObject * obj2 = 0 ;
20127 PyObject * obj3 = 0 ;
20128 char * kwnames[] = {
20129 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20130 };
20131
20132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawLineList" "', expected argument " "1"" of type '" "wxDC *""'");
20136 }
20137 arg1 = reinterpret_cast< wxDC * >(argp1);
20138 arg2 = obj1;
20139 arg3 = obj2;
20140 arg4 = obj3;
20141 {
20142 PyThreadState* __tstate = wxPyBeginAllowThreads();
20143 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 resultobj = result;
20148 return resultobj;
20149 fail:
20150 return NULL;
20151 }
20152
20153
20154 SWIGINTERN PyObject *_wrap_DC__DrawRectangleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20155 PyObject *resultobj = 0;
20156 wxDC *arg1 = (wxDC *) 0 ;
20157 PyObject *arg2 = (PyObject *) 0 ;
20158 PyObject *arg3 = (PyObject *) 0 ;
20159 PyObject *arg4 = (PyObject *) 0 ;
20160 PyObject *result = 0 ;
20161 void *argp1 = 0 ;
20162 int res1 = 0 ;
20163 PyObject * obj0 = 0 ;
20164 PyObject * obj1 = 0 ;
20165 PyObject * obj2 = 0 ;
20166 PyObject * obj3 = 0 ;
20167 char * kwnames[] = {
20168 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20169 };
20170
20171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20173 if (!SWIG_IsOK(res1)) {
20174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawRectangleList" "', expected argument " "1"" of type '" "wxDC *""'");
20175 }
20176 arg1 = reinterpret_cast< wxDC * >(argp1);
20177 arg2 = obj1;
20178 arg3 = obj2;
20179 arg4 = obj3;
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 resultobj = result;
20187 return resultobj;
20188 fail:
20189 return NULL;
20190 }
20191
20192
20193 SWIGINTERN PyObject *_wrap_DC__DrawEllipseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20194 PyObject *resultobj = 0;
20195 wxDC *arg1 = (wxDC *) 0 ;
20196 PyObject *arg2 = (PyObject *) 0 ;
20197 PyObject *arg3 = (PyObject *) 0 ;
20198 PyObject *arg4 = (PyObject *) 0 ;
20199 PyObject *result = 0 ;
20200 void *argp1 = 0 ;
20201 int res1 = 0 ;
20202 PyObject * obj0 = 0 ;
20203 PyObject * obj1 = 0 ;
20204 PyObject * obj2 = 0 ;
20205 PyObject * obj3 = 0 ;
20206 char * kwnames[] = {
20207 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20208 };
20209
20210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20212 if (!SWIG_IsOK(res1)) {
20213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawEllipseList" "', expected argument " "1"" of type '" "wxDC *""'");
20214 }
20215 arg1 = reinterpret_cast< wxDC * >(argp1);
20216 arg2 = obj1;
20217 arg3 = obj2;
20218 arg4 = obj3;
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 resultobj = result;
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 SWIGINTERN PyObject *_wrap_DC__DrawPolygonList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj = 0;
20234 wxDC *arg1 = (wxDC *) 0 ;
20235 PyObject *arg2 = (PyObject *) 0 ;
20236 PyObject *arg3 = (PyObject *) 0 ;
20237 PyObject *arg4 = (PyObject *) 0 ;
20238 PyObject *result = 0 ;
20239 void *argp1 = 0 ;
20240 int res1 = 0 ;
20241 PyObject * obj0 = 0 ;
20242 PyObject * obj1 = 0 ;
20243 PyObject * obj2 = 0 ;
20244 PyObject * obj3 = 0 ;
20245 char * kwnames[] = {
20246 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
20247 };
20248
20249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) 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__DrawPolygonList" "', expected argument " "1"" of type '" "wxDC *""'");
20253 }
20254 arg1 = reinterpret_cast< wxDC * >(argp1);
20255 arg2 = obj1;
20256 arg3 = obj2;
20257 arg4 = obj3;
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 resultobj = result;
20265 return resultobj;
20266 fail:
20267 return NULL;
20268 }
20269
20270
20271 SWIGINTERN PyObject *_wrap_DC__DrawTextList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20272 PyObject *resultobj = 0;
20273 wxDC *arg1 = (wxDC *) 0 ;
20274 PyObject *arg2 = (PyObject *) 0 ;
20275 PyObject *arg3 = (PyObject *) 0 ;
20276 PyObject *arg4 = (PyObject *) 0 ;
20277 PyObject *arg5 = (PyObject *) 0 ;
20278 PyObject *result = 0 ;
20279 void *argp1 = 0 ;
20280 int res1 = 0 ;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 PyObject * obj2 = 0 ;
20284 PyObject * obj3 = 0 ;
20285 PyObject * obj4 = 0 ;
20286 char * kwnames[] = {
20287 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
20288 };
20289
20290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20292 if (!SWIG_IsOK(res1)) {
20293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawTextList" "', expected argument " "1"" of type '" "wxDC *""'");
20294 }
20295 arg1 = reinterpret_cast< wxDC * >(argp1);
20296 arg2 = obj1;
20297 arg3 = obj2;
20298 arg4 = obj3;
20299 arg5 = obj4;
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = result;
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 SWIGINTERN PyObject *DC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20314 PyObject *obj;
20315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20316 SWIG_TypeNewClientData(SWIGTYPE_p_wxDC, SWIG_NewClientData(obj));
20317 return SWIG_Py_Void();
20318 }
20319
20320 SWIGINTERN PyObject *_wrap_new_MemoryDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *resultobj = 0;
20322 wxMemoryDC *result = 0 ;
20323
20324 if (!SWIG_Python_UnpackTuple(args,"new_MemoryDC",0,0,0)) SWIG_fail;
20325 {
20326 if (!wxPyCheckForApp()) SWIG_fail;
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 result = (wxMemoryDC *)new wxMemoryDC();
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_NEW | 0 );
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 SWIGINTERN PyObject *_wrap_new_MemoryDCFromDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj = 0;
20341 wxDC *arg1 = (wxDC *) 0 ;
20342 wxMemoryDC *result = 0 ;
20343 void *argp1 = 0 ;
20344 int res1 = 0 ;
20345 PyObject * obj0 = 0 ;
20346 char * kwnames[] = {
20347 (char *) "oldDC", NULL
20348 };
20349
20350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) SWIG_fail;
20351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20352 if (!SWIG_IsOK(res1)) {
20353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryDCFromDC" "', expected argument " "1"" of type '" "wxDC *""'");
20354 }
20355 arg1 = reinterpret_cast< wxDC * >(argp1);
20356 {
20357 if (!wxPyCheckForApp()) SWIG_fail;
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (wxMemoryDC *)new wxMemoryDC(arg1);
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_OWN | 0 );
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 SWIGINTERN PyObject *_wrap_MemoryDC_SelectObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20371 PyObject *resultobj = 0;
20372 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
20373 wxBitmap *arg2 = 0 ;
20374 void *argp1 = 0 ;
20375 int res1 = 0 ;
20376 void *argp2 = 0 ;
20377 int res2 = 0 ;
20378 PyObject * obj0 = 0 ;
20379 PyObject * obj1 = 0 ;
20380 char * kwnames[] = {
20381 (char *) "self",(char *) "bitmap", NULL
20382 };
20383
20384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) SWIG_fail;
20385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryDC, 0 | 0 );
20386 if (!SWIG_IsOK(res1)) {
20387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryDC_SelectObject" "', expected argument " "1"" of type '" "wxMemoryDC *""'");
20388 }
20389 arg1 = reinterpret_cast< wxMemoryDC * >(argp1);
20390 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20391 if (!SWIG_IsOK(res2)) {
20392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20393 }
20394 if (!argp2) {
20395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20396 }
20397 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 (arg1)->SelectObject((wxBitmap const &)*arg2);
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 resultobj = SWIG_Py_Void();
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 SWIGINTERN PyObject *MemoryDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20412 PyObject *obj;
20413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20414 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryDC, SWIG_NewClientData(obj));
20415 return SWIG_Py_Void();
20416 }
20417
20418 SWIGINTERN PyObject *MemoryDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20419 return SWIG_Python_InitShadowInstance(args);
20420 }
20421
20422 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
20423 PyObject *resultobj = 0;
20424 wxDC *arg1 = (wxDC *) 0 ;
20425 wxBitmap const &arg2_defvalue = wxNullBitmap ;
20426 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
20427 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20428 wxBufferedDC *result = 0 ;
20429 void *argp1 = 0 ;
20430 int res1 = 0 ;
20431 void *argp2 = 0 ;
20432 int res2 = 0 ;
20433 int val3 ;
20434 int ecode3 = 0 ;
20435
20436 if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
20437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20438 if (!SWIG_IsOK(res1)) {
20439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
20440 }
20441 arg1 = reinterpret_cast< wxDC * >(argp1);
20442 if (swig_obj[1]) {
20443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20444 if (!SWIG_IsOK(res2)) {
20445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20446 }
20447 if (!argp2) {
20448 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20449 }
20450 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20451 }
20452 if (swig_obj[2]) {
20453 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20454 if (!SWIG_IsOK(ecode3)) {
20455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
20456 }
20457 arg3 = static_cast< int >(val3);
20458 }
20459 {
20460 if (!wxPyCheckForApp()) SWIG_fail;
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
20474 PyObject *resultobj = 0;
20475 wxDC *arg1 = (wxDC *) 0 ;
20476 wxSize *arg2 = 0 ;
20477 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20478 wxBufferedDC *result = 0 ;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 wxSize temp2 ;
20482 int val3 ;
20483 int ecode3 = 0 ;
20484
20485 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
20486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20487 if (!SWIG_IsOK(res1)) {
20488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
20489 }
20490 arg1 = reinterpret_cast< wxDC * >(argp1);
20491 {
20492 arg2 = &temp2;
20493 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
20494 }
20495 if (swig_obj[2]) {
20496 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
20497 if (!SWIG_IsOK(ecode3)) {
20498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
20499 }
20500 arg3 = static_cast< int >(val3);
20501 }
20502 {
20503 if (!wxPyCheckForApp()) SWIG_fail;
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 SWIGINTERN PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
20517 int argc;
20518 PyObject *argv[4];
20519
20520 if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferedDC",0,3,argv))) SWIG_fail;
20521 --argc;
20522 if ((argc >= 1) && (argc <= 3)) {
20523 int _v = 0;
20524 if (argc > 1) {
20525 {
20526 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxBitmap, 0);
20527 _v = SWIG_CheckState(res);
20528 }
20529 if (!_v) goto check_1;
20530 }
20531 return _wrap_new_BufferedDC__SWIG_0(self, argc, argv);
20532 }
20533 check_1:
20534
20535 if ((argc >= 2) && (argc <= 3)) {
20536 return _wrap_new_BufferedDC__SWIG_1(self, argc, argv);
20537 }
20538
20539 fail:
20540 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
20541 return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *_wrap_delete_BufferedDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546 PyObject *resultobj = 0;
20547 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
20548 void *argp1 = 0 ;
20549 int res1 = 0 ;
20550 PyObject *swig_obj[1] ;
20551
20552 if (!args) SWIG_fail;
20553 swig_obj[0] = args;
20554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_DISOWN | 0 );
20555 if (!SWIG_IsOK(res1)) {
20556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferedDC" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
20557 }
20558 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 delete arg1;
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_Py_Void();
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_BufferedDC_UnMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 PyObject *swig_obj[1] ;
20579
20580 if (!args) SWIG_fail;
20581 swig_obj[0] = args;
20582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferedDC_UnMask" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
20585 }
20586 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 (arg1)->UnMask();
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_Py_Void();
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *BufferedDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *obj;
20602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20603 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedDC, SWIG_NewClientData(obj));
20604 return SWIG_Py_Void();
20605 }
20606
20607 SWIGINTERN PyObject *BufferedDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20608 return SWIG_Python_InitShadowInstance(args);
20609 }
20610
20611 SWIGINTERN PyObject *_wrap_new_BufferedPaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj = 0;
20613 wxWindow *arg1 = (wxWindow *) 0 ;
20614 wxBitmap const &arg2_defvalue = wxNullBitmap ;
20615 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
20616 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
20617 wxBufferedPaintDC *result = 0 ;
20618 void *argp1 = 0 ;
20619 int res1 = 0 ;
20620 void *argp2 = 0 ;
20621 int res2 = 0 ;
20622 int val3 ;
20623 int ecode3 = 0 ;
20624 PyObject * obj0 = 0 ;
20625 PyObject * obj1 = 0 ;
20626 PyObject * obj2 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "window",(char *) "buffer",(char *) "style", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedPaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20635 }
20636 arg1 = reinterpret_cast< wxWindow * >(argp1);
20637 if (obj1) {
20638 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
20639 if (!SWIG_IsOK(res2)) {
20640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20641 }
20642 if (!argp2) {
20643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
20644 }
20645 arg2 = reinterpret_cast< wxBitmap * >(argp2);
20646 }
20647 if (obj2) {
20648 ecode3 = SWIG_AsVal_int(obj2, &val3);
20649 if (!SWIG_IsOK(ecode3)) {
20650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedPaintDC" "', expected argument " "3"" of type '" "int""'");
20651 }
20652 arg3 = static_cast< int >(val3);
20653 }
20654 {
20655 if (!wxPyCheckForApp()) SWIG_fail;
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedPaintDC, SWIG_POINTER_NEW | 0 );
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 SWIGINTERN PyObject *BufferedPaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20669 PyObject *obj;
20670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20671 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedPaintDC, SWIG_NewClientData(obj));
20672 return SWIG_Py_Void();
20673 }
20674
20675 SWIGINTERN PyObject *BufferedPaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20676 return SWIG_Python_InitShadowInstance(args);
20677 }
20678
20679 SWIGINTERN PyObject *_wrap_new_ScreenDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20680 PyObject *resultobj = 0;
20681 wxScreenDC *result = 0 ;
20682
20683 if (!SWIG_Python_UnpackTuple(args,"new_ScreenDC",0,0,0)) SWIG_fail;
20684 {
20685 if (!wxPyCheckForApp()) SWIG_fail;
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (wxScreenDC *)new wxScreenDC();
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScreenDC, SWIG_POINTER_NEW | 0 );
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj = 0;
20700 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20701 wxWindow *arg2 = (wxWindow *) 0 ;
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 *) "window", NULL
20711 };
20712
20713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",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_StartDrawingOnTopWin" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20717 }
20718 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
20720 if (!SWIG_IsOK(res2)) {
20721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "2"" of type '" "wxWindow *""'");
20722 }
20723 arg2 = reinterpret_cast< wxWindow * >(argp2);
20724 {
20725 PyThreadState* __tstate = wxPyBeginAllowThreads();
20726 result = (bool)(arg1)->StartDrawingOnTop(arg2);
20727 wxPyEndAllowThreads(__tstate);
20728 if (PyErr_Occurred()) SWIG_fail;
20729 }
20730 {
20731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20732 }
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj = 0;
20741 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20742 wxRect *arg2 = (wxRect *) NULL ;
20743 bool result;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 void *argp2 = 0 ;
20747 int res2 = 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char * kwnames[] = {
20751 (char *) "self",(char *) "rect", NULL
20752 };
20753
20754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) SWIG_fail;
20755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20758 }
20759 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20760 if (obj1) {
20761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
20762 if (!SWIG_IsOK(res2)) {
20763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "2"" of type '" "wxRect *""'");
20764 }
20765 arg2 = reinterpret_cast< wxRect * >(argp2);
20766 }
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)(arg1)->StartDrawingOnTop(arg2);
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20775 }
20776 return resultobj;
20777 fail:
20778 return NULL;
20779 }
20780
20781
20782 SWIGINTERN PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20783 PyObject *resultobj = 0;
20784 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
20785 bool result;
20786 void *argp1 = 0 ;
20787 int res1 = 0 ;
20788 PyObject *swig_obj[1] ;
20789
20790 if (!args) SWIG_fail;
20791 swig_obj[0] = args;
20792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
20793 if (!SWIG_IsOK(res1)) {
20794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_EndDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
20795 }
20796 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (bool)(arg1)->EndDrawingOnTop();
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 {
20804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20805 }
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 SWIGINTERN PyObject *ScreenDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20813 PyObject *obj;
20814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20815 SWIG_TypeNewClientData(SWIGTYPE_p_wxScreenDC, SWIG_NewClientData(obj));
20816 return SWIG_Py_Void();
20817 }
20818
20819 SWIGINTERN PyObject *ScreenDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20820 return SWIG_Python_InitShadowInstance(args);
20821 }
20822
20823 SWIGINTERN PyObject *_wrap_new_ClientDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20824 PyObject *resultobj = 0;
20825 wxWindow *arg1 = (wxWindow *) 0 ;
20826 wxClientDC *result = 0 ;
20827 void *argp1 = 0 ;
20828 int res1 = 0 ;
20829 PyObject * obj0 = 0 ;
20830 char * kwnames[] = {
20831 (char *) "win", NULL
20832 };
20833
20834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) SWIG_fail;
20835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20838 }
20839 arg1 = reinterpret_cast< wxWindow * >(argp1);
20840 {
20841 if (!wxPyCheckForApp()) SWIG_fail;
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (wxClientDC *)new wxClientDC(arg1);
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClientDC, SWIG_POINTER_NEW | 0 );
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *ClientDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *obj;
20856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20857 SWIG_TypeNewClientData(SWIGTYPE_p_wxClientDC, SWIG_NewClientData(obj));
20858 return SWIG_Py_Void();
20859 }
20860
20861 SWIGINTERN PyObject *ClientDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20862 return SWIG_Python_InitShadowInstance(args);
20863 }
20864
20865 SWIGINTERN PyObject *_wrap_new_PaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20866 PyObject *resultobj = 0;
20867 wxWindow *arg1 = (wxWindow *) 0 ;
20868 wxPaintDC *result = 0 ;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject * obj0 = 0 ;
20872 char * kwnames[] = {
20873 (char *) "win", NULL
20874 };
20875
20876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) SWIG_fail;
20877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20878 if (!SWIG_IsOK(res1)) {
20879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20880 }
20881 arg1 = reinterpret_cast< wxWindow * >(argp1);
20882 {
20883 if (!wxPyCheckForApp()) SWIG_fail;
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxPaintDC *)new wxPaintDC(arg1);
20886 wxPyEndAllowThreads(__tstate);
20887 if (PyErr_Occurred()) SWIG_fail;
20888 }
20889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintDC, SWIG_POINTER_NEW | 0 );
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 SWIGINTERN PyObject *PaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20897 PyObject *obj;
20898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20899 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintDC, SWIG_NewClientData(obj));
20900 return SWIG_Py_Void();
20901 }
20902
20903 SWIGINTERN PyObject *PaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20904 return SWIG_Python_InitShadowInstance(args);
20905 }
20906
20907 SWIGINTERN PyObject *_wrap_new_WindowDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20908 PyObject *resultobj = 0;
20909 wxWindow *arg1 = (wxWindow *) 0 ;
20910 wxWindowDC *result = 0 ;
20911 void *argp1 = 0 ;
20912 int res1 = 0 ;
20913 PyObject * obj0 = 0 ;
20914 char * kwnames[] = {
20915 (char *) "win", NULL
20916 };
20917
20918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) SWIG_fail;
20919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
20920 if (!SWIG_IsOK(res1)) {
20921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDC" "', expected argument " "1"" of type '" "wxWindow *""'");
20922 }
20923 arg1 = reinterpret_cast< wxWindow * >(argp1);
20924 {
20925 if (!wxPyCheckForApp()) SWIG_fail;
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (wxWindowDC *)new wxWindowDC(arg1);
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDC, SWIG_POINTER_NEW | 0 );
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *WindowDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20939 PyObject *obj;
20940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20941 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDC, SWIG_NewClientData(obj));
20942 return SWIG_Py_Void();
20943 }
20944
20945 SWIGINTERN PyObject *WindowDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20946 return SWIG_Python_InitShadowInstance(args);
20947 }
20948
20949 SWIGINTERN PyObject *_wrap_new_MirrorDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj = 0;
20951 wxDC *arg1 = 0 ;
20952 bool arg2 ;
20953 wxMirrorDC *result = 0 ;
20954 void *argp1 = 0 ;
20955 int res1 = 0 ;
20956 bool val2 ;
20957 int ecode2 = 0 ;
20958 PyObject * obj0 = 0 ;
20959 PyObject * obj1 = 0 ;
20960 char * kwnames[] = {
20961 (char *) "dc",(char *) "mirror", NULL
20962 };
20963
20964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) SWIG_fail;
20965 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDC, 0 );
20966 if (!SWIG_IsOK(res1)) {
20967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
20968 }
20969 if (!argp1) {
20970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
20971 }
20972 arg1 = reinterpret_cast< wxDC * >(argp1);
20973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20974 if (!SWIG_IsOK(ecode2)) {
20975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MirrorDC" "', expected argument " "2"" of type '" "bool""'");
20976 }
20977 arg2 = static_cast< bool >(val2);
20978 {
20979 if (!wxPyCheckForApp()) SWIG_fail;
20980 PyThreadState* __tstate = wxPyBeginAllowThreads();
20981 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
20982 wxPyEndAllowThreads(__tstate);
20983 if (PyErr_Occurred()) SWIG_fail;
20984 }
20985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMirrorDC, SWIG_POINTER_NEW | 0 );
20986 return resultobj;
20987 fail:
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *MirrorDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *obj;
20994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20995 SWIG_TypeNewClientData(SWIGTYPE_p_wxMirrorDC, SWIG_NewClientData(obj));
20996 return SWIG_Py_Void();
20997 }
20998
20999 SWIGINTERN PyObject *MirrorDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21000 return SWIG_Python_InitShadowInstance(args);
21001 }
21002
21003 SWIGINTERN PyObject *_wrap_new_PostScriptDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21004 PyObject *resultobj = 0;
21005 wxPrintData *arg1 = 0 ;
21006 wxPostScriptDC *result = 0 ;
21007 void *argp1 = 0 ;
21008 int res1 = 0 ;
21009 PyObject * obj0 = 0 ;
21010 char * kwnames[] = {
21011 (char *) "printData", NULL
21012 };
21013
21014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) SWIG_fail;
21015 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21018 }
21019 if (!argp1) {
21020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21021 }
21022 arg1 = reinterpret_cast< wxPrintData * >(argp1);
21023 {
21024 if (!wxPyCheckForApp()) SWIG_fail;
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_NEW | 0 );
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
21040 wxPrintData *result = 0 ;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 PyObject *swig_obj[1] ;
21044
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_GetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
21050 }
21051 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 {
21055 wxPrintData &_result_ref = (arg1)->GetPrintData();
21056 result = (wxPrintData *) &_result_ref;
21057 }
21058 wxPyEndAllowThreads(__tstate);
21059 if (PyErr_Occurred()) SWIG_fail;
21060 }
21061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21069 PyObject *resultobj = 0;
21070 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
21071 wxPrintData *arg2 = 0 ;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 void *argp2 = 0 ;
21075 int res2 = 0 ;
21076 PyObject * obj0 = 0 ;
21077 PyObject * obj1 = 0 ;
21078 char * kwnames[] = {
21079 (char *) "self",(char *) "data", NULL
21080 };
21081
21082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;
21083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
21086 }
21087 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
21088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);
21089 if (!SWIG_IsOK(res2)) {
21090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
21091 }
21092 if (!argp2) {
21093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
21094 }
21095 arg2 = reinterpret_cast< wxPrintData * >(argp2);
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 (arg1)->SetPrintData((wxPrintData const &)*arg2);
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_Py_Void();
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_PostScriptDC_SetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = 0;
21111 int arg1 ;
21112 int val1 ;
21113 int ecode1 = 0 ;
21114 PyObject * obj0 = 0 ;
21115 char * kwnames[] = {
21116 (char *) "ppi", NULL
21117 };
21118
21119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) SWIG_fail;
21120 ecode1 = SWIG_AsVal_int(obj0, &val1);
21121 if (!SWIG_IsOK(ecode1)) {
21122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PostScriptDC_SetResolution" "', expected argument " "1"" of type '" "int""'");
21123 }
21124 arg1 = static_cast< int >(val1);
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 wxPostScriptDC::SetResolution(arg1);
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_Py_Void();
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *_wrap_PostScriptDC_GetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *resultobj = 0;
21140 int result;
21141
21142 if (!SWIG_Python_UnpackTuple(args,"PostScriptDC_GetResolution",0,0,0)) SWIG_fail;
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (int)wxPostScriptDC::GetResolution();
21146 wxPyEndAllowThreads(__tstate);
21147 if (PyErr_Occurred()) SWIG_fail;
21148 }
21149 resultobj = SWIG_From_int(static_cast< int >(result));
21150 return resultobj;
21151 fail:
21152 return NULL;
21153 }
21154
21155
21156 SWIGINTERN PyObject *PostScriptDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21157 PyObject *obj;
21158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPostScriptDC, SWIG_NewClientData(obj));
21160 return SWIG_Py_Void();
21161 }
21162
21163 SWIGINTERN PyObject *PostScriptDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21164 return SWIG_Python_InitShadowInstance(args);
21165 }
21166
21167 SWIGINTERN PyObject *_wrap_new_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj = 0;
21169 wxString const &arg1_defvalue = wxPyEmptyString ;
21170 wxString *arg1 = (wxString *) &arg1_defvalue ;
21171 wxMetaFile *result = 0 ;
21172 bool temp1 = false ;
21173 PyObject * obj0 = 0 ;
21174 char * kwnames[] = {
21175 (char *) "filename", NULL
21176 };
21177
21178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) SWIG_fail;
21179 if (obj0) {
21180 {
21181 arg1 = wxString_in_helper(obj0);
21182 if (arg1 == NULL) SWIG_fail;
21183 temp1 = true;
21184 }
21185 }
21186 {
21187 if (!wxPyCheckForApp()) SWIG_fail;
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, SWIG_POINTER_NEW | 0 );
21194 {
21195 if (temp1)
21196 delete arg1;
21197 }
21198 return resultobj;
21199 fail:
21200 {
21201 if (temp1)
21202 delete arg1;
21203 }
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *MetaFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *obj;
21210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21211 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFile, SWIG_NewClientData(obj));
21212 return SWIG_Py_Void();
21213 }
21214
21215 SWIGINTERN PyObject *MetaFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21216 return SWIG_Python_InitShadowInstance(args);
21217 }
21218
21219 SWIGINTERN PyObject *_wrap_new_MetaFileDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21220 PyObject *resultobj = 0;
21221 wxString const &arg1_defvalue = wxPyEmptyString ;
21222 wxString *arg1 = (wxString *) &arg1_defvalue ;
21223 int arg2 = (int) 0 ;
21224 int arg3 = (int) 0 ;
21225 wxString const &arg4_defvalue = wxPyEmptyString ;
21226 wxString *arg4 = (wxString *) &arg4_defvalue ;
21227 wxMetaFileDC *result = 0 ;
21228 bool temp1 = false ;
21229 int val2 ;
21230 int ecode2 = 0 ;
21231 int val3 ;
21232 int ecode3 = 0 ;
21233 bool temp4 = false ;
21234 PyObject * obj0 = 0 ;
21235 PyObject * obj1 = 0 ;
21236 PyObject * obj2 = 0 ;
21237 PyObject * obj3 = 0 ;
21238 char * kwnames[] = {
21239 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
21240 };
21241
21242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21243 if (obj0) {
21244 {
21245 arg1 = wxString_in_helper(obj0);
21246 if (arg1 == NULL) SWIG_fail;
21247 temp1 = true;
21248 }
21249 }
21250 if (obj1) {
21251 ecode2 = SWIG_AsVal_int(obj1, &val2);
21252 if (!SWIG_IsOK(ecode2)) {
21253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MetaFileDC" "', 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 '" "new_MetaFileDC" "', expected argument " "3"" of type '" "int""'");
21261 }
21262 arg3 = static_cast< int >(val3);
21263 }
21264 if (obj3) {
21265 {
21266 arg4 = wxString_in_helper(obj3);
21267 if (arg4 == NULL) SWIG_fail;
21268 temp4 = true;
21269 }
21270 }
21271 {
21272 if (!wxPyCheckForApp()) SWIG_fail;
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_NEW | 0 );
21279 {
21280 if (temp1)
21281 delete arg1;
21282 }
21283 {
21284 if (temp4)
21285 delete arg4;
21286 }
21287 return resultobj;
21288 fail:
21289 {
21290 if (temp1)
21291 delete arg1;
21292 }
21293 {
21294 if (temp4)
21295 delete arg4;
21296 }
21297 return NULL;
21298 }
21299
21300
21301 SWIGINTERN PyObject *MetaFileDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21302 PyObject *obj;
21303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21304 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFileDC, SWIG_NewClientData(obj));
21305 return SWIG_Py_Void();
21306 }
21307
21308 SWIGINTERN PyObject *MetaFileDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 return SWIG_Python_InitShadowInstance(args);
21310 }
21311
21312 SWIGINTERN PyObject *_wrap_new_PrinterDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21313 PyObject *resultobj = 0;
21314 wxPrintData *arg1 = 0 ;
21315 wxPrinterDC *result = 0 ;
21316 void *argp1 = 0 ;
21317 int res1 = 0 ;
21318 PyObject * obj0 = 0 ;
21319 char * kwnames[] = {
21320 (char *) "printData", NULL
21321 };
21322
21323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) SWIG_fail;
21324 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21327 }
21328 if (!argp1) {
21329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
21330 }
21331 arg1 = reinterpret_cast< wxPrintData * >(argp1);
21332 {
21333 if (!wxPyCheckForApp()) SWIG_fail;
21334 PyThreadState* __tstate = wxPyBeginAllowThreads();
21335 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrinterDC, SWIG_POINTER_NEW | 0 );
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 SWIGINTERN PyObject *PrinterDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21347 PyObject *obj;
21348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21349 SWIG_TypeNewClientData(SWIGTYPE_p_wxPrinterDC, SWIG_NewClientData(obj));
21350 return SWIG_Py_Void();
21351 }
21352
21353 SWIGINTERN PyObject *PrinterDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21354 return SWIG_Python_InitShadowInstance(args);
21355 }
21356
21357 SWIGINTERN PyObject *_wrap_new_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj = 0;
21359 int arg1 ;
21360 int arg2 ;
21361 int arg3 = (int) true ;
21362 int arg4 = (int) 1 ;
21363 wxImageList *result = 0 ;
21364 int val1 ;
21365 int ecode1 = 0 ;
21366 int val2 ;
21367 int ecode2 = 0 ;
21368 int val3 ;
21369 int ecode3 = 0 ;
21370 int val4 ;
21371 int ecode4 = 0 ;
21372 PyObject * obj0 = 0 ;
21373 PyObject * obj1 = 0 ;
21374 PyObject * obj2 = 0 ;
21375 PyObject * obj3 = 0 ;
21376 char * kwnames[] = {
21377 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
21378 };
21379
21380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21381 ecode1 = SWIG_AsVal_int(obj0, &val1);
21382 if (!SWIG_IsOK(ecode1)) {
21383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageList" "', expected argument " "1"" of type '" "int""'");
21384 }
21385 arg1 = static_cast< int >(val1);
21386 ecode2 = SWIG_AsVal_int(obj1, &val2);
21387 if (!SWIG_IsOK(ecode2)) {
21388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageList" "', expected argument " "2"" of type '" "int""'");
21389 }
21390 arg2 = static_cast< int >(val2);
21391 if (obj2) {
21392 ecode3 = SWIG_AsVal_int(obj2, &val3);
21393 if (!SWIG_IsOK(ecode3)) {
21394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageList" "', expected argument " "3"" of type '" "int""'");
21395 }
21396 arg3 = static_cast< int >(val3);
21397 }
21398 if (obj3) {
21399 ecode4 = SWIG_AsVal_int(obj3, &val4);
21400 if (!SWIG_IsOK(ecode4)) {
21401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImageList" "', expected argument " "4"" of type '" "int""'");
21402 }
21403 arg4 = static_cast< int >(val4);
21404 }
21405 {
21406 if (!wxPyCheckForApp()) SWIG_fail;
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 {
21413 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
21414 }
21415 return resultobj;
21416 fail:
21417 return NULL;
21418 }
21419
21420
21421 SWIGINTERN PyObject *_wrap_delete_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21422 PyObject *resultobj = 0;
21423 wxImageList *arg1 = (wxImageList *) 0 ;
21424 void *argp1 = 0 ;
21425 int res1 = 0 ;
21426 PyObject *swig_obj[1] ;
21427
21428 if (!args) SWIG_fail;
21429 swig_obj[0] = args;
21430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN | 0 );
21431 if (!SWIG_IsOK(res1)) {
21432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageList" "', expected argument " "1"" of type '" "wxImageList *""'");
21433 }
21434 arg1 = reinterpret_cast< wxImageList * >(argp1);
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 delete arg1;
21438
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 resultobj = SWIG_Py_Void();
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_ImageList_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21450 PyObject *resultobj = 0;
21451 wxImageList *arg1 = (wxImageList *) 0 ;
21452 wxBitmap *arg2 = 0 ;
21453 wxBitmap const &arg3_defvalue = wxNullBitmap ;
21454 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
21455 int result;
21456 void *argp1 = 0 ;
21457 int res1 = 0 ;
21458 void *argp2 = 0 ;
21459 int res2 = 0 ;
21460 void *argp3 = 0 ;
21461 int res3 = 0 ;
21462 PyObject * obj0 = 0 ;
21463 PyObject * obj1 = 0 ;
21464 PyObject * obj2 = 0 ;
21465 char * kwnames[] = {
21466 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
21467 };
21468
21469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21471 if (!SWIG_IsOK(res1)) {
21472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Add" "', expected argument " "1"" of type '" "wxImageList *""'");
21473 }
21474 arg1 = reinterpret_cast< wxImageList * >(argp1);
21475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
21476 if (!SWIG_IsOK(res2)) {
21477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21478 }
21479 if (!argp2) {
21480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21481 }
21482 arg2 = reinterpret_cast< wxBitmap * >(argp2);
21483 if (obj2) {
21484 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
21485 if (!SWIG_IsOK(res3)) {
21486 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21487 }
21488 if (!argp3) {
21489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21490 }
21491 arg3 = reinterpret_cast< wxBitmap * >(argp3);
21492 }
21493 {
21494 PyThreadState* __tstate = wxPyBeginAllowThreads();
21495 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 resultobj = SWIG_From_int(static_cast< int >(result));
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_ImageList_AddWithColourMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj = 0;
21508 wxImageList *arg1 = (wxImageList *) 0 ;
21509 wxBitmap *arg2 = 0 ;
21510 wxColour *arg3 = 0 ;
21511 int result;
21512 void *argp1 = 0 ;
21513 int res1 = 0 ;
21514 void *argp2 = 0 ;
21515 int res2 = 0 ;
21516 wxColour temp3 ;
21517 PyObject * obj0 = 0 ;
21518 PyObject * obj1 = 0 ;
21519 PyObject * obj2 = 0 ;
21520 char * kwnames[] = {
21521 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
21522 };
21523
21524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21526 if (!SWIG_IsOK(res1)) {
21527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddWithColourMask" "', expected argument " "1"" of type '" "wxImageList *""'");
21528 }
21529 arg1 = reinterpret_cast< wxImageList * >(argp1);
21530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
21531 if (!SWIG_IsOK(res2)) {
21532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21533 }
21534 if (!argp2) {
21535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
21536 }
21537 arg2 = reinterpret_cast< wxBitmap * >(argp2);
21538 {
21539 arg3 = &temp3;
21540 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21541 }
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 resultobj = SWIG_From_int(static_cast< int >(result));
21549 return resultobj;
21550 fail:
21551 return NULL;
21552 }
21553
21554
21555 SWIGINTERN PyObject *_wrap_ImageList_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21556 PyObject *resultobj = 0;
21557 wxImageList *arg1 = (wxImageList *) 0 ;
21558 wxIcon *arg2 = 0 ;
21559 int result;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 void *argp2 = 0 ;
21563 int res2 = 0 ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char * kwnames[] = {
21567 (char *) "self",(char *) "icon", NULL
21568 };
21569
21570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
21571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21572 if (!SWIG_IsOK(res1)) {
21573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddIcon" "', expected argument " "1"" of type '" "wxImageList *""'");
21574 }
21575 arg1 = reinterpret_cast< wxImageList * >(argp1);
21576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
21577 if (!SWIG_IsOK(res2)) {
21578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
21579 }
21580 if (!argp2) {
21581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
21582 }
21583 arg2 = reinterpret_cast< wxIcon * >(argp2);
21584 {
21585 PyThreadState* __tstate = wxPyBeginAllowThreads();
21586 result = (int)(arg1)->Add((wxIcon const &)*arg2);
21587 wxPyEndAllowThreads(__tstate);
21588 if (PyErr_Occurred()) SWIG_fail;
21589 }
21590 resultobj = SWIG_From_int(static_cast< int >(result));
21591 return resultobj;
21592 fail:
21593 return NULL;
21594 }
21595
21596
21597 SWIGINTERN PyObject *_wrap_ImageList_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21598 PyObject *resultobj = 0;
21599 wxImageList *arg1 = (wxImageList *) 0 ;
21600 int arg2 ;
21601 SwigValueWrapper<wxBitmap > result;
21602 void *argp1 = 0 ;
21603 int res1 = 0 ;
21604 int val2 ;
21605 int ecode2 = 0 ;
21606 PyObject * obj0 = 0 ;
21607 PyObject * obj1 = 0 ;
21608 char * kwnames[] = {
21609 (char *) "self",(char *) "index", NULL
21610 };
21611
21612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
21613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetBitmap" "', expected argument " "1"" of type '" "wxImageList const *""'");
21616 }
21617 arg1 = reinterpret_cast< wxImageList * >(argp1);
21618 ecode2 = SWIG_AsVal_int(obj1, &val2);
21619 if (!SWIG_IsOK(ecode2)) {
21620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetBitmap" "', expected argument " "2"" of type '" "int""'");
21621 }
21622 arg2 = static_cast< int >(val2);
21623 {
21624 PyThreadState* __tstate = wxPyBeginAllowThreads();
21625 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
21626 wxPyEndAllowThreads(__tstate);
21627 if (PyErr_Occurred()) SWIG_fail;
21628 }
21629 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 SWIGINTERN PyObject *_wrap_ImageList_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21637 PyObject *resultobj = 0;
21638 wxImageList *arg1 = (wxImageList *) 0 ;
21639 int arg2 ;
21640 wxIcon result;
21641 void *argp1 = 0 ;
21642 int res1 = 0 ;
21643 int val2 ;
21644 int ecode2 = 0 ;
21645 PyObject * obj0 = 0 ;
21646 PyObject * obj1 = 0 ;
21647 char * kwnames[] = {
21648 (char *) "self",(char *) "index", NULL
21649 };
21650
21651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
21652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetIcon" "', expected argument " "1"" of type '" "wxImageList const *""'");
21655 }
21656 arg1 = reinterpret_cast< wxImageList * >(argp1);
21657 ecode2 = SWIG_AsVal_int(obj1, &val2);
21658 if (!SWIG_IsOK(ecode2)) {
21659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetIcon" "', expected argument " "2"" of type '" "int""'");
21660 }
21661 arg2 = static_cast< int >(val2);
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = ((wxImageList const *)arg1)->GetIcon(arg2);
21665 wxPyEndAllowThreads(__tstate);
21666 if (PyErr_Occurred()) SWIG_fail;
21667 }
21668 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
21669 return resultobj;
21670 fail:
21671 return NULL;
21672 }
21673
21674
21675 SWIGINTERN PyObject *_wrap_ImageList_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21676 PyObject *resultobj = 0;
21677 wxImageList *arg1 = (wxImageList *) 0 ;
21678 int arg2 ;
21679 wxBitmap *arg3 = 0 ;
21680 wxBitmap const &arg4_defvalue = wxNullBitmap ;
21681 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
21682 bool result;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 int val2 ;
21686 int ecode2 = 0 ;
21687 void *argp3 = 0 ;
21688 int res3 = 0 ;
21689 void *argp4 = 0 ;
21690 int res4 = 0 ;
21691 PyObject * obj0 = 0 ;
21692 PyObject * obj1 = 0 ;
21693 PyObject * obj2 = 0 ;
21694 PyObject * obj3 = 0 ;
21695 char * kwnames[] = {
21696 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
21697 };
21698
21699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21701 if (!SWIG_IsOK(res1)) {
21702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Replace" "', expected argument " "1"" of type '" "wxImageList *""'");
21703 }
21704 arg1 = reinterpret_cast< wxImageList * >(argp1);
21705 ecode2 = SWIG_AsVal_int(obj1, &val2);
21706 if (!SWIG_IsOK(ecode2)) {
21707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Replace" "', expected argument " "2"" of type '" "int""'");
21708 }
21709 arg2 = static_cast< int >(val2);
21710 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
21711 if (!SWIG_IsOK(res3)) {
21712 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21713 }
21714 if (!argp3) {
21715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
21716 }
21717 arg3 = reinterpret_cast< wxBitmap * >(argp3);
21718 if (obj3) {
21719 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 | 0);
21720 if (!SWIG_IsOK(res4)) {
21721 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
21722 }
21723 if (!argp4) {
21724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
21725 }
21726 arg4 = reinterpret_cast< wxBitmap * >(argp4);
21727 }
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 {
21735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21736 }
21737 return resultobj;
21738 fail:
21739 return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_ImageList_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj = 0;
21745 wxImageList *arg1 = (wxImageList *) 0 ;
21746 int arg2 ;
21747 wxDC *arg3 = 0 ;
21748 int arg4 ;
21749 int arg5 ;
21750 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
21751 bool arg7 = (bool) (bool)false ;
21752 bool result;
21753 void *argp1 = 0 ;
21754 int res1 = 0 ;
21755 int val2 ;
21756 int ecode2 = 0 ;
21757 void *argp3 = 0 ;
21758 int res3 = 0 ;
21759 int val4 ;
21760 int ecode4 = 0 ;
21761 int val5 ;
21762 int ecode5 = 0 ;
21763 int val6 ;
21764 int ecode6 = 0 ;
21765 bool val7 ;
21766 int ecode7 = 0 ;
21767 PyObject * obj0 = 0 ;
21768 PyObject * obj1 = 0 ;
21769 PyObject * obj2 = 0 ;
21770 PyObject * obj3 = 0 ;
21771 PyObject * obj4 = 0 ;
21772 PyObject * obj5 = 0 ;
21773 PyObject * obj6 = 0 ;
21774 char * kwnames[] = {
21775 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
21776 };
21777
21778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
21779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21780 if (!SWIG_IsOK(res1)) {
21781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Draw" "', expected argument " "1"" of type '" "wxImageList *""'");
21782 }
21783 arg1 = reinterpret_cast< wxImageList * >(argp1);
21784 ecode2 = SWIG_AsVal_int(obj1, &val2);
21785 if (!SWIG_IsOK(ecode2)) {
21786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Draw" "', expected argument " "2"" of type '" "int""'");
21787 }
21788 arg2 = static_cast< int >(val2);
21789 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
21790 if (!SWIG_IsOK(res3)) {
21791 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
21792 }
21793 if (!argp3) {
21794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
21795 }
21796 arg3 = reinterpret_cast< wxDC * >(argp3);
21797 ecode4 = SWIG_AsVal_int(obj3, &val4);
21798 if (!SWIG_IsOK(ecode4)) {
21799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageList_Draw" "', expected argument " "4"" of type '" "int""'");
21800 }
21801 arg4 = static_cast< int >(val4);
21802 ecode5 = SWIG_AsVal_int(obj4, &val5);
21803 if (!SWIG_IsOK(ecode5)) {
21804 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageList_Draw" "', expected argument " "5"" of type '" "int""'");
21805 }
21806 arg5 = static_cast< int >(val5);
21807 if (obj5) {
21808 ecode6 = SWIG_AsVal_int(obj5, &val6);
21809 if (!SWIG_IsOK(ecode6)) {
21810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageList_Draw" "', expected argument " "6"" of type '" "int""'");
21811 }
21812 arg6 = static_cast< int >(val6);
21813 }
21814 if (obj6) {
21815 ecode7 = SWIG_AsVal_bool(obj6, &val7);
21816 if (!SWIG_IsOK(ecode7)) {
21817 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageList_Draw" "', expected argument " "7"" of type '" "bool""'");
21818 }
21819 arg7 = static_cast< bool >(val7);
21820 }
21821 {
21822 PyThreadState* __tstate = wxPyBeginAllowThreads();
21823 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
21824 wxPyEndAllowThreads(__tstate);
21825 if (PyErr_Occurred()) SWIG_fail;
21826 }
21827 {
21828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21829 }
21830 return resultobj;
21831 fail:
21832 return NULL;
21833 }
21834
21835
21836 SWIGINTERN PyObject *_wrap_ImageList_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21837 PyObject *resultobj = 0;
21838 wxImageList *arg1 = (wxImageList *) 0 ;
21839 int result;
21840 void *argp1 = 0 ;
21841 int res1 = 0 ;
21842 PyObject *swig_obj[1] ;
21843
21844 if (!args) SWIG_fail;
21845 swig_obj[0] = args;
21846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21847 if (!SWIG_IsOK(res1)) {
21848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetImageCount" "', expected argument " "1"" of type '" "wxImageList *""'");
21849 }
21850 arg1 = reinterpret_cast< wxImageList * >(argp1);
21851 {
21852 PyThreadState* __tstate = wxPyBeginAllowThreads();
21853 result = (int)(arg1)->GetImageCount();
21854 wxPyEndAllowThreads(__tstate);
21855 if (PyErr_Occurred()) SWIG_fail;
21856 }
21857 resultobj = SWIG_From_int(static_cast< int >(result));
21858 return resultobj;
21859 fail:
21860 return NULL;
21861 }
21862
21863
21864 SWIGINTERN PyObject *_wrap_ImageList_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21865 PyObject *resultobj = 0;
21866 wxImageList *arg1 = (wxImageList *) 0 ;
21867 int arg2 ;
21868 bool result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 int val2 ;
21872 int ecode2 = 0 ;
21873 PyObject * obj0 = 0 ;
21874 PyObject * obj1 = 0 ;
21875 char * kwnames[] = {
21876 (char *) "self",(char *) "index", NULL
21877 };
21878
21879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
21880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21881 if (!SWIG_IsOK(res1)) {
21882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Remove" "', expected argument " "1"" of type '" "wxImageList *""'");
21883 }
21884 arg1 = reinterpret_cast< wxImageList * >(argp1);
21885 ecode2 = SWIG_AsVal_int(obj1, &val2);
21886 if (!SWIG_IsOK(ecode2)) {
21887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Remove" "', expected argument " "2"" of type '" "int""'");
21888 }
21889 arg2 = static_cast< int >(val2);
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (bool)(arg1)->Remove(arg2);
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_ImageList_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21906 PyObject *resultobj = 0;
21907 wxImageList *arg1 = (wxImageList *) 0 ;
21908 bool result;
21909 void *argp1 = 0 ;
21910 int res1 = 0 ;
21911 PyObject *swig_obj[1] ;
21912
21913 if (!args) SWIG_fail;
21914 swig_obj[0] = args;
21915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21916 if (!SWIG_IsOK(res1)) {
21917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_RemoveAll" "', expected argument " "1"" of type '" "wxImageList *""'");
21918 }
21919 arg1 = reinterpret_cast< wxImageList * >(argp1);
21920 {
21921 PyThreadState* __tstate = wxPyBeginAllowThreads();
21922 result = (bool)(arg1)->RemoveAll();
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 {
21927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21928 }
21929 return resultobj;
21930 fail:
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *_wrap_ImageList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj = 0;
21937 wxImageList *arg1 = (wxImageList *) 0 ;
21938 int arg2 ;
21939 int *arg3 = 0 ;
21940 int *arg4 = 0 ;
21941 void *argp1 = 0 ;
21942 int res1 = 0 ;
21943 int val2 ;
21944 int ecode2 = 0 ;
21945 int temp3 ;
21946 int res3 = SWIG_TMPOBJ ;
21947 int temp4 ;
21948 int res4 = SWIG_TMPOBJ ;
21949 PyObject * obj0 = 0 ;
21950 PyObject * obj1 = 0 ;
21951 char * kwnames[] = {
21952 (char *) "self",(char *) "index", NULL
21953 };
21954
21955 arg3 = &temp3;
21956 arg4 = &temp4;
21957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
21958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
21959 if (!SWIG_IsOK(res1)) {
21960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetSize" "', expected argument " "1"" of type '" "wxImageList *""'");
21961 }
21962 arg1 = reinterpret_cast< wxImageList * >(argp1);
21963 ecode2 = SWIG_AsVal_int(obj1, &val2);
21964 if (!SWIG_IsOK(ecode2)) {
21965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetSize" "', expected argument " "2"" of type '" "int""'");
21966 }
21967 arg2 = static_cast< int >(val2);
21968 {
21969 PyThreadState* __tstate = wxPyBeginAllowThreads();
21970 (arg1)->GetSize(arg2,*arg3,*arg4);
21971 wxPyEndAllowThreads(__tstate);
21972 if (PyErr_Occurred()) SWIG_fail;
21973 }
21974 resultobj = SWIG_Py_Void();
21975 if (SWIG_IsTmpObj(res3)) {
21976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21977 } else {
21978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21980 }
21981 if (SWIG_IsTmpObj(res4)) {
21982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
21983 } else {
21984 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
21986 }
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 SWIGINTERN PyObject *ImageList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21994 PyObject *obj;
21995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21996 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageList, SWIG_NewClientData(obj));
21997 return SWIG_Py_Void();
21998 }
21999
22000 SWIGINTERN PyObject *ImageList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 return SWIG_Python_InitShadowInstance(args);
22002 }
22003
22004 SWIGINTERN PyObject *_wrap_new_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 PyObject *resultobj = 0;
22006 wxStockGDI *result = 0 ;
22007
22008 if (!SWIG_Python_UnpackTuple(args,"new_StockGDI",0,0,0)) SWIG_fail;
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (wxStockGDI *)new wxStockGDI();
22012 wxPyEndAllowThreads(__tstate);
22013 if (PyErr_Occurred()) SWIG_fail;
22014 }
22015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, SWIG_POINTER_NEW | 0 );
22016 return resultobj;
22017 fail:
22018 return NULL;
22019 }
22020
22021
22022 SWIGINTERN PyObject *_wrap_delete_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22023 PyObject *resultobj = 0;
22024 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
22025 void *argp1 = 0 ;
22026 int res1 = 0 ;
22027 PyObject *swig_obj[1] ;
22028
22029 if (!args) SWIG_fail;
22030 swig_obj[0] = args;
22031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStockGDI, SWIG_POINTER_DISOWN | 0 );
22032 if (!SWIG_IsOK(res1)) {
22033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StockGDI" "', expected argument " "1"" of type '" "wxStockGDI *""'");
22034 }
22035 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 delete arg1;
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_StockGDI_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052
22053 if (!SWIG_Python_UnpackTuple(args,"StockGDI_DeleteAll",0,0,0)) SWIG_fail;
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 wxStockGDI::DeleteAll();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 resultobj = SWIG_Py_Void();
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 SWIGINTERN PyObject *_wrap_StockGDI_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22068 PyObject *resultobj = 0;
22069 wxStockGDI *result = 0 ;
22070
22071 if (!SWIG_Python_UnpackTuple(args,"StockGDI_instance",0,0,0)) SWIG_fail;
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 {
22075 wxStockGDI &_result_ref = wxStockGDI::instance();
22076 result = (wxStockGDI *) &_result_ref;
22077 }
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, 0 | 0 );
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *_wrap_StockGDI_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj = 0;
22090 wxStockGDI::Item arg1 ;
22091 wxBrush *result = 0 ;
22092 int val1 ;
22093 int ecode1 = 0 ;
22094 PyObject * obj0 = 0 ;
22095 char * kwnames[] = {
22096 (char *) "item", NULL
22097 };
22098
22099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetBrush",kwnames,&obj0)) SWIG_fail;
22100 ecode1 = SWIG_AsVal_int(obj0, &val1);
22101 if (!SWIG_IsOK(ecode1)) {
22102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetBrush" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
22103 }
22104 arg1 = static_cast< wxStockGDI::Item >(val1);
22105 {
22106 PyThreadState* __tstate = wxPyBeginAllowThreads();
22107 result = (wxBrush *)wxStockGDI::GetBrush(arg1);
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 SWIGINTERN PyObject *_wrap_StockGDI_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj = 0;
22120 wxStockGDI::Item arg1 ;
22121 wxColour *result = 0 ;
22122 int val1 ;
22123 int ecode1 = 0 ;
22124 PyObject * obj0 = 0 ;
22125 char * kwnames[] = {
22126 (char *) "item", NULL
22127 };
22128
22129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetColour",kwnames,&obj0)) SWIG_fail;
22130 ecode1 = SWIG_AsVal_int(obj0, &val1);
22131 if (!SWIG_IsOK(ecode1)) {
22132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetColour" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
22133 }
22134 arg1 = static_cast< wxStockGDI::Item >(val1);
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (wxColour *)wxStockGDI::GetColour(arg1);
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_StockGDI_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22149 PyObject *resultobj = 0;
22150 wxStockGDI::Item arg1 ;
22151 wxCursor *result = 0 ;
22152 int val1 ;
22153 int ecode1 = 0 ;
22154 PyObject * obj0 = 0 ;
22155 char * kwnames[] = {
22156 (char *) "item", NULL
22157 };
22158
22159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetCursor",kwnames,&obj0)) SWIG_fail;
22160 ecode1 = SWIG_AsVal_int(obj0, &val1);
22161 if (!SWIG_IsOK(ecode1)) {
22162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetCursor" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
22163 }
22164 arg1 = static_cast< wxStockGDI::Item >(val1);
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (wxCursor *)wxStockGDI::GetCursor(arg1);
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, 0 | 0 );
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_StockGDI_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj = 0;
22180 wxStockGDI::Item arg1 ;
22181 wxPen *result = 0 ;
22182 int val1 ;
22183 int ecode1 = 0 ;
22184 PyObject * obj0 = 0 ;
22185 char * kwnames[] = {
22186 (char *) "item", NULL
22187 };
22188
22189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetPen",kwnames,&obj0)) SWIG_fail;
22190 ecode1 = SWIG_AsVal_int(obj0, &val1);
22191 if (!SWIG_IsOK(ecode1)) {
22192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetPen" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
22193 }
22194 arg1 = static_cast< wxStockGDI::Item >(val1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (wxPen *)wxStockGDI::GetPen(arg1);
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_StockGDI_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22209 PyObject *resultobj = 0;
22210 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
22211 wxStockGDI::Item arg2 ;
22212 wxFont *result = 0 ;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 int val2 ;
22216 int ecode2 = 0 ;
22217 PyObject * obj0 = 0 ;
22218 PyObject * obj1 = 0 ;
22219 char * kwnames[] = {
22220 (char *) "self",(char *) "item", NULL
22221 };
22222
22223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StockGDI_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
22224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStockGDI, 0 | 0 );
22225 if (!SWIG_IsOK(res1)) {
22226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StockGDI_GetFont" "', expected argument " "1"" of type '" "wxStockGDI *""'");
22227 }
22228 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
22229 ecode2 = SWIG_AsVal_int(obj1, &val2);
22230 if (!SWIG_IsOK(ecode2)) {
22231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StockGDI_GetFont" "', expected argument " "2"" of type '" "wxStockGDI::Item""'");
22232 }
22233 arg2 = static_cast< wxStockGDI::Item >(val2);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (wxFont *)(arg1)->GetFont(arg2);
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *StockGDI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22248 PyObject *obj;
22249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22250 SWIG_TypeNewClientData(SWIGTYPE_p_wxStockGDI, SWIG_NewClientData(obj));
22251 return SWIG_Py_Void();
22252 }
22253
22254 SWIGINTERN PyObject *StockGDI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 return SWIG_Python_InitShadowInstance(args);
22256 }
22257
22258 SWIGINTERN int NullBitmap_set(PyObject *) {
22259 SWIG_Error(SWIG_AttributeError,"Variable NullBitmap is read-only.");
22260 return 1;
22261 }
22262
22263
22264 SWIGINTERN PyObject *NullBitmap_get(void) {
22265 PyObject *pyobj = 0;
22266
22267 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0 );
22268 return pyobj;
22269 }
22270
22271
22272 SWIGINTERN int NullIcon_set(PyObject *) {
22273 SWIG_Error(SWIG_AttributeError,"Variable NullIcon is read-only.");
22274 return 1;
22275 }
22276
22277
22278 SWIGINTERN PyObject *NullIcon_get(void) {
22279 PyObject *pyobj = 0;
22280
22281 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullIcon), SWIGTYPE_p_wxIcon, 0 );
22282 return pyobj;
22283 }
22284
22285
22286 SWIGINTERN int NullCursor_set(PyObject *) {
22287 SWIG_Error(SWIG_AttributeError,"Variable NullCursor is read-only.");
22288 return 1;
22289 }
22290
22291
22292 SWIGINTERN PyObject *NullCursor_get(void) {
22293 PyObject *pyobj = 0;
22294
22295 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullCursor), SWIGTYPE_p_wxCursor, 0 );
22296 return pyobj;
22297 }
22298
22299
22300 SWIGINTERN int NullPen_set(PyObject *) {
22301 SWIG_Error(SWIG_AttributeError,"Variable NullPen is read-only.");
22302 return 1;
22303 }
22304
22305
22306 SWIGINTERN PyObject *NullPen_get(void) {
22307 PyObject *pyobj = 0;
22308
22309 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPen), SWIGTYPE_p_wxPen, 0 );
22310 return pyobj;
22311 }
22312
22313
22314 SWIGINTERN int NullBrush_set(PyObject *) {
22315 SWIG_Error(SWIG_AttributeError,"Variable NullBrush is read-only.");
22316 return 1;
22317 }
22318
22319
22320 SWIGINTERN PyObject *NullBrush_get(void) {
22321 PyObject *pyobj = 0;
22322
22323 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBrush), SWIGTYPE_p_wxBrush, 0 );
22324 return pyobj;
22325 }
22326
22327
22328 SWIGINTERN int NullPalette_set(PyObject *) {
22329 SWIG_Error(SWIG_AttributeError,"Variable NullPalette is read-only.");
22330 return 1;
22331 }
22332
22333
22334 SWIGINTERN PyObject *NullPalette_get(void) {
22335 PyObject *pyobj = 0;
22336
22337 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPalette), SWIGTYPE_p_wxPalette, 0 );
22338 return pyobj;
22339 }
22340
22341
22342 SWIGINTERN int NullFont_set(PyObject *) {
22343 SWIG_Error(SWIG_AttributeError,"Variable NullFont is read-only.");
22344 return 1;
22345 }
22346
22347
22348 SWIGINTERN PyObject *NullFont_get(void) {
22349 PyObject *pyobj = 0;
22350
22351 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullFont), SWIGTYPE_p_wxFont, 0 );
22352 return pyobj;
22353 }
22354
22355
22356 SWIGINTERN int NullColour_set(PyObject *) {
22357 SWIG_Error(SWIG_AttributeError,"Variable NullColour is read-only.");
22358 return 1;
22359 }
22360
22361
22362 SWIGINTERN PyObject *NullColour_get(void) {
22363 PyObject *pyobj = 0;
22364
22365 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullColour), SWIGTYPE_p_wxColour, 0 );
22366 return pyobj;
22367 }
22368
22369
22370 SWIGINTERN PyObject *_wrap_new_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22371 PyObject *resultobj = 0;
22372 wxGDIObjListBase *result = 0 ;
22373
22374 if (!SWIG_Python_UnpackTuple(args,"new_GDIObjListBase",0,0,0)) SWIG_fail;
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 result = (wxGDIObjListBase *)new wxGDIObjListBase();
22378 wxPyEndAllowThreads(__tstate);
22379 if (PyErr_Occurred()) SWIG_fail;
22380 }
22381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_NEW | 0 );
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 SWIGINTERN PyObject *_wrap_delete_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22389 PyObject *resultobj = 0;
22390 wxGDIObjListBase *arg1 = (wxGDIObjListBase *) 0 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 PyObject *swig_obj[1] ;
22394
22395 if (!args) SWIG_fail;
22396 swig_obj[0] = args;
22397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_DISOWN | 0 );
22398 if (!SWIG_IsOK(res1)) {
22399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObjListBase" "', expected argument " "1"" of type '" "wxGDIObjListBase *""'");
22400 }
22401 arg1 = reinterpret_cast< wxGDIObjListBase * >(argp1);
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 delete arg1;
22405
22406 wxPyEndAllowThreads(__tstate);
22407 if (PyErr_Occurred()) SWIG_fail;
22408 }
22409 resultobj = SWIG_Py_Void();
22410 return resultobj;
22411 fail:
22412 return NULL;
22413 }
22414
22415
22416 SWIGINTERN PyObject *GDIObjListBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22417 PyObject *obj;
22418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22419 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObjListBase, SWIG_NewClientData(obj));
22420 return SWIG_Py_Void();
22421 }
22422
22423 SWIGINTERN PyObject *GDIObjListBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22424 return SWIG_Python_InitShadowInstance(args);
22425 }
22426
22427 SWIGINTERN PyObject *_wrap_PenList_FindOrCreatePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22428 PyObject *resultobj = 0;
22429 wxPenList *arg1 = (wxPenList *) 0 ;
22430 wxColour *arg2 = 0 ;
22431 int arg3 ;
22432 int arg4 ;
22433 wxPen *result = 0 ;
22434 void *argp1 = 0 ;
22435 int res1 = 0 ;
22436 wxColour temp2 ;
22437 int val3 ;
22438 int ecode3 = 0 ;
22439 int val4 ;
22440 int ecode4 = 0 ;
22441 PyObject * obj0 = 0 ;
22442 PyObject * obj1 = 0 ;
22443 PyObject * obj2 = 0 ;
22444 PyObject * obj3 = 0 ;
22445 char * kwnames[] = {
22446 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
22447 };
22448
22449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22451 if (!SWIG_IsOK(res1)) {
22452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_FindOrCreatePen" "', expected argument " "1"" of type '" "wxPenList *""'");
22453 }
22454 arg1 = reinterpret_cast< wxPenList * >(argp1);
22455 {
22456 arg2 = &temp2;
22457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22458 }
22459 ecode3 = SWIG_AsVal_int(obj2, &val3);
22460 if (!SWIG_IsOK(ecode3)) {
22461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PenList_FindOrCreatePen" "', expected argument " "3"" of type '" "int""'");
22462 }
22463 arg3 = static_cast< int >(val3);
22464 ecode4 = SWIG_AsVal_int(obj3, &val4);
22465 if (!SWIG_IsOK(ecode4)) {
22466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PenList_FindOrCreatePen" "', expected argument " "4"" of type '" "int""'");
22467 }
22468 arg4 = static_cast< int >(val4);
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 SWIGINTERN PyObject *_wrap_PenList_AddPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22483 PyObject *resultobj = 0;
22484 wxPenList *arg1 = (wxPenList *) 0 ;
22485 wxPen *arg2 = (wxPen *) 0 ;
22486 void *argp1 = 0 ;
22487 int res1 = 0 ;
22488 void *argp2 = 0 ;
22489 int res2 = 0 ;
22490 PyObject * obj0 = 0 ;
22491 PyObject * obj1 = 0 ;
22492 char * kwnames[] = {
22493 (char *) "self",(char *) "pen", NULL
22494 };
22495
22496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) SWIG_fail;
22497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22498 if (!SWIG_IsOK(res1)) {
22499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_AddPen" "', expected argument " "1"" of type '" "wxPenList *""'");
22500 }
22501 arg1 = reinterpret_cast< wxPenList * >(argp1);
22502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
22503 if (!SWIG_IsOK(res2)) {
22504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_AddPen" "', expected argument " "2"" of type '" "wxPen *""'");
22505 }
22506 arg2 = reinterpret_cast< wxPen * >(argp2);
22507 {
22508 PyThreadState* __tstate = wxPyBeginAllowThreads();
22509 (arg1)->AddPen(arg2);
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 resultobj = SWIG_Py_Void();
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 SWIGINTERN PyObject *_wrap_PenList_RemovePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22521 PyObject *resultobj = 0;
22522 wxPenList *arg1 = (wxPenList *) 0 ;
22523 wxPen *arg2 = (wxPen *) 0 ;
22524 void *argp1 = 0 ;
22525 int res1 = 0 ;
22526 void *argp2 = 0 ;
22527 int res2 = 0 ;
22528 PyObject * obj0 = 0 ;
22529 PyObject * obj1 = 0 ;
22530 char * kwnames[] = {
22531 (char *) "self",(char *) "pen", NULL
22532 };
22533
22534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) SWIG_fail;
22535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
22536 if (!SWIG_IsOK(res1)) {
22537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_RemovePen" "', expected argument " "1"" of type '" "wxPenList *""'");
22538 }
22539 arg1 = reinterpret_cast< wxPenList * >(argp1);
22540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
22541 if (!SWIG_IsOK(res2)) {
22542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_RemovePen" "', expected argument " "2"" of type '" "wxPen *""'");
22543 }
22544 arg2 = reinterpret_cast< wxPen * >(argp2);
22545 {
22546 PyThreadState* __tstate = wxPyBeginAllowThreads();
22547 (arg1)->RemovePen(arg2);
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 resultobj = SWIG_Py_Void();
22552 return resultobj;
22553 fail:
22554 return NULL;
22555 }
22556
22557
22558 SWIGINTERN PyObject *PenList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22559 PyObject *obj;
22560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPenList, SWIG_NewClientData(obj));
22562 return SWIG_Py_Void();
22563 }
22564
22565 SWIGINTERN PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj = 0;
22567 wxBrushList *arg1 = (wxBrushList *) 0 ;
22568 wxColour *arg2 = 0 ;
22569 int arg3 = (int) wxSOLID ;
22570 wxBrush *result = 0 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 wxColour temp2 ;
22574 int val3 ;
22575 int ecode3 = 0 ;
22576 PyObject * obj0 = 0 ;
22577 PyObject * obj1 = 0 ;
22578 PyObject * obj2 = 0 ;
22579 char * kwnames[] = {
22580 (char *) "self",(char *) "colour",(char *) "style", NULL
22581 };
22582
22583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
22587 }
22588 arg1 = reinterpret_cast< wxBrushList * >(argp1);
22589 {
22590 arg2 = &temp2;
22591 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22592 }
22593 if (obj2) {
22594 ecode3 = SWIG_AsVal_int(obj2, &val3);
22595 if (!SWIG_IsOK(ecode3)) {
22596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "3"" of type '" "int""'");
22597 }
22598 arg3 = static_cast< int >(val3);
22599 }
22600 {
22601 PyThreadState* __tstate = wxPyBeginAllowThreads();
22602 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
22603 wxPyEndAllowThreads(__tstate);
22604 if (PyErr_Occurred()) SWIG_fail;
22605 }
22606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
22607 return resultobj;
22608 fail:
22609 return NULL;
22610 }
22611
22612
22613 SWIGINTERN PyObject *_wrap_BrushList_AddBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22614 PyObject *resultobj = 0;
22615 wxBrushList *arg1 = (wxBrushList *) 0 ;
22616 wxBrush *arg2 = (wxBrush *) 0 ;
22617 void *argp1 = 0 ;
22618 int res1 = 0 ;
22619 void *argp2 = 0 ;
22620 int res2 = 0 ;
22621 PyObject * obj0 = 0 ;
22622 PyObject * obj1 = 0 ;
22623 char * kwnames[] = {
22624 (char *) "self",(char *) "brush", NULL
22625 };
22626
22627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) SWIG_fail;
22628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
22629 if (!SWIG_IsOK(res1)) {
22630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_AddBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
22631 }
22632 arg1 = reinterpret_cast< wxBrushList * >(argp1);
22633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
22634 if (!SWIG_IsOK(res2)) {
22635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_AddBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
22636 }
22637 arg2 = reinterpret_cast< wxBrush * >(argp2);
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 (arg1)->AddBrush(arg2);
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 resultobj = SWIG_Py_Void();
22645 return resultobj;
22646 fail:
22647 return NULL;
22648 }
22649
22650
22651 SWIGINTERN PyObject *_wrap_BrushList_RemoveBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22652 PyObject *resultobj = 0;
22653 wxBrushList *arg1 = (wxBrushList *) 0 ;
22654 wxBrush *arg2 = (wxBrush *) 0 ;
22655 void *argp1 = 0 ;
22656 int res1 = 0 ;
22657 void *argp2 = 0 ;
22658 int res2 = 0 ;
22659 PyObject * obj0 = 0 ;
22660 PyObject * obj1 = 0 ;
22661 char * kwnames[] = {
22662 (char *) "self",(char *) "brush", NULL
22663 };
22664
22665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) SWIG_fail;
22666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
22667 if (!SWIG_IsOK(res1)) {
22668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_RemoveBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
22669 }
22670 arg1 = reinterpret_cast< wxBrushList * >(argp1);
22671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
22672 if (!SWIG_IsOK(res2)) {
22673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_RemoveBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
22674 }
22675 arg2 = reinterpret_cast< wxBrush * >(argp2);
22676 {
22677 PyThreadState* __tstate = wxPyBeginAllowThreads();
22678 (arg1)->RemoveBrush(arg2);
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 resultobj = SWIG_Py_Void();
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 SWIGINTERN PyObject *BrushList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22690 PyObject *obj;
22691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22692 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrushList, SWIG_NewClientData(obj));
22693 return SWIG_Py_Void();
22694 }
22695
22696 SWIGINTERN PyObject *_wrap_FontList_FindOrCreateFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22697 PyObject *resultobj = 0;
22698 wxFontList *arg1 = (wxFontList *) 0 ;
22699 int arg2 ;
22700 int arg3 ;
22701 int arg4 ;
22702 int arg5 ;
22703 bool arg6 = (bool) false ;
22704 wxString const &arg7_defvalue = wxPyEmptyString ;
22705 wxString *arg7 = (wxString *) &arg7_defvalue ;
22706 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
22707 wxFont *result = 0 ;
22708 void *argp1 = 0 ;
22709 int res1 = 0 ;
22710 int val2 ;
22711 int ecode2 = 0 ;
22712 int val3 ;
22713 int ecode3 = 0 ;
22714 int val4 ;
22715 int ecode4 = 0 ;
22716 int val5 ;
22717 int ecode5 = 0 ;
22718 bool val6 ;
22719 int ecode6 = 0 ;
22720 bool temp7 = false ;
22721 int val8 ;
22722 int ecode8 = 0 ;
22723 PyObject * obj0 = 0 ;
22724 PyObject * obj1 = 0 ;
22725 PyObject * obj2 = 0 ;
22726 PyObject * obj3 = 0 ;
22727 PyObject * obj4 = 0 ;
22728 PyObject * obj5 = 0 ;
22729 PyObject * obj6 = 0 ;
22730 PyObject * obj7 = 0 ;
22731 char * kwnames[] = {
22732 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
22733 };
22734
22735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
22737 if (!SWIG_IsOK(res1)) {
22738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_FindOrCreateFont" "', expected argument " "1"" of type '" "wxFontList *""'");
22739 }
22740 arg1 = reinterpret_cast< wxFontList * >(argp1);
22741 ecode2 = SWIG_AsVal_int(obj1, &val2);
22742 if (!SWIG_IsOK(ecode2)) {
22743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontList_FindOrCreateFont" "', expected argument " "2"" of type '" "int""'");
22744 }
22745 arg2 = static_cast< int >(val2);
22746 ecode3 = SWIG_AsVal_int(obj2, &val3);
22747 if (!SWIG_IsOK(ecode3)) {
22748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontList_FindOrCreateFont" "', expected argument " "3"" of type '" "int""'");
22749 }
22750 arg3 = static_cast< int >(val3);
22751 ecode4 = SWIG_AsVal_int(obj3, &val4);
22752 if (!SWIG_IsOK(ecode4)) {
22753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontList_FindOrCreateFont" "', expected argument " "4"" of type '" "int""'");
22754 }
22755 arg4 = static_cast< int >(val4);
22756 ecode5 = SWIG_AsVal_int(obj4, &val5);
22757 if (!SWIG_IsOK(ecode5)) {
22758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FontList_FindOrCreateFont" "', expected argument " "5"" of type '" "int""'");
22759 }
22760 arg5 = static_cast< int >(val5);
22761 if (obj5) {
22762 ecode6 = SWIG_AsVal_bool(obj5, &val6);
22763 if (!SWIG_IsOK(ecode6)) {
22764 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FontList_FindOrCreateFont" "', expected argument " "6"" of type '" "bool""'");
22765 }
22766 arg6 = static_cast< bool >(val6);
22767 }
22768 if (obj6) {
22769 {
22770 arg7 = wxString_in_helper(obj6);
22771 if (arg7 == NULL) SWIG_fail;
22772 temp7 = true;
22773 }
22774 }
22775 if (obj7) {
22776 ecode8 = SWIG_AsVal_int(obj7, &val8);
22777 if (!SWIG_IsOK(ecode8)) {
22778 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FontList_FindOrCreateFont" "', expected argument " "8"" of type '" "wxFontEncoding""'");
22779 }
22780 arg8 = static_cast< wxFontEncoding >(val8);
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,arg8);
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
22789 {
22790 if (temp7)
22791 delete arg7;
22792 }
22793 return resultobj;
22794 fail:
22795 {
22796 if (temp7)
22797 delete arg7;
22798 }
22799 return NULL;
22800 }
22801
22802
22803 SWIGINTERN PyObject *_wrap_FontList_AddFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22804 PyObject *resultobj = 0;
22805 wxFontList *arg1 = (wxFontList *) 0 ;
22806 wxFont *arg2 = (wxFont *) 0 ;
22807 void *argp1 = 0 ;
22808 int res1 = 0 ;
22809 void *argp2 = 0 ;
22810 int res2 = 0 ;
22811 PyObject * obj0 = 0 ;
22812 PyObject * obj1 = 0 ;
22813 char * kwnames[] = {
22814 (char *) "self",(char *) "font", NULL
22815 };
22816
22817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) SWIG_fail;
22818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
22819 if (!SWIG_IsOK(res1)) {
22820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_AddFont" "', expected argument " "1"" of type '" "wxFontList *""'");
22821 }
22822 arg1 = reinterpret_cast< wxFontList * >(argp1);
22823 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
22824 if (!SWIG_IsOK(res2)) {
22825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_AddFont" "', expected argument " "2"" of type '" "wxFont *""'");
22826 }
22827 arg2 = reinterpret_cast< wxFont * >(argp2);
22828 {
22829 PyThreadState* __tstate = wxPyBeginAllowThreads();
22830 (arg1)->AddFont(arg2);
22831 wxPyEndAllowThreads(__tstate);
22832 if (PyErr_Occurred()) SWIG_fail;
22833 }
22834 resultobj = SWIG_Py_Void();
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_FontList_RemoveFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxFontList *arg1 = (wxFontList *) 0 ;
22844 wxFont *arg2 = (wxFont *) 0 ;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 void *argp2 = 0 ;
22848 int res2 = 0 ;
22849 PyObject * obj0 = 0 ;
22850 PyObject * obj1 = 0 ;
22851 char * kwnames[] = {
22852 (char *) "self",(char *) "font", NULL
22853 };
22854
22855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) SWIG_fail;
22856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_RemoveFont" "', expected argument " "1"" of type '" "wxFontList *""'");
22859 }
22860 arg1 = reinterpret_cast< wxFontList * >(argp1);
22861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
22862 if (!SWIG_IsOK(res2)) {
22863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_RemoveFont" "', expected argument " "2"" of type '" "wxFont *""'");
22864 }
22865 arg2 = reinterpret_cast< wxFont * >(argp2);
22866 {
22867 PyThreadState* __tstate = wxPyBeginAllowThreads();
22868 (arg1)->RemoveFont(arg2);
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 resultobj = SWIG_Py_Void();
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 SWIGINTERN PyObject *FontList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22880 PyObject *obj;
22881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22882 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontList, SWIG_NewClientData(obj));
22883 return SWIG_Py_Void();
22884 }
22885
22886 SWIGINTERN PyObject *_wrap_new_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22887 PyObject *resultobj = 0;
22888 wxColourDatabase *result = 0 ;
22889
22890 if (!SWIG_Python_UnpackTuple(args,"new_ColourDatabase",0,0,0)) SWIG_fail;
22891 {
22892 if (!wxPyCheckForApp()) SWIG_fail;
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 result = (wxColourDatabase *)new wxColourDatabase();
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_NEW | 0 );
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 SWIGINTERN PyObject *_wrap_delete_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22906 PyObject *resultobj = 0;
22907 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
22908 void *argp1 = 0 ;
22909 int res1 = 0 ;
22910 PyObject *swig_obj[1] ;
22911
22912 if (!args) SWIG_fail;
22913 swig_obj[0] = args;
22914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_DISOWN | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDatabase" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
22917 }
22918 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 delete arg1;
22922
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 resultobj = SWIG_Py_Void();
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 SWIGINTERN PyObject *_wrap_ColourDatabase_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22934 PyObject *resultobj = 0;
22935 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
22936 wxString *arg2 = 0 ;
22937 wxColour result;
22938 void *argp1 = 0 ;
22939 int res1 = 0 ;
22940 bool temp2 = false ;
22941 PyObject * obj0 = 0 ;
22942 PyObject * obj1 = 0 ;
22943 char * kwnames[] = {
22944 (char *) "self",(char *) "name", NULL
22945 };
22946
22947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) SWIG_fail;
22948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
22949 if (!SWIG_IsOK(res1)) {
22950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Find" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
22951 }
22952 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
22953 {
22954 arg2 = wxString_in_helper(obj1);
22955 if (arg2 == NULL) SWIG_fail;
22956 temp2 = true;
22957 }
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
22961 wxPyEndAllowThreads(__tstate);
22962 if (PyErr_Occurred()) SWIG_fail;
22963 }
22964 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
22965 {
22966 if (temp2)
22967 delete arg2;
22968 }
22969 return resultobj;
22970 fail:
22971 {
22972 if (temp2)
22973 delete arg2;
22974 }
22975 return NULL;
22976 }
22977
22978
22979 SWIGINTERN PyObject *_wrap_ColourDatabase_FindName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj = 0;
22981 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
22982 wxColour *arg2 = 0 ;
22983 wxString result;
22984 void *argp1 = 0 ;
22985 int res1 = 0 ;
22986 wxColour temp2 ;
22987 PyObject * obj0 = 0 ;
22988 PyObject * obj1 = 0 ;
22989 char * kwnames[] = {
22990 (char *) "self",(char *) "colour", NULL
22991 };
22992
22993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_FindName" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
22997 }
22998 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
22999 {
23000 arg2 = &temp2;
23001 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23002 }
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 {
23010 #if wxUSE_UNICODE
23011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23012 #else
23013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23014 #endif
23015 }
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 SWIGINTERN PyObject *_wrap_ColourDatabase_AddColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23023 PyObject *resultobj = 0;
23024 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23025 wxString *arg2 = 0 ;
23026 wxColour *arg3 = 0 ;
23027 void *argp1 = 0 ;
23028 int res1 = 0 ;
23029 bool temp2 = false ;
23030 wxColour temp3 ;
23031 PyObject * obj0 = 0 ;
23032 PyObject * obj1 = 0 ;
23033 PyObject * obj2 = 0 ;
23034 char * kwnames[] = {
23035 (char *) "self",(char *) "name",(char *) "colour", NULL
23036 };
23037
23038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_AddColour" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
23042 }
23043 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23044 {
23045 arg2 = wxString_in_helper(obj1);
23046 if (arg2 == NULL) SWIG_fail;
23047 temp2 = true;
23048 }
23049 {
23050 arg3 = &temp3;
23051 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
23052 }
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 resultobj = SWIG_Py_Void();
23060 {
23061 if (temp2)
23062 delete arg2;
23063 }
23064 return resultobj;
23065 fail:
23066 {
23067 if (temp2)
23068 delete arg2;
23069 }
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_ColourDatabase_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj = 0;
23076 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
23077 wxString *arg2 = 0 ;
23078 int arg3 ;
23079 int arg4 ;
23080 int arg5 ;
23081 void *argp1 = 0 ;
23082 int res1 = 0 ;
23083 bool temp2 = false ;
23084 int val3 ;
23085 int ecode3 = 0 ;
23086 int val4 ;
23087 int ecode4 = 0 ;
23088 int val5 ;
23089 int ecode5 = 0 ;
23090 PyObject * obj0 = 0 ;
23091 PyObject * obj1 = 0 ;
23092 PyObject * obj2 = 0 ;
23093 PyObject * obj3 = 0 ;
23094 PyObject * obj4 = 0 ;
23095 char * kwnames[] = {
23096 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
23097 };
23098
23099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23101 if (!SWIG_IsOK(res1)) {
23102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Append" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
23103 }
23104 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
23105 {
23106 arg2 = wxString_in_helper(obj1);
23107 if (arg2 == NULL) SWIG_fail;
23108 temp2 = true;
23109 }
23110 ecode3 = SWIG_AsVal_int(obj2, &val3);
23111 if (!SWIG_IsOK(ecode3)) {
23112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourDatabase_Append" "', expected argument " "3"" of type '" "int""'");
23113 }
23114 arg3 = static_cast< int >(val3);
23115 ecode4 = SWIG_AsVal_int(obj3, &val4);
23116 if (!SWIG_IsOK(ecode4)) {
23117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourDatabase_Append" "', expected argument " "4"" of type '" "int""'");
23118 }
23119 arg4 = static_cast< int >(val4);
23120 ecode5 = SWIG_AsVal_int(obj4, &val5);
23121 if (!SWIG_IsOK(ecode5)) {
23122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourDatabase_Append" "', expected argument " "5"" of type '" "int""'");
23123 }
23124 arg5 = static_cast< int >(val5);
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 resultobj = SWIG_Py_Void();
23132 {
23133 if (temp2)
23134 delete arg2;
23135 }
23136 return resultobj;
23137 fail:
23138 {
23139 if (temp2)
23140 delete arg2;
23141 }
23142 return NULL;
23143 }
23144
23145
23146 SWIGINTERN PyObject *ColourDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23147 PyObject *obj;
23148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23149 SWIG_TypeNewClientData(SWIGTYPE_p_wxColourDatabase, SWIG_NewClientData(obj));
23150 return SWIG_Py_Void();
23151 }
23152
23153 SWIGINTERN PyObject *ColourDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23154 return SWIG_Python_InitShadowInstance(args);
23155 }
23156
23157 SWIGINTERN PyObject *_wrap__wxPyInitTheFontList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxFontList *result = 0 ;
23160
23161 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheFontList",0,0,0)) SWIG_fail;
23162 {
23163 PyThreadState* __tstate = wxPyBeginAllowThreads();
23164 result = (wxFontList *)_wxPyInitTheFontList();
23165 wxPyEndAllowThreads(__tstate);
23166 if (PyErr_Occurred()) SWIG_fail;
23167 }
23168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontList, 0 | 0 );
23169 return resultobj;
23170 fail:
23171 return NULL;
23172 }
23173
23174
23175 SWIGINTERN PyObject *_wrap__wxPyInitThePenList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23176 PyObject *resultobj = 0;
23177 wxPenList *result = 0 ;
23178
23179 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitThePenList",0,0,0)) SWIG_fail;
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (wxPenList *)_wxPyInitThePenList();
23183 wxPyEndAllowThreads(__tstate);
23184 if (PyErr_Occurred()) SWIG_fail;
23185 }
23186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPenList, 0 | 0 );
23187 return resultobj;
23188 fail:
23189 return NULL;
23190 }
23191
23192
23193 SWIGINTERN PyObject *_wrap__wxPyInitTheBrushList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23194 PyObject *resultobj = 0;
23195 wxBrushList *result = 0 ;
23196
23197 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheBrushList",0,0,0)) SWIG_fail;
23198 {
23199 PyThreadState* __tstate = wxPyBeginAllowThreads();
23200 result = (wxBrushList *)_wxPyInitTheBrushList();
23201 wxPyEndAllowThreads(__tstate);
23202 if (PyErr_Occurred()) SWIG_fail;
23203 }
23204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrushList, 0 | 0 );
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap__wxPyInitTheColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23212 PyObject *resultobj = 0;
23213 wxColourDatabase *result = 0 ;
23214
23215 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheColourDatabase",0,0,0)) SWIG_fail;
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (wxColourDatabase *)_wxPyInitTheColourDatabase();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, 0 | 0 );
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_new_Effects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxEffects *result = 0 ;
23232
23233 if (!SWIG_Python_UnpackTuple(args,"new_Effects",0,0,0)) SWIG_fail;
23234 {
23235 PyThreadState* __tstate = wxPyBeginAllowThreads();
23236 result = (wxEffects *)new wxEffects();
23237 wxPyEndAllowThreads(__tstate);
23238 if (PyErr_Occurred()) SWIG_fail;
23239 }
23240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEffects, SWIG_POINTER_NEW | 0 );
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_Effects_GetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxEffects *arg1 = (wxEffects *) 0 ;
23250 wxColour result;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 PyObject *swig_obj[1] ;
23254
23255 if (!args) SWIG_fail;
23256 swig_obj[0] = args;
23257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetHighlightColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
23260 }
23261 arg1 = reinterpret_cast< wxEffects * >(argp1);
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = ((wxEffects const *)arg1)->GetHighlightColour();
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 SWIGINTERN PyObject *_wrap_Effects_GetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23276 PyObject *resultobj = 0;
23277 wxEffects *arg1 = (wxEffects *) 0 ;
23278 wxColour result;
23279 void *argp1 = 0 ;
23280 int res1 = 0 ;
23281 PyObject *swig_obj[1] ;
23282
23283 if (!args) SWIG_fail;
23284 swig_obj[0] = args;
23285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23286 if (!SWIG_IsOK(res1)) {
23287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetLightShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23288 }
23289 arg1 = reinterpret_cast< wxEffects * >(argp1);
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 result = ((wxEffects const *)arg1)->GetLightShadow();
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 SWIGINTERN PyObject *_wrap_Effects_GetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23304 PyObject *resultobj = 0;
23305 wxEffects *arg1 = (wxEffects *) 0 ;
23306 wxColour result;
23307 void *argp1 = 0 ;
23308 int res1 = 0 ;
23309 PyObject *swig_obj[1] ;
23310
23311 if (!args) SWIG_fail;
23312 swig_obj[0] = args;
23313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23314 if (!SWIG_IsOK(res1)) {
23315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetFaceColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
23316 }
23317 arg1 = reinterpret_cast< wxEffects * >(argp1);
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 result = ((wxEffects const *)arg1)->GetFaceColour();
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_Effects_GetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23332 PyObject *resultobj = 0;
23333 wxEffects *arg1 = (wxEffects *) 0 ;
23334 wxColour result;
23335 void *argp1 = 0 ;
23336 int res1 = 0 ;
23337 PyObject *swig_obj[1] ;
23338
23339 if (!args) SWIG_fail;
23340 swig_obj[0] = args;
23341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetMediumShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23344 }
23345 arg1 = reinterpret_cast< wxEffects * >(argp1);
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = ((wxEffects const *)arg1)->GetMediumShadow();
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_Effects_GetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23360 PyObject *resultobj = 0;
23361 wxEffects *arg1 = (wxEffects *) 0 ;
23362 wxColour result;
23363 void *argp1 = 0 ;
23364 int res1 = 0 ;
23365 PyObject *swig_obj[1] ;
23366
23367 if (!args) SWIG_fail;
23368 swig_obj[0] = args;
23369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23370 if (!SWIG_IsOK(res1)) {
23371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetDarkShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
23372 }
23373 arg1 = reinterpret_cast< wxEffects * >(argp1);
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 result = ((wxEffects const *)arg1)->GetDarkShadow();
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 SWIGINTERN PyObject *_wrap_Effects_SetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23388 PyObject *resultobj = 0;
23389 wxEffects *arg1 = (wxEffects *) 0 ;
23390 wxColour *arg2 = 0 ;
23391 void *argp1 = 0 ;
23392 int res1 = 0 ;
23393 wxColour temp2 ;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 char * kwnames[] = {
23397 (char *) "self",(char *) "c", NULL
23398 };
23399
23400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
23401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23402 if (!SWIG_IsOK(res1)) {
23403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetHighlightColour" "', expected argument " "1"" of type '" "wxEffects *""'");
23404 }
23405 arg1 = reinterpret_cast< wxEffects * >(argp1);
23406 {
23407 arg2 = &temp2;
23408 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23409 }
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 (arg1)->SetHighlightColour((wxColour const &)*arg2);
23413 wxPyEndAllowThreads(__tstate);
23414 if (PyErr_Occurred()) SWIG_fail;
23415 }
23416 resultobj = SWIG_Py_Void();
23417 return resultobj;
23418 fail:
23419 return NULL;
23420 }
23421
23422
23423 SWIGINTERN PyObject *_wrap_Effects_SetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23424 PyObject *resultobj = 0;
23425 wxEffects *arg1 = (wxEffects *) 0 ;
23426 wxColour *arg2 = 0 ;
23427 void *argp1 = 0 ;
23428 int res1 = 0 ;
23429 wxColour temp2 ;
23430 PyObject * obj0 = 0 ;
23431 PyObject * obj1 = 0 ;
23432 char * kwnames[] = {
23433 (char *) "self",(char *) "c", NULL
23434 };
23435
23436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetLightShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23440 }
23441 arg1 = reinterpret_cast< wxEffects * >(argp1);
23442 {
23443 arg2 = &temp2;
23444 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23445 }
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 (arg1)->SetLightShadow((wxColour const &)*arg2);
23449 wxPyEndAllowThreads(__tstate);
23450 if (PyErr_Occurred()) SWIG_fail;
23451 }
23452 resultobj = SWIG_Py_Void();
23453 return resultobj;
23454 fail:
23455 return NULL;
23456 }
23457
23458
23459 SWIGINTERN PyObject *_wrap_Effects_SetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23460 PyObject *resultobj = 0;
23461 wxEffects *arg1 = (wxEffects *) 0 ;
23462 wxColour *arg2 = 0 ;
23463 void *argp1 = 0 ;
23464 int res1 = 0 ;
23465 wxColour temp2 ;
23466 PyObject * obj0 = 0 ;
23467 PyObject * obj1 = 0 ;
23468 char * kwnames[] = {
23469 (char *) "self",(char *) "c", NULL
23470 };
23471
23472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) SWIG_fail;
23473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23474 if (!SWIG_IsOK(res1)) {
23475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetFaceColour" "', expected argument " "1"" of type '" "wxEffects *""'");
23476 }
23477 arg1 = reinterpret_cast< wxEffects * >(argp1);
23478 {
23479 arg2 = &temp2;
23480 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 (arg1)->SetFaceColour((wxColour const &)*arg2);
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 resultobj = SWIG_Py_Void();
23489 return resultobj;
23490 fail:
23491 return NULL;
23492 }
23493
23494
23495 SWIGINTERN PyObject *_wrap_Effects_SetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23496 PyObject *resultobj = 0;
23497 wxEffects *arg1 = (wxEffects *) 0 ;
23498 wxColour *arg2 = 0 ;
23499 void *argp1 = 0 ;
23500 int res1 = 0 ;
23501 wxColour temp2 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char * kwnames[] = {
23505 (char *) "self",(char *) "c", NULL
23506 };
23507
23508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23510 if (!SWIG_IsOK(res1)) {
23511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetMediumShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23512 }
23513 arg1 = reinterpret_cast< wxEffects * >(argp1);
23514 {
23515 arg2 = &temp2;
23516 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23517 }
23518 {
23519 PyThreadState* __tstate = wxPyBeginAllowThreads();
23520 (arg1)->SetMediumShadow((wxColour const &)*arg2);
23521 wxPyEndAllowThreads(__tstate);
23522 if (PyErr_Occurred()) SWIG_fail;
23523 }
23524 resultobj = SWIG_Py_Void();
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 SWIGINTERN PyObject *_wrap_Effects_SetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj = 0;
23533 wxEffects *arg1 = (wxEffects *) 0 ;
23534 wxColour *arg2 = 0 ;
23535 void *argp1 = 0 ;
23536 int res1 = 0 ;
23537 wxColour temp2 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char * kwnames[] = {
23541 (char *) "self",(char *) "c", NULL
23542 };
23543
23544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) SWIG_fail;
23545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23546 if (!SWIG_IsOK(res1)) {
23547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetDarkShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
23548 }
23549 arg1 = reinterpret_cast< wxEffects * >(argp1);
23550 {
23551 arg2 = &temp2;
23552 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23553 }
23554 {
23555 PyThreadState* __tstate = wxPyBeginAllowThreads();
23556 (arg1)->SetDarkShadow((wxColour const &)*arg2);
23557 wxPyEndAllowThreads(__tstate);
23558 if (PyErr_Occurred()) SWIG_fail;
23559 }
23560 resultobj = SWIG_Py_Void();
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 SWIGINTERN PyObject *_wrap_Effects_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj = 0;
23569 wxEffects *arg1 = (wxEffects *) 0 ;
23570 wxColour *arg2 = 0 ;
23571 wxColour *arg3 = 0 ;
23572 wxColour *arg4 = 0 ;
23573 wxColour *arg5 = 0 ;
23574 wxColour *arg6 = 0 ;
23575 void *argp1 = 0 ;
23576 int res1 = 0 ;
23577 wxColour temp2 ;
23578 wxColour temp3 ;
23579 wxColour temp4 ;
23580 wxColour temp5 ;
23581 wxColour temp6 ;
23582 PyObject * obj0 = 0 ;
23583 PyObject * obj1 = 0 ;
23584 PyObject * obj2 = 0 ;
23585 PyObject * obj3 = 0 ;
23586 PyObject * obj4 = 0 ;
23587 PyObject * obj5 = 0 ;
23588 char * kwnames[] = {
23589 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
23590 };
23591
23592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23594 if (!SWIG_IsOK(res1)) {
23595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_Set" "', expected argument " "1"" of type '" "wxEffects *""'");
23596 }
23597 arg1 = reinterpret_cast< wxEffects * >(argp1);
23598 {
23599 arg2 = &temp2;
23600 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
23601 }
23602 {
23603 arg3 = &temp3;
23604 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
23605 }
23606 {
23607 arg4 = &temp4;
23608 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
23609 }
23610 {
23611 arg5 = &temp5;
23612 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
23613 }
23614 {
23615 arg6 = &temp6;
23616 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
23617 }
23618 {
23619 PyThreadState* __tstate = wxPyBeginAllowThreads();
23620 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 resultobj = SWIG_Py_Void();
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj = 0;
23633 wxEffects *arg1 = (wxEffects *) 0 ;
23634 wxDC *arg2 = 0 ;
23635 wxRect *arg3 = 0 ;
23636 int arg4 = (int) 1 ;
23637 void *argp1 = 0 ;
23638 int res1 = 0 ;
23639 void *argp2 = 0 ;
23640 int res2 = 0 ;
23641 wxRect temp3 ;
23642 int val4 ;
23643 int ecode4 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 PyObject * obj1 = 0 ;
23646 PyObject * obj2 = 0 ;
23647 PyObject * obj3 = 0 ;
23648 char * kwnames[] = {
23649 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
23650 };
23651
23652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23654 if (!SWIG_IsOK(res1)) {
23655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "1"" of type '" "wxEffects *""'");
23656 }
23657 arg1 = reinterpret_cast< wxEffects * >(argp1);
23658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
23659 if (!SWIG_IsOK(res2)) {
23660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
23661 }
23662 if (!argp2) {
23663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
23664 }
23665 arg2 = reinterpret_cast< wxDC * >(argp2);
23666 {
23667 arg3 = &temp3;
23668 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
23669 }
23670 if (obj3) {
23671 ecode4 = SWIG_AsVal_int(obj3, &val4);
23672 if (!SWIG_IsOK(ecode4)) {
23673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "4"" of type '" "int""'");
23674 }
23675 arg4 = static_cast< int >(val4);
23676 }
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 resultobj = SWIG_Py_Void();
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_Effects_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj = 0;
23692 wxEffects *arg1 = (wxEffects *) 0 ;
23693 wxRect *arg2 = 0 ;
23694 wxDC *arg3 = 0 ;
23695 wxBitmap *arg4 = 0 ;
23696 bool result;
23697 void *argp1 = 0 ;
23698 int res1 = 0 ;
23699 wxRect temp2 ;
23700 void *argp3 = 0 ;
23701 int res3 = 0 ;
23702 void *argp4 = 0 ;
23703 int res4 = 0 ;
23704 PyObject * obj0 = 0 ;
23705 PyObject * obj1 = 0 ;
23706 PyObject * obj2 = 0 ;
23707 PyObject * obj3 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_TileBitmap" "', expected argument " "1"" of type '" "wxEffects *""'");
23716 }
23717 arg1 = reinterpret_cast< wxEffects * >(argp1);
23718 {
23719 arg2 = &temp2;
23720 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23721 }
23722 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
23723 if (!SWIG_IsOK(res3)) {
23724 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
23725 }
23726 if (!argp3) {
23727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
23728 }
23729 arg3 = reinterpret_cast< wxDC * >(argp3);
23730 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 );
23731 if (!SWIG_IsOK(res4)) {
23732 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
23733 }
23734 if (!argp4) {
23735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
23736 }
23737 arg4 = reinterpret_cast< wxBitmap * >(argp4);
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
23741 wxPyEndAllowThreads(__tstate);
23742 if (PyErr_Occurred()) SWIG_fail;
23743 }
23744 {
23745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23746 }
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 SWIGINTERN PyObject *Effects_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23754 PyObject *obj;
23755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23756 SWIG_TypeNewClientData(SWIGTYPE_p_wxEffects, SWIG_NewClientData(obj));
23757 return SWIG_Py_Void();
23758 }
23759
23760 SWIGINTERN PyObject *Effects_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 return SWIG_Python_InitShadowInstance(args);
23762 }
23763
23764 SWIGINTERN PyObject *_wrap_new_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj = 0;
23766 int arg1 ;
23767 int arg2 ;
23768 bool arg3 ;
23769 wxSplitterRenderParams *result = 0 ;
23770 int val1 ;
23771 int ecode1 = 0 ;
23772 int val2 ;
23773 int ecode2 = 0 ;
23774 bool val3 ;
23775 int ecode3 = 0 ;
23776 PyObject * obj0 = 0 ;
23777 PyObject * obj1 = 0 ;
23778 PyObject * obj2 = 0 ;
23779 char * kwnames[] = {
23780 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
23781 };
23782
23783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23784 ecode1 = SWIG_AsVal_int(obj0, &val1);
23785 if (!SWIG_IsOK(ecode1)) {
23786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplitterRenderParams" "', expected argument " "1"" of type '" "int""'");
23787 }
23788 arg1 = static_cast< int >(val1);
23789 ecode2 = SWIG_AsVal_int(obj1, &val2);
23790 if (!SWIG_IsOK(ecode2)) {
23791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SplitterRenderParams" "', expected argument " "2"" of type '" "int""'");
23792 }
23793 arg2 = static_cast< int >(val2);
23794 ecode3 = SWIG_AsVal_bool(obj2, &val3);
23795 if (!SWIG_IsOK(ecode3)) {
23796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SplitterRenderParams" "', expected argument " "3"" of type '" "bool""'");
23797 }
23798 arg3 = static_cast< bool >(val3);
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_NEW | 0 );
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_delete_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *resultobj = 0;
23814 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
23815 void *argp1 = 0 ;
23816 int res1 = 0 ;
23817 PyObject *swig_obj[1] ;
23818
23819 if (!args) SWIG_fail;
23820 swig_obj[0] = args;
23821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_DISOWN | 0 );
23822 if (!SWIG_IsOK(res1)) {
23823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplitterRenderParams" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
23824 }
23825 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 delete arg1;
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_Py_Void();
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 SWIGINTERN PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 PyObject *resultobj = 0;
23842 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
23843 int result;
23844 void *argp1 = 0 ;
23845 int res1 = 0 ;
23846 PyObject *swig_obj[1] ;
23847
23848 if (!args) SWIG_fail;
23849 swig_obj[0] = args;
23850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
23851 if (!SWIG_IsOK(res1)) {
23852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_widthSash_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
23853 }
23854 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
23855 result = (int)(int) ((arg1)->widthSash);
23856 resultobj = SWIG_From_int(static_cast< int >(result));
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 SWIGINTERN PyObject *_wrap_SplitterRenderParams_border_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23864 PyObject *resultobj = 0;
23865 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
23866 int result;
23867 void *argp1 = 0 ;
23868 int res1 = 0 ;
23869 PyObject *swig_obj[1] ;
23870
23871 if (!args) SWIG_fail;
23872 swig_obj[0] = args;
23873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
23874 if (!SWIG_IsOK(res1)) {
23875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_border_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
23876 }
23877 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
23878 result = (int)(int) ((arg1)->border);
23879 resultobj = SWIG_From_int(static_cast< int >(result));
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 SWIGINTERN PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23887 PyObject *resultobj = 0;
23888 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
23889 bool result;
23890 void *argp1 = 0 ;
23891 int res1 = 0 ;
23892 PyObject *swig_obj[1] ;
23893
23894 if (!args) SWIG_fail;
23895 swig_obj[0] = args;
23896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
23897 if (!SWIG_IsOK(res1)) {
23898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_isHotSensitive_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
23899 }
23900 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
23901 result = (bool)(bool) ((arg1)->isHotSensitive);
23902 resultobj = SWIG_From_bool(static_cast< bool >(result));
23903 return resultobj;
23904 fail:
23905 return NULL;
23906 }
23907
23908
23909 SWIGINTERN PyObject *SplitterRenderParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23910 PyObject *obj;
23911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23912 SWIG_TypeNewClientData(SWIGTYPE_p_wxSplitterRenderParams, SWIG_NewClientData(obj));
23913 return SWIG_Py_Void();
23914 }
23915
23916 SWIGINTERN PyObject *SplitterRenderParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23917 return SWIG_Python_InitShadowInstance(args);
23918 }
23919
23920 SWIGINTERN PyObject *_wrap_new_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23921 PyObject *resultobj = 0;
23922 int arg1 ;
23923 int arg2 ;
23924 wxRendererVersion *result = 0 ;
23925 int val1 ;
23926 int ecode1 = 0 ;
23927 int val2 ;
23928 int ecode2 = 0 ;
23929 PyObject * obj0 = 0 ;
23930 PyObject * obj1 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "version_",(char *) "age_", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) SWIG_fail;
23936 ecode1 = SWIG_AsVal_int(obj0, &val1);
23937 if (!SWIG_IsOK(ecode1)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RendererVersion" "', expected argument " "1"" of type '" "int""'");
23939 }
23940 arg1 = static_cast< int >(val1);
23941 ecode2 = SWIG_AsVal_int(obj1, &val2);
23942 if (!SWIG_IsOK(ecode2)) {
23943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RendererVersion" "', expected argument " "2"" of type '" "int""'");
23944 }
23945 arg2 = static_cast< int >(val2);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_NEW | 0 );
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 SWIGINTERN PyObject *_wrap_delete_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 PyObject *resultobj = 0;
23961 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
23962 void *argp1 = 0 ;
23963 int res1 = 0 ;
23964 PyObject *swig_obj[1] ;
23965
23966 if (!args) SWIG_fail;
23967 swig_obj[0] = args;
23968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_DISOWN | 0 );
23969 if (!SWIG_IsOK(res1)) {
23970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RendererVersion" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
23971 }
23972 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
23973 {
23974 PyThreadState* __tstate = wxPyBeginAllowThreads();
23975 delete arg1;
23976
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 resultobj = SWIG_Py_Void();
23981 return resultobj;
23982 fail:
23983 return NULL;
23984 }
23985
23986
23987 SWIGINTERN PyObject *_wrap_RendererVersion_IsCompatible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23988 PyObject *resultobj = 0;
23989 wxRendererVersion *arg1 = 0 ;
23990 bool result;
23991 void *argp1 = 0 ;
23992 int res1 = 0 ;
23993 PyObject * obj0 = 0 ;
23994 char * kwnames[] = {
23995 (char *) "ver", NULL
23996 };
23997
23998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) SWIG_fail;
23999 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRendererVersion, 0 | 0);
24000 if (!SWIG_IsOK(res1)) {
24001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
24002 }
24003 if (!argp1) {
24004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
24005 }
24006 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 SWIGINTERN PyObject *_wrap_RendererVersion_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24023 PyObject *resultobj = 0;
24024 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
24025 int result;
24026 void *argp1 = 0 ;
24027 int res1 = 0 ;
24028 PyObject *swig_obj[1] ;
24029
24030 if (!args) SWIG_fail;
24031 swig_obj[0] = args;
24032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
24033 if (!SWIG_IsOK(res1)) {
24034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_version_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
24035 }
24036 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24037 result = (int)(int) ((arg1)->version);
24038 resultobj = SWIG_From_int(static_cast< int >(result));
24039 return resultobj;
24040 fail:
24041 return NULL;
24042 }
24043
24044
24045 SWIGINTERN PyObject *_wrap_RendererVersion_age_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24046 PyObject *resultobj = 0;
24047 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
24048 int result;
24049 void *argp1 = 0 ;
24050 int res1 = 0 ;
24051 PyObject *swig_obj[1] ;
24052
24053 if (!args) SWIG_fail;
24054 swig_obj[0] = args;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_age_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
24058 }
24059 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
24060 result = (int)(int) ((arg1)->age);
24061 resultobj = SWIG_From_int(static_cast< int >(result));
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 SWIGINTERN PyObject *RendererVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24069 PyObject *obj;
24070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24071 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererVersion, SWIG_NewClientData(obj));
24072 return SWIG_Py_Void();
24073 }
24074
24075 SWIGINTERN PyObject *RendererVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24076 return SWIG_Python_InitShadowInstance(args);
24077 }
24078
24079 SWIGINTERN PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24080 PyObject *resultobj = 0;
24081 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24082 wxWindow *arg2 = (wxWindow *) 0 ;
24083 wxDC *arg3 = 0 ;
24084 wxRect *arg4 = 0 ;
24085 int arg5 = (int) 0 ;
24086 void *argp1 = 0 ;
24087 int res1 = 0 ;
24088 void *argp2 = 0 ;
24089 int res2 = 0 ;
24090 void *argp3 = 0 ;
24091 int res3 = 0 ;
24092 wxRect temp4 ;
24093 int val5 ;
24094 int ecode5 = 0 ;
24095 PyObject * obj0 = 0 ;
24096 PyObject * obj1 = 0 ;
24097 PyObject * obj2 = 0 ;
24098 PyObject * obj3 = 0 ;
24099 PyObject * obj4 = 0 ;
24100 char * kwnames[] = {
24101 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24102 };
24103
24104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24108 }
24109 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24111 if (!SWIG_IsOK(res2)) {
24112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24113 }
24114 arg2 = reinterpret_cast< wxWindow * >(argp2);
24115 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24116 if (!SWIG_IsOK(res3)) {
24117 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
24118 }
24119 if (!argp3) {
24120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
24121 }
24122 arg3 = reinterpret_cast< wxDC * >(argp3);
24123 {
24124 arg4 = &temp4;
24125 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24126 }
24127 if (obj4) {
24128 ecode5 = SWIG_AsVal_int(obj4, &val5);
24129 if (!SWIG_IsOK(ecode5)) {
24130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "5"" of type '" "int""'");
24131 }
24132 arg5 = static_cast< int >(val5);
24133 }
24134 {
24135 PyThreadState* __tstate = wxPyBeginAllowThreads();
24136 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 resultobj = SWIG_Py_Void();
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 SWIGINTERN PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj = 0;
24149 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24150 wxWindow *arg2 = (wxWindow *) 0 ;
24151 wxDC *arg3 = 0 ;
24152 wxRect *arg4 = 0 ;
24153 int arg5 = (int) 0 ;
24154 void *argp1 = 0 ;
24155 int res1 = 0 ;
24156 void *argp2 = 0 ;
24157 int res2 = 0 ;
24158 void *argp3 = 0 ;
24159 int res3 = 0 ;
24160 wxRect temp4 ;
24161 int val5 ;
24162 int ecode5 = 0 ;
24163 PyObject * obj0 = 0 ;
24164 PyObject * obj1 = 0 ;
24165 PyObject * obj2 = 0 ;
24166 PyObject * obj3 = 0 ;
24167 PyObject * obj4 = 0 ;
24168 char * kwnames[] = {
24169 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24170 };
24171
24172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24174 if (!SWIG_IsOK(res1)) {
24175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24176 }
24177 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24179 if (!SWIG_IsOK(res2)) {
24180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24181 }
24182 arg2 = reinterpret_cast< wxWindow * >(argp2);
24183 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24184 if (!SWIG_IsOK(res3)) {
24185 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
24186 }
24187 if (!argp3) {
24188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
24189 }
24190 arg3 = reinterpret_cast< wxDC * >(argp3);
24191 {
24192 arg4 = &temp4;
24193 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24194 }
24195 if (obj4) {
24196 ecode5 = SWIG_AsVal_int(obj4, &val5);
24197 if (!SWIG_IsOK(ecode5)) {
24198 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "5"" of type '" "int""'");
24199 }
24200 arg5 = static_cast< int >(val5);
24201 }
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_Py_Void();
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj = 0;
24217 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24218 wxWindow *arg2 = (wxWindow *) 0 ;
24219 wxDC *arg3 = 0 ;
24220 wxRect *arg4 = 0 ;
24221 int arg5 = (int) 0 ;
24222 void *argp1 = 0 ;
24223 int res1 = 0 ;
24224 void *argp2 = 0 ;
24225 int res2 = 0 ;
24226 void *argp3 = 0 ;
24227 int res3 = 0 ;
24228 wxRect temp4 ;
24229 int val5 ;
24230 int ecode5 = 0 ;
24231 PyObject * obj0 = 0 ;
24232 PyObject * obj1 = 0 ;
24233 PyObject * obj2 = 0 ;
24234 PyObject * obj3 = 0 ;
24235 PyObject * obj4 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24244 }
24245 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24247 if (!SWIG_IsOK(res2)) {
24248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "2"" of type '" "wxWindow *""'");
24249 }
24250 arg2 = reinterpret_cast< wxWindow * >(argp2);
24251 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24252 if (!SWIG_IsOK(res3)) {
24253 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
24254 }
24255 if (!argp3) {
24256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
24257 }
24258 arg3 = reinterpret_cast< wxDC * >(argp3);
24259 {
24260 arg4 = &temp4;
24261 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24262 }
24263 if (obj4) {
24264 ecode5 = SWIG_AsVal_int(obj4, &val5);
24265 if (!SWIG_IsOK(ecode5)) {
24266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "5"" of type '" "int""'");
24267 }
24268 arg5 = static_cast< int >(val5);
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 resultobj = SWIG_Py_Void();
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24284 PyObject *resultobj = 0;
24285 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24286 wxWindow *arg2 = (wxWindow *) 0 ;
24287 wxDC *arg3 = 0 ;
24288 wxSize *arg4 = 0 ;
24289 int arg5 ;
24290 wxOrientation arg6 ;
24291 int arg7 = (int) 0 ;
24292 void *argp1 = 0 ;
24293 int res1 = 0 ;
24294 void *argp2 = 0 ;
24295 int res2 = 0 ;
24296 void *argp3 = 0 ;
24297 int res3 = 0 ;
24298 wxSize temp4 ;
24299 int val5 ;
24300 int ecode5 = 0 ;
24301 int val6 ;
24302 int ecode6 = 0 ;
24303 int val7 ;
24304 int ecode7 = 0 ;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 PyObject * obj2 = 0 ;
24308 PyObject * obj3 = 0 ;
24309 PyObject * obj4 = 0 ;
24310 PyObject * obj5 = 0 ;
24311 PyObject * obj6 = 0 ;
24312 char * kwnames[] = {
24313 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
24314 };
24315
24316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24318 if (!SWIG_IsOK(res1)) {
24319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24320 }
24321 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24323 if (!SWIG_IsOK(res2)) {
24324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "2"" of type '" "wxWindow *""'");
24325 }
24326 arg2 = reinterpret_cast< wxWindow * >(argp2);
24327 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24328 if (!SWIG_IsOK(res3)) {
24329 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
24330 }
24331 if (!argp3) {
24332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
24333 }
24334 arg3 = reinterpret_cast< wxDC * >(argp3);
24335 {
24336 arg4 = &temp4;
24337 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24338 }
24339 ecode5 = SWIG_AsVal_int(obj4, &val5);
24340 if (!SWIG_IsOK(ecode5)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "5"" of type '" "int""'");
24342 }
24343 arg5 = static_cast< int >(val5);
24344 ecode6 = SWIG_AsVal_int(obj5, &val6);
24345 if (!SWIG_IsOK(ecode6)) {
24346 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "6"" of type '" "wxOrientation""'");
24347 }
24348 arg6 = static_cast< wxOrientation >(val6);
24349 if (obj6) {
24350 ecode7 = SWIG_AsVal_int(obj6, &val7);
24351 if (!SWIG_IsOK(ecode7)) {
24352 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "7"" of type '" "int""'");
24353 }
24354 arg7 = static_cast< int >(val7);
24355 }
24356 {
24357 PyThreadState* __tstate = wxPyBeginAllowThreads();
24358 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,arg6,arg7);
24359 wxPyEndAllowThreads(__tstate);
24360 if (PyErr_Occurred()) SWIG_fail;
24361 }
24362 resultobj = SWIG_Py_Void();
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24370 PyObject *resultobj = 0;
24371 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24372 wxWindow *arg2 = (wxWindow *) 0 ;
24373 wxDC *arg3 = 0 ;
24374 wxRect *arg4 = 0 ;
24375 int arg5 = (int) 0 ;
24376 void *argp1 = 0 ;
24377 int res1 = 0 ;
24378 void *argp2 = 0 ;
24379 int res2 = 0 ;
24380 void *argp3 = 0 ;
24381 int res3 = 0 ;
24382 wxRect temp4 ;
24383 int val5 ;
24384 int ecode5 = 0 ;
24385 PyObject * obj0 = 0 ;
24386 PyObject * obj1 = 0 ;
24387 PyObject * obj2 = 0 ;
24388 PyObject * obj3 = 0 ;
24389 PyObject * obj4 = 0 ;
24390 char * kwnames[] = {
24391 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24392 };
24393
24394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24396 if (!SWIG_IsOK(res1)) {
24397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24398 }
24399 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24401 if (!SWIG_IsOK(res2)) {
24402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24403 }
24404 arg2 = reinterpret_cast< wxWindow * >(argp2);
24405 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24406 if (!SWIG_IsOK(res3)) {
24407 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
24408 }
24409 if (!argp3) {
24410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
24411 }
24412 arg3 = reinterpret_cast< wxDC * >(argp3);
24413 {
24414 arg4 = &temp4;
24415 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24416 }
24417 if (obj4) {
24418 ecode5 = SWIG_AsVal_int(obj4, &val5);
24419 if (!SWIG_IsOK(ecode5)) {
24420 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "5"" of type '" "int""'");
24421 }
24422 arg5 = static_cast< int >(val5);
24423 }
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24427 wxPyEndAllowThreads(__tstate);
24428 if (PyErr_Occurred()) SWIG_fail;
24429 }
24430 resultobj = SWIG_Py_Void();
24431 return resultobj;
24432 fail:
24433 return NULL;
24434 }
24435
24436
24437 SWIGINTERN PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24438 PyObject *resultobj = 0;
24439 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24440 wxWindow *arg2 = (wxWindow *) 0 ;
24441 wxDC *arg3 = 0 ;
24442 wxRect *arg4 = 0 ;
24443 int arg5 = (int) 0 ;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 void *argp2 = 0 ;
24447 int res2 = 0 ;
24448 void *argp3 = 0 ;
24449 int res3 = 0 ;
24450 wxRect temp4 ;
24451 int val5 ;
24452 int ecode5 = 0 ;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 PyObject * obj2 = 0 ;
24456 PyObject * obj3 = 0 ;
24457 PyObject * obj4 = 0 ;
24458 char * kwnames[] = {
24459 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24460 };
24461
24462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24464 if (!SWIG_IsOK(res1)) {
24465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24466 }
24467 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24469 if (!SWIG_IsOK(res2)) {
24470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "2"" of type '" "wxWindow *""'");
24471 }
24472 arg2 = reinterpret_cast< wxWindow * >(argp2);
24473 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24474 if (!SWIG_IsOK(res3)) {
24475 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
24476 }
24477 if (!argp3) {
24478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
24479 }
24480 arg3 = reinterpret_cast< wxDC * >(argp3);
24481 {
24482 arg4 = &temp4;
24483 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24484 }
24485 if (obj4) {
24486 ecode5 = SWIG_AsVal_int(obj4, &val5);
24487 if (!SWIG_IsOK(ecode5)) {
24488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "5"" of type '" "int""'");
24489 }
24490 arg5 = static_cast< int >(val5);
24491 }
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_Py_Void();
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 SWIGINTERN PyObject *_wrap_RendererNative_DrawCheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj = 0;
24507 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24508 wxWindow *arg2 = (wxWindow *) 0 ;
24509 wxDC *arg3 = 0 ;
24510 wxRect *arg4 = 0 ;
24511 int arg5 = (int) 0 ;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 void *argp2 = 0 ;
24515 int res2 = 0 ;
24516 void *argp3 = 0 ;
24517 int res3 = 0 ;
24518 wxRect temp4 ;
24519 int val5 ;
24520 int ecode5 = 0 ;
24521 PyObject * obj0 = 0 ;
24522 PyObject * obj1 = 0 ;
24523 PyObject * obj2 = 0 ;
24524 PyObject * obj3 = 0 ;
24525 PyObject * obj4 = 0 ;
24526 char * kwnames[] = {
24527 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24528 };
24529
24530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawCheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24532 if (!SWIG_IsOK(res1)) {
24533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24534 }
24535 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24537 if (!SWIG_IsOK(res2)) {
24538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "2"" of type '" "wxWindow *""'");
24539 }
24540 arg2 = reinterpret_cast< wxWindow * >(argp2);
24541 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24542 if (!SWIG_IsOK(res3)) {
24543 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
24544 }
24545 if (!argp3) {
24546 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
24547 }
24548 arg3 = reinterpret_cast< wxDC * >(argp3);
24549 {
24550 arg4 = &temp4;
24551 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24552 }
24553 if (obj4) {
24554 ecode5 = SWIG_AsVal_int(obj4, &val5);
24555 if (!SWIG_IsOK(ecode5)) {
24556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "5"" of type '" "int""'");
24557 }
24558 arg5 = static_cast< int >(val5);
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 (arg1)->DrawCheckBox(arg2,*arg3,(wxRect const &)*arg4,arg5);
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 resultobj = SWIG_Py_Void();
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *_wrap_RendererNative_DrawPushButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24574 PyObject *resultobj = 0;
24575 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24576 wxWindow *arg2 = (wxWindow *) 0 ;
24577 wxDC *arg3 = 0 ;
24578 wxRect *arg4 = 0 ;
24579 int arg5 = (int) 0 ;
24580 void *argp1 = 0 ;
24581 int res1 = 0 ;
24582 void *argp2 = 0 ;
24583 int res2 = 0 ;
24584 void *argp3 = 0 ;
24585 int res3 = 0 ;
24586 wxRect temp4 ;
24587 int val5 ;
24588 int ecode5 = 0 ;
24589 PyObject * obj0 = 0 ;
24590 PyObject * obj1 = 0 ;
24591 PyObject * obj2 = 0 ;
24592 PyObject * obj3 = 0 ;
24593 PyObject * obj4 = 0 ;
24594 char * kwnames[] = {
24595 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24596 };
24597
24598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawPushButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24600 if (!SWIG_IsOK(res1)) {
24601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawPushButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24602 }
24603 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24605 if (!SWIG_IsOK(res2)) {
24606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawPushButton" "', expected argument " "2"" of type '" "wxWindow *""'");
24607 }
24608 arg2 = reinterpret_cast< wxWindow * >(argp2);
24609 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24610 if (!SWIG_IsOK(res3)) {
24611 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
24612 }
24613 if (!argp3) {
24614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
24615 }
24616 arg3 = reinterpret_cast< wxDC * >(argp3);
24617 {
24618 arg4 = &temp4;
24619 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24620 }
24621 if (obj4) {
24622 ecode5 = SWIG_AsVal_int(obj4, &val5);
24623 if (!SWIG_IsOK(ecode5)) {
24624 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawPushButton" "', expected argument " "5"" of type '" "int""'");
24625 }
24626 arg5 = static_cast< int >(val5);
24627 }
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 (arg1)->DrawPushButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 resultobj = SWIG_Py_Void();
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 SWIGINTERN PyObject *_wrap_RendererNative_DrawItemSelectionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj = 0;
24643 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24644 wxWindow *arg2 = (wxWindow *) 0 ;
24645 wxDC *arg3 = 0 ;
24646 wxRect *arg4 = 0 ;
24647 int arg5 = (int) 0 ;
24648 void *argp1 = 0 ;
24649 int res1 = 0 ;
24650 void *argp2 = 0 ;
24651 int res2 = 0 ;
24652 void *argp3 = 0 ;
24653 int res3 = 0 ;
24654 wxRect temp4 ;
24655 int val5 ;
24656 int ecode5 = 0 ;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 PyObject * obj2 = 0 ;
24660 PyObject * obj3 = 0 ;
24661 PyObject * obj4 = 0 ;
24662 char * kwnames[] = {
24663 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
24664 };
24665
24666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawItemSelectionRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24670 }
24671 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24673 if (!SWIG_IsOK(res2)) {
24674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "2"" of type '" "wxWindow *""'");
24675 }
24676 arg2 = reinterpret_cast< wxWindow * >(argp2);
24677 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24678 if (!SWIG_IsOK(res3)) {
24679 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
24680 }
24681 if (!argp3) {
24682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
24683 }
24684 arg3 = reinterpret_cast< wxDC * >(argp3);
24685 {
24686 arg4 = &temp4;
24687 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
24688 }
24689 if (obj4) {
24690 ecode5 = SWIG_AsVal_int(obj4, &val5);
24691 if (!SWIG_IsOK(ecode5)) {
24692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "5"" of type '" "int""'");
24693 }
24694 arg5 = static_cast< int >(val5);
24695 }
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 (arg1)->DrawItemSelectionRect(arg2,*arg3,(wxRect const &)*arg4,arg5);
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = SWIG_Py_Void();
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj = 0;
24711 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24712 wxWindow *arg2 = (wxWindow *) 0 ;
24713 SwigValueWrapper<wxSplitterRenderParams > result;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 void *argp2 = 0 ;
24717 int res2 = 0 ;
24718 PyObject * obj0 = 0 ;
24719 PyObject * obj1 = 0 ;
24720 char * kwnames[] = {
24721 (char *) "self",(char *) "win", NULL
24722 };
24723
24724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) SWIG_fail;
24725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24726 if (!SWIG_IsOK(res1)) {
24727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24728 }
24729 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24731 if (!SWIG_IsOK(res2)) {
24732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "2"" of type '" "wxWindow const *""'");
24733 }
24734 arg2 = reinterpret_cast< wxWindow * >(argp2);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_NewPointerObj((new wxSplitterRenderParams(static_cast< const wxSplitterRenderParams& >(result))), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_OWN | 0 );
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_RendererNative_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxRendererNative *result = 0 ;
24751
24752 if (!SWIG_Python_UnpackTuple(args,"RendererNative_Get",0,0,0)) SWIG_fail;
24753 {
24754 if (!wxPyCheckForApp()) SWIG_fail;
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 {
24757 wxRendererNative &_result_ref = wxRendererNative::Get();
24758 result = (wxRendererNative *) &_result_ref;
24759 }
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *_wrap_RendererNative_GetGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24771 PyObject *resultobj = 0;
24772 wxRendererNative *result = 0 ;
24773
24774 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetGeneric",0,0,0)) SWIG_fail;
24775 {
24776 if (!wxPyCheckForApp()) SWIG_fail;
24777 PyThreadState* __tstate = wxPyBeginAllowThreads();
24778 {
24779 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
24780 result = (wxRendererNative *) &_result_ref;
24781 }
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 SWIGINTERN PyObject *_wrap_RendererNative_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24793 PyObject *resultobj = 0;
24794 wxRendererNative *result = 0 ;
24795
24796 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetDefault",0,0,0)) SWIG_fail;
24797 {
24798 if (!wxPyCheckForApp()) SWIG_fail;
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 {
24801 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
24802 result = (wxRendererNative *) &_result_ref;
24803 }
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_RendererNative_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24817 wxRendererNative *result = 0 ;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "renderer", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) SWIG_fail;
24826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_Set" "', expected argument " "1"" of type '" "wxRendererNative *""'");
24829 }
24830 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24831 {
24832 if (!wxPyCheckForApp()) SWIG_fail;
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 result = (wxRendererNative *)wxRendererNative::Set(arg1);
24835 wxPyEndAllowThreads(__tstate);
24836 if (PyErr_Occurred()) SWIG_fail;
24837 }
24838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_RendererNative_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
24848 SwigValueWrapper<wxRendererVersion > result;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 PyObject *swig_obj[1] ;
24852
24853 if (!args) SWIG_fail;
24854 swig_obj[0] = args;
24855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetVersion" "', expected argument " "1"" of type '" "wxRendererNative const *""'");
24858 }
24859 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = ((wxRendererNative const *)arg1)->GetVersion();
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 resultobj = SWIG_NewPointerObj((new wxRendererVersion(static_cast< const wxRendererVersion& >(result))), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_OWN | 0 );
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 SWIGINTERN PyObject *RendererNative_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24874 PyObject *obj;
24875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24876 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererNative, SWIG_NewClientData(obj));
24877 return SWIG_Py_Void();
24878 }
24879
24880 SWIGINTERN PyObject *_wrap_new_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxPseudoDC *result = 0 ;
24883
24884 if (!SWIG_Python_UnpackTuple(args,"new_PseudoDC",0,0,0)) SWIG_fail;
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = (wxPseudoDC *)new wxPseudoDC();
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_NEW | 0 );
24892 return resultobj;
24893 fail:
24894 return NULL;
24895 }
24896
24897
24898 SWIGINTERN PyObject *_wrap_PseudoDC_BeginDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24899 PyObject *resultobj = 0;
24900 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
24901 void *argp1 = 0 ;
24902 int res1 = 0 ;
24903 PyObject *swig_obj[1] ;
24904
24905 if (!args) SWIG_fail;
24906 swig_obj[0] = args;
24907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
24908 if (!SWIG_IsOK(res1)) {
24909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_BeginDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
24910 }
24911 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 (arg1)->BeginDrawing();
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 resultobj = SWIG_Py_Void();
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 SWIGINTERN PyObject *_wrap_PseudoDC_EndDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 PyObject *resultobj = 0;
24927 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
24928 void *argp1 = 0 ;
24929 int res1 = 0 ;
24930 PyObject *swig_obj[1] ;
24931
24932 if (!args) SWIG_fail;
24933 swig_obj[0] = args;
24934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
24935 if (!SWIG_IsOK(res1)) {
24936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_EndDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
24937 }
24938 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 (arg1)->EndDrawing();
24942 wxPyEndAllowThreads(__tstate);
24943 if (PyErr_Occurred()) SWIG_fail;
24944 }
24945 resultobj = SWIG_Py_Void();
24946 return resultobj;
24947 fail:
24948 return NULL;
24949 }
24950
24951
24952 SWIGINTERN PyObject *_wrap_delete_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24953 PyObject *resultobj = 0;
24954 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
24955 void *argp1 = 0 ;
24956 int res1 = 0 ;
24957 PyObject *swig_obj[1] ;
24958
24959 if (!args) SWIG_fail;
24960 swig_obj[0] = args;
24961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_DISOWN | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PseudoDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
24964 }
24965 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
24966 {
24967 PyThreadState* __tstate = wxPyBeginAllowThreads();
24968 delete arg1;
24969
24970 wxPyEndAllowThreads(__tstate);
24971 if (PyErr_Occurred()) SWIG_fail;
24972 }
24973 resultobj = SWIG_Py_Void();
24974 return resultobj;
24975 fail:
24976 return NULL;
24977 }
24978
24979
24980 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24981 PyObject *resultobj = 0;
24982 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
24983 void *argp1 = 0 ;
24984 int res1 = 0 ;
24985 PyObject *swig_obj[1] ;
24986
24987 if (!args) SWIG_fail;
24988 swig_obj[0] = args;
24989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
24990 if (!SWIG_IsOK(res1)) {
24991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveAll" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
24992 }
24993 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 (arg1)->RemoveAll();
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 resultobj = SWIG_Py_Void();
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 SWIGINTERN PyObject *_wrap_PseudoDC_GetLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25008 PyObject *resultobj = 0;
25009 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25010 int result;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 PyObject *swig_obj[1] ;
25014
25015 if (!args) SWIG_fail;
25016 swig_obj[0] = args;
25017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetLen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25020 }
25021 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (int)(arg1)->GetLen();
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 resultobj = SWIG_From_int(static_cast< int >(result));
25029 return resultobj;
25030 fail:
25031 return NULL;
25032 }
25033
25034
25035 SWIGINTERN PyObject *_wrap_PseudoDC_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25036 PyObject *resultobj = 0;
25037 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25038 int arg2 ;
25039 void *argp1 = 0 ;
25040 int res1 = 0 ;
25041 int val2 ;
25042 int ecode2 = 0 ;
25043 PyObject * obj0 = 0 ;
25044 PyObject * obj1 = 0 ;
25045 char * kwnames[] = {
25046 (char *) "self",(char *) "id", NULL
25047 };
25048
25049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
25050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25053 }
25054 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25055 ecode2 = SWIG_AsVal_int(obj1, &val2);
25056 if (!SWIG_IsOK(ecode2)) {
25057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetId" "', expected argument " "2"" of type '" "int""'");
25058 }
25059 arg2 = static_cast< int >(val2);
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 (arg1)->SetId(arg2);
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 resultobj = SWIG_Py_Void();
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_PseudoDC_ClearId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj = 0;
25075 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25076 int arg2 ;
25077 void *argp1 = 0 ;
25078 int res1 = 0 ;
25079 int val2 ;
25080 int ecode2 = 0 ;
25081 PyObject * obj0 = 0 ;
25082 PyObject * obj1 = 0 ;
25083 char * kwnames[] = {
25084 (char *) "self",(char *) "id", NULL
25085 };
25086
25087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_ClearId",kwnames,&obj0,&obj1)) SWIG_fail;
25088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25089 if (!SWIG_IsOK(res1)) {
25090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_ClearId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25091 }
25092 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25093 ecode2 = SWIG_AsVal_int(obj1, &val2);
25094 if (!SWIG_IsOK(ecode2)) {
25095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_ClearId" "', expected argument " "2"" of type '" "int""'");
25096 }
25097 arg2 = static_cast< int >(val2);
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 (arg1)->ClearId(arg2);
25101 wxPyEndAllowThreads(__tstate);
25102 if (PyErr_Occurred()) SWIG_fail;
25103 }
25104 resultobj = SWIG_Py_Void();
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj = 0;
25113 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25114 int arg2 ;
25115 void *argp1 = 0 ;
25116 int res1 = 0 ;
25117 int val2 ;
25118 int ecode2 = 0 ;
25119 PyObject * obj0 = 0 ;
25120 PyObject * obj1 = 0 ;
25121 char * kwnames[] = {
25122 (char *) "self",(char *) "id", NULL
25123 };
25124
25125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_RemoveId",kwnames,&obj0,&obj1)) SWIG_fail;
25126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25127 if (!SWIG_IsOK(res1)) {
25128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25129 }
25130 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25131 ecode2 = SWIG_AsVal_int(obj1, &val2);
25132 if (!SWIG_IsOK(ecode2)) {
25133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_RemoveId" "', expected argument " "2"" of type '" "int""'");
25134 }
25135 arg2 = static_cast< int >(val2);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 (arg1)->RemoveId(arg2);
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 resultobj = SWIG_Py_Void();
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 SWIGINTERN PyObject *_wrap_PseudoDC_TranslateId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = 0;
25151 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25152 int arg2 ;
25153 int arg3 ;
25154 int arg4 ;
25155 void *argp1 = 0 ;
25156 int res1 = 0 ;
25157 int val2 ;
25158 int ecode2 = 0 ;
25159 int val3 ;
25160 int ecode3 = 0 ;
25161 int val4 ;
25162 int ecode4 = 0 ;
25163 PyObject * obj0 = 0 ;
25164 PyObject * obj1 = 0 ;
25165 PyObject * obj2 = 0 ;
25166 PyObject * obj3 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "self",(char *) "id",(char *) "dx",(char *) "dy", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_TranslateId",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25173 if (!SWIG_IsOK(res1)) {
25174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_TranslateId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25175 }
25176 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25177 ecode2 = SWIG_AsVal_int(obj1, &val2);
25178 if (!SWIG_IsOK(ecode2)) {
25179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_TranslateId" "', expected argument " "2"" of type '" "int""'");
25180 }
25181 arg2 = static_cast< int >(val2);
25182 ecode3 = SWIG_AsVal_int(obj2, &val3);
25183 if (!SWIG_IsOK(ecode3)) {
25184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_TranslateId" "', expected argument " "3"" of type '" "int""'");
25185 }
25186 arg3 = static_cast< int >(val3);
25187 ecode4 = SWIG_AsVal_int(obj3, &val4);
25188 if (!SWIG_IsOK(ecode4)) {
25189 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_TranslateId" "', expected argument " "4"" of type '" "int""'");
25190 }
25191 arg4 = static_cast< int >(val4);
25192 {
25193 PyThreadState* __tstate = wxPyBeginAllowThreads();
25194 (arg1)->TranslateId(arg2,arg3,arg4);
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 resultobj = SWIG_Py_Void();
25199 return resultobj;
25200 fail:
25201 return NULL;
25202 }
25203
25204
25205 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIdToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25206 PyObject *resultobj = 0;
25207 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25208 int arg2 ;
25209 wxDC *arg3 = (wxDC *) 0 ;
25210 void *argp1 = 0 ;
25211 int res1 = 0 ;
25212 int val2 ;
25213 int ecode2 = 0 ;
25214 void *argp3 = 0 ;
25215 int res3 = 0 ;
25216 PyObject * obj0 = 0 ;
25217 PyObject * obj1 = 0 ;
25218 PyObject * obj2 = 0 ;
25219 char * kwnames[] = {
25220 (char *) "self",(char *) "id",(char *) "dc", NULL
25221 };
25222
25223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIdToDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25225 if (!SWIG_IsOK(res1)) {
25226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25227 }
25228 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25229 ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "2"" of type '" "int""'");
25232 }
25233 arg2 = static_cast< int >(val2);
25234 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxDC, 0 | 0 );
25235 if (!SWIG_IsOK(res3)) {
25236 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "3"" of type '" "wxDC *""'");
25237 }
25238 arg3 = reinterpret_cast< wxDC * >(argp3);
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 (arg1)->DrawIdToDC(arg2,arg3);
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 resultobj = SWIG_Py_Void();
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 SWIGINTERN PyObject *_wrap_PseudoDC_SetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj = 0;
25254 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25255 int arg2 ;
25256 wxRect *arg3 = 0 ;
25257 void *argp1 = 0 ;
25258 int res1 = 0 ;
25259 int val2 ;
25260 int ecode2 = 0 ;
25261 wxRect temp3 ;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 PyObject * obj2 = 0 ;
25265 char * kwnames[] = {
25266 (char *) "self",(char *) "id",(char *) "rect", NULL
25267 };
25268
25269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_SetIdBounds",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25271 if (!SWIG_IsOK(res1)) {
25272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25273 }
25274 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25275 ecode2 = SWIG_AsVal_int(obj1, &val2);
25276 if (!SWIG_IsOK(ecode2)) {
25277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "2"" of type '" "int""'");
25278 }
25279 arg2 = static_cast< int >(val2);
25280 {
25281 arg3 = &temp3;
25282 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
25283 }
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 (arg1)->SetIdBounds(arg2,*arg3);
25287 wxPyEndAllowThreads(__tstate);
25288 if (PyErr_Occurred()) SWIG_fail;
25289 }
25290 resultobj = SWIG_Py_Void();
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_PseudoDC_GetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = 0;
25299 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25300 int arg2 ;
25301 wxRect result;
25302 void *argp1 = 0 ;
25303 int res1 = 0 ;
25304 int val2 ;
25305 int ecode2 = 0 ;
25306 PyObject * obj0 = 0 ;
25307 PyObject * obj1 = 0 ;
25308 char * kwnames[] = {
25309 (char *) "self",(char *) "id", NULL
25310 };
25311
25312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_GetIdBounds",kwnames,&obj0,&obj1)) SWIG_fail;
25313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25316 }
25317 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25318 ecode2 = SWIG_AsVal_int(obj1, &val2);
25319 if (!SWIG_IsOK(ecode2)) {
25320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "2"" of type '" "int""'");
25321 }
25322 arg2 = static_cast< int >(val2);
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = wxPseudoDC_GetIdBounds(arg1,arg2);
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj = 0;
25338 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25339 wxDC *arg2 = (wxDC *) 0 ;
25340 wxRect *arg3 = 0 ;
25341 void *argp1 = 0 ;
25342 int res1 = 0 ;
25343 void *argp2 = 0 ;
25344 int res2 = 0 ;
25345 wxRect temp3 ;
25346 PyObject * obj0 = 0 ;
25347 PyObject * obj1 = 0 ;
25348 PyObject * obj2 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "self",(char *) "dc",(char *) "rect", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClipped",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25355 if (!SWIG_IsOK(res1)) {
25356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25357 }
25358 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
25360 if (!SWIG_IsOK(res2)) {
25361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "2"" of type '" "wxDC *""'");
25362 }
25363 arg2 = reinterpret_cast< wxDC * >(argp2);
25364 {
25365 arg3 = &temp3;
25366 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 (arg1)->DrawToDCClipped(arg2,(wxRect const &)*arg3);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_Py_Void();
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClippedRgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = 0;
25383 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25384 wxDC *arg2 = (wxDC *) 0 ;
25385 wxRegion *arg3 = 0 ;
25386 void *argp1 = 0 ;
25387 int res1 = 0 ;
25388 void *argp2 = 0 ;
25389 int res2 = 0 ;
25390 void *argp3 = 0 ;
25391 int res3 = 0 ;
25392 PyObject * obj0 = 0 ;
25393 PyObject * obj1 = 0 ;
25394 PyObject * obj2 = 0 ;
25395 char * kwnames[] = {
25396 (char *) "self",(char *) "dc",(char *) "region", NULL
25397 };
25398
25399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClippedRgn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25401 if (!SWIG_IsOK(res1)) {
25402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25403 }
25404 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
25406 if (!SWIG_IsOK(res2)) {
25407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "2"" of type '" "wxDC *""'");
25408 }
25409 arg2 = reinterpret_cast< wxDC * >(argp2);
25410 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRegion, 0 | 0);
25411 if (!SWIG_IsOK(res3)) {
25412 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
25413 }
25414 if (!argp3) {
25415 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
25416 }
25417 arg3 = reinterpret_cast< wxRegion * >(argp3);
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 (arg1)->DrawToDCClippedRgn(arg2,(wxRegion const &)*arg3);
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 resultobj = SWIG_Py_Void();
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25432 PyObject *resultobj = 0;
25433 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25434 wxDC *arg2 = (wxDC *) 0 ;
25435 void *argp1 = 0 ;
25436 int res1 = 0 ;
25437 void *argp2 = 0 ;
25438 int res2 = 0 ;
25439 PyObject * obj0 = 0 ;
25440 PyObject * obj1 = 0 ;
25441 char * kwnames[] = {
25442 (char *) "self",(char *) "dc", NULL
25443 };
25444
25445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawToDC",kwnames,&obj0,&obj1)) SWIG_fail;
25446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25447 if (!SWIG_IsOK(res1)) {
25448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25449 }
25450 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
25452 if (!SWIG_IsOK(res2)) {
25453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDC" "', expected argument " "2"" of type '" "wxDC *""'");
25454 }
25455 arg2 = reinterpret_cast< wxDC * >(argp2);
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 (arg1)->DrawToDC(arg2);
25459 wxPyEndAllowThreads(__tstate);
25460 if (PyErr_Occurred()) SWIG_fail;
25461 }
25462 resultobj = SWIG_Py_Void();
25463 return resultobj;
25464 fail:
25465 return NULL;
25466 }
25467
25468
25469 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25470 PyObject *resultobj = 0;
25471 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25472 int arg2 ;
25473 int arg3 ;
25474 wxColour *arg4 = 0 ;
25475 int arg5 = (int) wxFLOOD_SURFACE ;
25476 void *argp1 = 0 ;
25477 int res1 = 0 ;
25478 int val2 ;
25479 int ecode2 = 0 ;
25480 int val3 ;
25481 int ecode3 = 0 ;
25482 wxColour temp4 ;
25483 int val5 ;
25484 int ecode5 = 0 ;
25485 PyObject * obj0 = 0 ;
25486 PyObject * obj1 = 0 ;
25487 PyObject * obj2 = 0 ;
25488 PyObject * obj3 = 0 ;
25489 PyObject * obj4 = 0 ;
25490 char * kwnames[] = {
25491 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
25492 };
25493
25494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25496 if (!SWIG_IsOK(res1)) {
25497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFill" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25498 }
25499 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25500 ecode2 = SWIG_AsVal_int(obj1, &val2);
25501 if (!SWIG_IsOK(ecode2)) {
25502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_FloodFill" "', expected argument " "2"" of type '" "int""'");
25503 }
25504 arg2 = static_cast< int >(val2);
25505 ecode3 = SWIG_AsVal_int(obj2, &val3);
25506 if (!SWIG_IsOK(ecode3)) {
25507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_FloodFill" "', expected argument " "3"" of type '" "int""'");
25508 }
25509 arg3 = static_cast< int >(val3);
25510 {
25511 arg4 = &temp4;
25512 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
25513 }
25514 if (obj4) {
25515 ecode5 = SWIG_AsVal_int(obj4, &val5);
25516 if (!SWIG_IsOK(ecode5)) {
25517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_FloodFill" "', expected argument " "5"" of type '" "int""'");
25518 }
25519 arg5 = static_cast< int >(val5);
25520 }
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 (arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 resultobj = SWIG_Py_Void();
25528 return resultobj;
25529 fail:
25530 return NULL;
25531 }
25532
25533
25534 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25535 PyObject *resultobj = 0;
25536 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25537 wxPoint *arg2 = 0 ;
25538 wxColour *arg3 = 0 ;
25539 int arg4 = (int) wxFLOOD_SURFACE ;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 wxPoint temp2 ;
25543 wxColour temp3 ;
25544 int val4 ;
25545 int ecode4 = 0 ;
25546 PyObject * obj0 = 0 ;
25547 PyObject * obj1 = 0 ;
25548 PyObject * obj2 = 0 ;
25549 PyObject * obj3 = 0 ;
25550 char * kwnames[] = {
25551 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
25552 };
25553
25554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25556 if (!SWIG_IsOK(res1)) {
25557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25558 }
25559 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25560 {
25561 arg2 = &temp2;
25562 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25563 }
25564 {
25565 arg3 = &temp3;
25566 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
25567 }
25568 if (obj3) {
25569 ecode4 = SWIG_AsVal_int(obj3, &val4);
25570 if (!SWIG_IsOK(ecode4)) {
25571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
25572 }
25573 arg4 = static_cast< int >(val4);
25574 }
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 (arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_Py_Void();
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25589 PyObject *resultobj = 0;
25590 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25591 int arg2 ;
25592 int arg3 ;
25593 int arg4 ;
25594 int arg5 ;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 int val2 ;
25598 int ecode2 = 0 ;
25599 int val3 ;
25600 int ecode3 = 0 ;
25601 int val4 ;
25602 int ecode4 = 0 ;
25603 int val5 ;
25604 int ecode5 = 0 ;
25605 PyObject * obj0 = 0 ;
25606 PyObject * obj1 = 0 ;
25607 PyObject * obj2 = 0 ;
25608 PyObject * obj3 = 0 ;
25609 PyObject * obj4 = 0 ;
25610 char * kwnames[] = {
25611 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
25612 };
25613
25614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLine" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25618 }
25619 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25620 ecode2 = SWIG_AsVal_int(obj1, &val2);
25621 if (!SWIG_IsOK(ecode2)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawLine" "', expected argument " "2"" of type '" "int""'");
25623 }
25624 arg2 = static_cast< int >(val2);
25625 ecode3 = SWIG_AsVal_int(obj2, &val3);
25626 if (!SWIG_IsOK(ecode3)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawLine" "', expected argument " "3"" of type '" "int""'");
25628 }
25629 arg3 = static_cast< int >(val3);
25630 ecode4 = SWIG_AsVal_int(obj3, &val4);
25631 if (!SWIG_IsOK(ecode4)) {
25632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLine" "', expected argument " "4"" of type '" "int""'");
25633 }
25634 arg4 = static_cast< int >(val4);
25635 ecode5 = SWIG_AsVal_int(obj4, &val5);
25636 if (!SWIG_IsOK(ecode5)) {
25637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLine" "', expected argument " "5"" of type '" "int""'");
25638 }
25639 arg5 = static_cast< int >(val5);
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 resultobj = SWIG_Py_Void();
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = 0;
25655 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25656 wxPoint *arg2 = 0 ;
25657 wxPoint *arg3 = 0 ;
25658 void *argp1 = 0 ;
25659 int res1 = 0 ;
25660 wxPoint temp2 ;
25661 wxPoint temp3 ;
25662 PyObject * obj0 = 0 ;
25663 PyObject * obj1 = 0 ;
25664 PyObject * obj2 = 0 ;
25665 char * kwnames[] = {
25666 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
25667 };
25668
25669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLinePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25673 }
25674 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25675 {
25676 arg2 = &temp2;
25677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25678 }
25679 {
25680 arg3 = &temp3;
25681 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25682 }
25683 {
25684 PyThreadState* __tstate = wxPyBeginAllowThreads();
25685 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
25686 wxPyEndAllowThreads(__tstate);
25687 if (PyErr_Occurred()) SWIG_fail;
25688 }
25689 resultobj = SWIG_Py_Void();
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj = 0;
25698 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25699 int arg2 ;
25700 int arg3 ;
25701 void *argp1 = 0 ;
25702 int res1 = 0 ;
25703 int val2 ;
25704 int ecode2 = 0 ;
25705 int val3 ;
25706 int ecode3 = 0 ;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 PyObject * obj2 = 0 ;
25710 char * kwnames[] = {
25711 (char *) "self",(char *) "x",(char *) "y", NULL
25712 };
25713
25714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHair" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25718 }
25719 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25720 ecode2 = SWIG_AsVal_int(obj1, &val2);
25721 if (!SWIG_IsOK(ecode2)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_CrossHair" "', expected argument " "2"" of type '" "int""'");
25723 }
25724 arg2 = static_cast< int >(val2);
25725 ecode3 = SWIG_AsVal_int(obj2, &val3);
25726 if (!SWIG_IsOK(ecode3)) {
25727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_CrossHair" "', expected argument " "3"" of type '" "int""'");
25728 }
25729 arg3 = static_cast< int >(val3);
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 (arg1)->CrossHair(arg2,arg3);
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 resultobj = SWIG_Py_Void();
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25744 PyObject *resultobj = 0;
25745 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25746 wxPoint *arg2 = 0 ;
25747 void *argp1 = 0 ;
25748 int res1 = 0 ;
25749 wxPoint temp2 ;
25750 PyObject * obj0 = 0 ;
25751 PyObject * obj1 = 0 ;
25752 char * kwnames[] = {
25753 (char *) "self",(char *) "pt", NULL
25754 };
25755
25756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
25757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25758 if (!SWIG_IsOK(res1)) {
25759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHairPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25760 }
25761 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25762 {
25763 arg2 = &temp2;
25764 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25765 }
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 (arg1)->CrossHair((wxPoint const &)*arg2);
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 resultobj = SWIG_Py_Void();
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj = 0;
25781 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25782 int arg2 ;
25783 int arg3 ;
25784 int arg4 ;
25785 int arg5 ;
25786 int arg6 ;
25787 int arg7 ;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 int val2 ;
25791 int ecode2 = 0 ;
25792 int val3 ;
25793 int ecode3 = 0 ;
25794 int val4 ;
25795 int ecode4 = 0 ;
25796 int val5 ;
25797 int ecode5 = 0 ;
25798 int val6 ;
25799 int ecode6 = 0 ;
25800 int val7 ;
25801 int ecode7 = 0 ;
25802 PyObject * obj0 = 0 ;
25803 PyObject * obj1 = 0 ;
25804 PyObject * obj2 = 0 ;
25805 PyObject * obj3 = 0 ;
25806 PyObject * obj4 = 0 ;
25807 PyObject * obj5 = 0 ;
25808 PyObject * obj6 = 0 ;
25809 char * kwnames[] = {
25810 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
25811 };
25812
25813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25817 }
25818 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25819 ecode2 = SWIG_AsVal_int(obj1, &val2);
25820 if (!SWIG_IsOK(ecode2)) {
25821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawArc" "', expected argument " "2"" of type '" "int""'");
25822 }
25823 arg2 = static_cast< int >(val2);
25824 ecode3 = SWIG_AsVal_int(obj2, &val3);
25825 if (!SWIG_IsOK(ecode3)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawArc" "', expected argument " "3"" of type '" "int""'");
25827 }
25828 arg3 = static_cast< int >(val3);
25829 ecode4 = SWIG_AsVal_int(obj3, &val4);
25830 if (!SWIG_IsOK(ecode4)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawArc" "', expected argument " "4"" of type '" "int""'");
25832 }
25833 arg4 = static_cast< int >(val4);
25834 ecode5 = SWIG_AsVal_int(obj4, &val5);
25835 if (!SWIG_IsOK(ecode5)) {
25836 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawArc" "', expected argument " "5"" of type '" "int""'");
25837 }
25838 arg5 = static_cast< int >(val5);
25839 ecode6 = SWIG_AsVal_int(obj5, &val6);
25840 if (!SWIG_IsOK(ecode6)) {
25841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawArc" "', expected argument " "6"" of type '" "int""'");
25842 }
25843 arg6 = static_cast< int >(val6);
25844 ecode7 = SWIG_AsVal_int(obj6, &val7);
25845 if (!SWIG_IsOK(ecode7)) {
25846 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawArc" "', expected argument " "7"" of type '" "int""'");
25847 }
25848 arg7 = static_cast< int >(val7);
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 resultobj = SWIG_Py_Void();
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25863 PyObject *resultobj = 0;
25864 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25865 wxPoint *arg2 = 0 ;
25866 wxPoint *arg3 = 0 ;
25867 wxPoint *arg4 = 0 ;
25868 void *argp1 = 0 ;
25869 int res1 = 0 ;
25870 wxPoint temp2 ;
25871 wxPoint temp3 ;
25872 wxPoint temp4 ;
25873 PyObject * obj0 = 0 ;
25874 PyObject * obj1 = 0 ;
25875 PyObject * obj2 = 0 ;
25876 PyObject * obj3 = 0 ;
25877 char * kwnames[] = {
25878 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
25879 };
25880
25881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25883 if (!SWIG_IsOK(res1)) {
25884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArcPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25885 }
25886 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25887 {
25888 arg2 = &temp2;
25889 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25890 }
25891 {
25892 arg3 = &temp3;
25893 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25894 }
25895 {
25896 arg4 = &temp4;
25897 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25898 }
25899 {
25900 PyThreadState* __tstate = wxPyBeginAllowThreads();
25901 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
25902 wxPyEndAllowThreads(__tstate);
25903 if (PyErr_Occurred()) SWIG_fail;
25904 }
25905 resultobj = SWIG_Py_Void();
25906 return resultobj;
25907 fail:
25908 return NULL;
25909 }
25910
25911
25912 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj = 0;
25914 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25915 int arg2 ;
25916 int arg3 ;
25917 int arg4 ;
25918 int arg5 ;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 int val2 ;
25922 int ecode2 = 0 ;
25923 int val3 ;
25924 int ecode3 = 0 ;
25925 int val4 ;
25926 int ecode4 = 0 ;
25927 int val5 ;
25928 int ecode5 = 0 ;
25929 PyObject * obj0 = 0 ;
25930 PyObject * obj1 = 0 ;
25931 PyObject * obj2 = 0 ;
25932 PyObject * obj3 = 0 ;
25933 PyObject * obj4 = 0 ;
25934 char * kwnames[] = {
25935 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
25936 };
25937
25938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25942 }
25943 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25944 ecode2 = SWIG_AsVal_int(obj1, &val2);
25945 if (!SWIG_IsOK(ecode2)) {
25946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
25947 }
25948 arg2 = static_cast< int >(val2);
25949 ecode3 = SWIG_AsVal_int(obj2, &val3);
25950 if (!SWIG_IsOK(ecode3)) {
25951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
25952 }
25953 arg3 = static_cast< int >(val3);
25954 ecode4 = SWIG_AsVal_int(obj3, &val4);
25955 if (!SWIG_IsOK(ecode4)) {
25956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
25957 }
25958 arg4 = static_cast< int >(val4);
25959 ecode5 = SWIG_AsVal_int(obj4, &val5);
25960 if (!SWIG_IsOK(ecode5)) {
25961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
25962 }
25963 arg5 = static_cast< int >(val5);
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 resultobj = SWIG_Py_Void();
25971 return resultobj;
25972 fail:
25973 return NULL;
25974 }
25975
25976
25977 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25978 PyObject *resultobj = 0;
25979 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
25980 wxRect *arg2 = 0 ;
25981 void *argp1 = 0 ;
25982 int res1 = 0 ;
25983 wxRect temp2 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 char * kwnames[] = {
25987 (char *) "self",(char *) "rect", NULL
25988 };
25989
25990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
25991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
25992 if (!SWIG_IsOK(res1)) {
25993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
25994 }
25995 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
25996 {
25997 arg2 = &temp2;
25998 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 (arg1)->DrawCheckMark((wxRect const &)*arg2);
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 resultobj = SWIG_Py_Void();
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj = 0;
26015 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26016 int arg2 ;
26017 int arg3 ;
26018 int arg4 ;
26019 int arg5 ;
26020 double arg6 ;
26021 double arg7 ;
26022 void *argp1 = 0 ;
26023 int res1 = 0 ;
26024 int val2 ;
26025 int ecode2 = 0 ;
26026 int val3 ;
26027 int ecode3 = 0 ;
26028 int val4 ;
26029 int ecode4 = 0 ;
26030 int val5 ;
26031 int ecode5 = 0 ;
26032 double val6 ;
26033 int ecode6 = 0 ;
26034 double val7 ;
26035 int ecode7 = 0 ;
26036 PyObject * obj0 = 0 ;
26037 PyObject * obj1 = 0 ;
26038 PyObject * obj2 = 0 ;
26039 PyObject * obj3 = 0 ;
26040 PyObject * obj4 = 0 ;
26041 PyObject * obj5 = 0 ;
26042 PyObject * obj6 = 0 ;
26043 char * kwnames[] = {
26044 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
26045 };
26046
26047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26049 if (!SWIG_IsOK(res1)) {
26050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26051 }
26052 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26053 ecode2 = SWIG_AsVal_int(obj1, &val2);
26054 if (!SWIG_IsOK(ecode2)) {
26055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
26056 }
26057 arg2 = static_cast< int >(val2);
26058 ecode3 = SWIG_AsVal_int(obj2, &val3);
26059 if (!SWIG_IsOK(ecode3)) {
26060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
26061 }
26062 arg3 = static_cast< int >(val3);
26063 ecode4 = SWIG_AsVal_int(obj3, &val4);
26064 if (!SWIG_IsOK(ecode4)) {
26065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
26066 }
26067 arg4 = static_cast< int >(val4);
26068 ecode5 = SWIG_AsVal_int(obj4, &val5);
26069 if (!SWIG_IsOK(ecode5)) {
26070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
26071 }
26072 arg5 = static_cast< int >(val5);
26073 ecode6 = SWIG_AsVal_double(obj5, &val6);
26074 if (!SWIG_IsOK(ecode6)) {
26075 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
26076 }
26077 arg6 = static_cast< double >(val6);
26078 ecode7 = SWIG_AsVal_double(obj6, &val7);
26079 if (!SWIG_IsOK(ecode7)) {
26080 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
26081 }
26082 arg7 = static_cast< double >(val7);
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 resultobj = SWIG_Py_Void();
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj = 0;
26098 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26099 wxPoint *arg2 = 0 ;
26100 wxSize *arg3 = 0 ;
26101 double arg4 ;
26102 double arg5 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 wxPoint temp2 ;
26106 wxSize temp3 ;
26107 double val4 ;
26108 int ecode4 = 0 ;
26109 double val5 ;
26110 int ecode5 = 0 ;
26111 PyObject * obj0 = 0 ;
26112 PyObject * obj1 = 0 ;
26113 PyObject * obj2 = 0 ;
26114 PyObject * obj3 = 0 ;
26115 PyObject * obj4 = 0 ;
26116 char * kwnames[] = {
26117 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
26118 };
26119
26120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26122 if (!SWIG_IsOK(res1)) {
26123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26124 }
26125 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26126 {
26127 arg2 = &temp2;
26128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26129 }
26130 {
26131 arg3 = &temp3;
26132 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26133 }
26134 ecode4 = SWIG_AsVal_double(obj3, &val4);
26135 if (!SWIG_IsOK(ecode4)) {
26136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
26137 }
26138 arg4 = static_cast< double >(val4);
26139 ecode5 = SWIG_AsVal_double(obj4, &val5);
26140 if (!SWIG_IsOK(ecode5)) {
26141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
26142 }
26143 arg5 = static_cast< double >(val5);
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 resultobj = SWIG_Py_Void();
26151 return resultobj;
26152 fail:
26153 return NULL;
26154 }
26155
26156
26157 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26158 PyObject *resultobj = 0;
26159 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26160 int arg2 ;
26161 int arg3 ;
26162 void *argp1 = 0 ;
26163 int res1 = 0 ;
26164 int val2 ;
26165 int ecode2 = 0 ;
26166 int val3 ;
26167 int ecode3 = 0 ;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 PyObject * obj2 = 0 ;
26171 char * kwnames[] = {
26172 (char *) "self",(char *) "x",(char *) "y", NULL
26173 };
26174
26175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26177 if (!SWIG_IsOK(res1)) {
26178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26179 }
26180 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26181 ecode2 = SWIG_AsVal_int(obj1, &val2);
26182 if (!SWIG_IsOK(ecode2)) {
26183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
26184 }
26185 arg2 = static_cast< int >(val2);
26186 ecode3 = SWIG_AsVal_int(obj2, &val3);
26187 if (!SWIG_IsOK(ecode3)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
26189 }
26190 arg3 = static_cast< int >(val3);
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 (arg1)->DrawPoint(arg2,arg3);
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 resultobj = SWIG_Py_Void();
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj = 0;
26206 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26207 wxPoint *arg2 = 0 ;
26208 void *argp1 = 0 ;
26209 int res1 = 0 ;
26210 wxPoint temp2 ;
26211 PyObject * obj0 = 0 ;
26212 PyObject * obj1 = 0 ;
26213 char * kwnames[] = {
26214 (char *) "self",(char *) "pt", NULL
26215 };
26216
26217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
26218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPointPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26221 }
26222 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26223 {
26224 arg2 = &temp2;
26225 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26226 }
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 (arg1)->DrawPoint((wxPoint const &)*arg2);
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 resultobj = SWIG_Py_Void();
26234 return resultobj;
26235 fail:
26236 return NULL;
26237 }
26238
26239
26240 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26241 PyObject *resultobj = 0;
26242 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26243 int arg2 ;
26244 int arg3 ;
26245 int arg4 ;
26246 int arg5 ;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 int val2 ;
26250 int ecode2 = 0 ;
26251 int val3 ;
26252 int ecode3 = 0 ;
26253 int val4 ;
26254 int ecode4 = 0 ;
26255 int val5 ;
26256 int ecode5 = 0 ;
26257 PyObject * obj0 = 0 ;
26258 PyObject * obj1 = 0 ;
26259 PyObject * obj2 = 0 ;
26260 PyObject * obj3 = 0 ;
26261 PyObject * obj4 = 0 ;
26262 char * kwnames[] = {
26263 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
26264 };
26265
26266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26270 }
26271 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26272 ecode2 = SWIG_AsVal_int(obj1, &val2);
26273 if (!SWIG_IsOK(ecode2)) {
26274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
26275 }
26276 arg2 = static_cast< int >(val2);
26277 ecode3 = SWIG_AsVal_int(obj2, &val3);
26278 if (!SWIG_IsOK(ecode3)) {
26279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
26280 }
26281 arg3 = static_cast< int >(val3);
26282 ecode4 = SWIG_AsVal_int(obj3, &val4);
26283 if (!SWIG_IsOK(ecode4)) {
26284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
26285 }
26286 arg4 = static_cast< int >(val4);
26287 ecode5 = SWIG_AsVal_int(obj4, &val5);
26288 if (!SWIG_IsOK(ecode5)) {
26289 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
26290 }
26291 arg5 = static_cast< int >(val5);
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_Py_Void();
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj = 0;
26307 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26308 wxRect *arg2 = 0 ;
26309 void *argp1 = 0 ;
26310 int res1 = 0 ;
26311 wxRect temp2 ;
26312 PyObject * obj0 = 0 ;
26313 PyObject * obj1 = 0 ;
26314 char * kwnames[] = {
26315 (char *) "self",(char *) "rect", NULL
26316 };
26317
26318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
26319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26320 if (!SWIG_IsOK(res1)) {
26321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26322 }
26323 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26324 {
26325 arg2 = &temp2;
26326 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26327 }
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 (arg1)->DrawRectangle((wxRect const &)*arg2);
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26344 wxPoint *arg2 = 0 ;
26345 wxSize *arg3 = 0 ;
26346 void *argp1 = 0 ;
26347 int res1 = 0 ;
26348 wxPoint temp2 ;
26349 wxSize temp3 ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 PyObject * obj2 = 0 ;
26353 char * kwnames[] = {
26354 (char *) "self",(char *) "pt",(char *) "sz", NULL
26355 };
26356
26357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26359 if (!SWIG_IsOK(res1)) {
26360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26361 }
26362 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26363 {
26364 arg2 = &temp2;
26365 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26366 }
26367 {
26368 arg3 = &temp3;
26369 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26370 }
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 resultobj = SWIG_Py_Void();
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj = 0;
26386 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26387 int arg2 ;
26388 int arg3 ;
26389 int arg4 ;
26390 int arg5 ;
26391 double arg6 ;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 int val2 ;
26395 int ecode2 = 0 ;
26396 int val3 ;
26397 int ecode3 = 0 ;
26398 int val4 ;
26399 int ecode4 = 0 ;
26400 int val5 ;
26401 int ecode5 = 0 ;
26402 double val6 ;
26403 int ecode6 = 0 ;
26404 PyObject * obj0 = 0 ;
26405 PyObject * obj1 = 0 ;
26406 PyObject * obj2 = 0 ;
26407 PyObject * obj3 = 0 ;
26408 PyObject * obj4 = 0 ;
26409 PyObject * obj5 = 0 ;
26410 char * kwnames[] = {
26411 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
26412 };
26413
26414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:PseudoDC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26418 }
26419 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26420 ecode2 = SWIG_AsVal_int(obj1, &val2);
26421 if (!SWIG_IsOK(ecode2)) {
26422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
26423 }
26424 arg2 = static_cast< int >(val2);
26425 ecode3 = SWIG_AsVal_int(obj2, &val3);
26426 if (!SWIG_IsOK(ecode3)) {
26427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
26428 }
26429 arg3 = static_cast< int >(val3);
26430 ecode4 = SWIG_AsVal_int(obj3, &val4);
26431 if (!SWIG_IsOK(ecode4)) {
26432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
26433 }
26434 arg4 = static_cast< int >(val4);
26435 ecode5 = SWIG_AsVal_int(obj4, &val5);
26436 if (!SWIG_IsOK(ecode5)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
26438 }
26439 arg5 = static_cast< int >(val5);
26440 ecode6 = SWIG_AsVal_double(obj5, &val6);
26441 if (!SWIG_IsOK(ecode6)) {
26442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
26443 }
26444 arg6 = static_cast< double >(val6);
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
26448 wxPyEndAllowThreads(__tstate);
26449 if (PyErr_Occurred()) SWIG_fail;
26450 }
26451 resultobj = SWIG_Py_Void();
26452 return resultobj;
26453 fail:
26454 return NULL;
26455 }
26456
26457
26458 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26459 PyObject *resultobj = 0;
26460 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26461 wxRect *arg2 = 0 ;
26462 double arg3 ;
26463 void *argp1 = 0 ;
26464 int res1 = 0 ;
26465 wxRect temp2 ;
26466 double val3 ;
26467 int ecode3 = 0 ;
26468 PyObject * obj0 = 0 ;
26469 PyObject * obj1 = 0 ;
26470 PyObject * obj2 = 0 ;
26471 char * kwnames[] = {
26472 (char *) "self",(char *) "r",(char *) "radius", NULL
26473 };
26474
26475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26477 if (!SWIG_IsOK(res1)) {
26478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26479 }
26480 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26481 {
26482 arg2 = &temp2;
26483 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26484 }
26485 ecode3 = SWIG_AsVal_double(obj2, &val3);
26486 if (!SWIG_IsOK(ecode3)) {
26487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
26488 }
26489 arg3 = static_cast< double >(val3);
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_Py_Void();
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj = 0;
26505 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26506 wxPoint *arg2 = 0 ;
26507 wxSize *arg3 = 0 ;
26508 double arg4 ;
26509 void *argp1 = 0 ;
26510 int res1 = 0 ;
26511 wxPoint temp2 ;
26512 wxSize temp3 ;
26513 double val4 ;
26514 int ecode4 = 0 ;
26515 PyObject * obj0 = 0 ;
26516 PyObject * obj1 = 0 ;
26517 PyObject * obj2 = 0 ;
26518 PyObject * obj3 = 0 ;
26519 char * kwnames[] = {
26520 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
26521 };
26522
26523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26525 if (!SWIG_IsOK(res1)) {
26526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26527 }
26528 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26529 {
26530 arg2 = &temp2;
26531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26532 }
26533 {
26534 arg3 = &temp3;
26535 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26536 }
26537 ecode4 = SWIG_AsVal_double(obj3, &val4);
26538 if (!SWIG_IsOK(ecode4)) {
26539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
26540 }
26541 arg4 = static_cast< double >(val4);
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 resultobj = SWIG_Py_Void();
26549 return resultobj;
26550 fail:
26551 return NULL;
26552 }
26553
26554
26555 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26556 PyObject *resultobj = 0;
26557 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26558 int arg2 ;
26559 int arg3 ;
26560 int arg4 ;
26561 void *argp1 = 0 ;
26562 int res1 = 0 ;
26563 int val2 ;
26564 int ecode2 = 0 ;
26565 int val3 ;
26566 int ecode3 = 0 ;
26567 int val4 ;
26568 int ecode4 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 PyObject * obj2 = 0 ;
26572 PyObject * obj3 = 0 ;
26573 char * kwnames[] = {
26574 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
26575 };
26576
26577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26579 if (!SWIG_IsOK(res1)) {
26580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCircle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26581 }
26582 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26583 ecode2 = SWIG_AsVal_int(obj1, &val2);
26584 if (!SWIG_IsOK(ecode2)) {
26585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
26586 }
26587 arg2 = static_cast< int >(val2);
26588 ecode3 = SWIG_AsVal_int(obj2, &val3);
26589 if (!SWIG_IsOK(ecode3)) {
26590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
26591 }
26592 arg3 = static_cast< int >(val3);
26593 ecode4 = SWIG_AsVal_int(obj3, &val4);
26594 if (!SWIG_IsOK(ecode4)) {
26595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
26596 }
26597 arg4 = static_cast< int >(val4);
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 (arg1)->DrawCircle(arg2,arg3,arg4);
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 resultobj = SWIG_Py_Void();
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj = 0;
26613 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26614 wxPoint *arg2 = 0 ;
26615 int arg3 ;
26616 void *argp1 = 0 ;
26617 int res1 = 0 ;
26618 wxPoint temp2 ;
26619 int val3 ;
26620 int ecode3 = 0 ;
26621 PyObject * obj0 = 0 ;
26622 PyObject * obj1 = 0 ;
26623 PyObject * obj2 = 0 ;
26624 char * kwnames[] = {
26625 (char *) "self",(char *) "pt",(char *) "radius", NULL
26626 };
26627
26628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26630 if (!SWIG_IsOK(res1)) {
26631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26632 }
26633 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26634 {
26635 arg2 = &temp2;
26636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26637 }
26638 ecode3 = SWIG_AsVal_int(obj2, &val3);
26639 if (!SWIG_IsOK(ecode3)) {
26640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
26641 }
26642 arg3 = static_cast< int >(val3);
26643 {
26644 PyThreadState* __tstate = wxPyBeginAllowThreads();
26645 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 resultobj = SWIG_Py_Void();
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj = 0;
26658 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26659 int arg2 ;
26660 int arg3 ;
26661 int arg4 ;
26662 int arg5 ;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 int val2 ;
26666 int ecode2 = 0 ;
26667 int val3 ;
26668 int ecode3 = 0 ;
26669 int val4 ;
26670 int ecode4 = 0 ;
26671 int val5 ;
26672 int ecode5 = 0 ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 PyObject * obj2 = 0 ;
26676 PyObject * obj3 = 0 ;
26677 PyObject * obj4 = 0 ;
26678 char * kwnames[] = {
26679 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
26680 };
26681
26682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26684 if (!SWIG_IsOK(res1)) {
26685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26686 }
26687 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26688 ecode2 = SWIG_AsVal_int(obj1, &val2);
26689 if (!SWIG_IsOK(ecode2)) {
26690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
26691 }
26692 arg2 = static_cast< int >(val2);
26693 ecode3 = SWIG_AsVal_int(obj2, &val3);
26694 if (!SWIG_IsOK(ecode3)) {
26695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
26696 }
26697 arg3 = static_cast< int >(val3);
26698 ecode4 = SWIG_AsVal_int(obj3, &val4);
26699 if (!SWIG_IsOK(ecode4)) {
26700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
26701 }
26702 arg4 = static_cast< int >(val4);
26703 ecode5 = SWIG_AsVal_int(obj4, &val5);
26704 if (!SWIG_IsOK(ecode5)) {
26705 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
26706 }
26707 arg5 = static_cast< int >(val5);
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_Py_Void();
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj = 0;
26723 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26724 wxRect *arg2 = 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 wxRect temp2 ;
26728 PyObject * obj0 = 0 ;
26729 PyObject * obj1 = 0 ;
26730 char * kwnames[] = {
26731 (char *) "self",(char *) "rect", NULL
26732 };
26733
26734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
26735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26736 if (!SWIG_IsOK(res1)) {
26737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26738 }
26739 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26740 {
26741 arg2 = &temp2;
26742 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26743 }
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 (arg1)->DrawEllipse((wxRect const &)*arg2);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 resultobj = SWIG_Py_Void();
26751 return resultobj;
26752 fail:
26753 return NULL;
26754 }
26755
26756
26757 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26758 PyObject *resultobj = 0;
26759 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26760 wxPoint *arg2 = 0 ;
26761 wxSize *arg3 = 0 ;
26762 void *argp1 = 0 ;
26763 int res1 = 0 ;
26764 wxPoint temp2 ;
26765 wxSize temp3 ;
26766 PyObject * obj0 = 0 ;
26767 PyObject * obj1 = 0 ;
26768 PyObject * obj2 = 0 ;
26769 char * kwnames[] = {
26770 (char *) "self",(char *) "pt",(char *) "sz", NULL
26771 };
26772
26773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26775 if (!SWIG_IsOK(res1)) {
26776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26777 }
26778 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26779 {
26780 arg2 = &temp2;
26781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26782 }
26783 {
26784 arg3 = &temp3;
26785 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26786 }
26787 {
26788 PyThreadState* __tstate = wxPyBeginAllowThreads();
26789 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
26790 wxPyEndAllowThreads(__tstate);
26791 if (PyErr_Occurred()) SWIG_fail;
26792 }
26793 resultobj = SWIG_Py_Void();
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj = 0;
26802 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26803 wxIcon *arg2 = 0 ;
26804 int arg3 ;
26805 int arg4 ;
26806 void *argp1 = 0 ;
26807 int res1 = 0 ;
26808 void *argp2 = 0 ;
26809 int res2 = 0 ;
26810 int val3 ;
26811 int ecode3 = 0 ;
26812 int val4 ;
26813 int ecode4 = 0 ;
26814 PyObject * obj0 = 0 ;
26815 PyObject * obj1 = 0 ;
26816 PyObject * obj2 = 0 ;
26817 PyObject * obj3 = 0 ;
26818 char * kwnames[] = {
26819 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
26820 };
26821
26822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIcon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26826 }
26827 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
26829 if (!SWIG_IsOK(res2)) {
26830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
26831 }
26832 if (!argp2) {
26833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
26834 }
26835 arg2 = reinterpret_cast< wxIcon * >(argp2);
26836 ecode3 = SWIG_AsVal_int(obj2, &val3);
26837 if (!SWIG_IsOK(ecode3)) {
26838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
26839 }
26840 arg3 = static_cast< int >(val3);
26841 ecode4 = SWIG_AsVal_int(obj3, &val4);
26842 if (!SWIG_IsOK(ecode4)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
26844 }
26845 arg4 = static_cast< int >(val4);
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 resultobj = SWIG_Py_Void();
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj = 0;
26861 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26862 wxIcon *arg2 = 0 ;
26863 wxPoint *arg3 = 0 ;
26864 void *argp1 = 0 ;
26865 int res1 = 0 ;
26866 void *argp2 = 0 ;
26867 int res2 = 0 ;
26868 wxPoint temp3 ;
26869 PyObject * obj0 = 0 ;
26870 PyObject * obj1 = 0 ;
26871 PyObject * obj2 = 0 ;
26872 char * kwnames[] = {
26873 (char *) "self",(char *) "icon",(char *) "pt", NULL
26874 };
26875
26876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26878 if (!SWIG_IsOK(res1)) {
26879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26880 }
26881 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
26883 if (!SWIG_IsOK(res2)) {
26884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
26885 }
26886 if (!argp2) {
26887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
26888 }
26889 arg2 = reinterpret_cast< wxIcon * >(argp2);
26890 {
26891 arg3 = &temp3;
26892 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26893 }
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
26897 wxPyEndAllowThreads(__tstate);
26898 if (PyErr_Occurred()) SWIG_fail;
26899 }
26900 resultobj = SWIG_Py_Void();
26901 return resultobj;
26902 fail:
26903 return NULL;
26904 }
26905
26906
26907 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26908 PyObject *resultobj = 0;
26909 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26910 wxBitmap *arg2 = 0 ;
26911 int arg3 ;
26912 int arg4 ;
26913 bool arg5 = (bool) false ;
26914 void *argp1 = 0 ;
26915 int res1 = 0 ;
26916 void *argp2 = 0 ;
26917 int res2 = 0 ;
26918 int val3 ;
26919 int ecode3 = 0 ;
26920 int val4 ;
26921 int ecode4 = 0 ;
26922 bool val5 ;
26923 int ecode5 = 0 ;
26924 PyObject * obj0 = 0 ;
26925 PyObject * obj1 = 0 ;
26926 PyObject * obj2 = 0 ;
26927 PyObject * obj3 = 0 ;
26928 PyObject * obj4 = 0 ;
26929 char * kwnames[] = {
26930 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
26931 };
26932
26933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
26935 if (!SWIG_IsOK(res1)) {
26936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
26937 }
26938 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
26939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
26940 if (!SWIG_IsOK(res2)) {
26941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
26942 }
26943 if (!argp2) {
26944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
26945 }
26946 arg2 = reinterpret_cast< wxBitmap * >(argp2);
26947 ecode3 = SWIG_AsVal_int(obj2, &val3);
26948 if (!SWIG_IsOK(ecode3)) {
26949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
26950 }
26951 arg3 = static_cast< int >(val3);
26952 ecode4 = SWIG_AsVal_int(obj3, &val4);
26953 if (!SWIG_IsOK(ecode4)) {
26954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
26955 }
26956 arg4 = static_cast< int >(val4);
26957 if (obj4) {
26958 ecode5 = SWIG_AsVal_bool(obj4, &val5);
26959 if (!SWIG_IsOK(ecode5)) {
26960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
26961 }
26962 arg5 = static_cast< bool >(val5);
26963 }
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 resultobj = SWIG_Py_Void();
26971 return resultobj;
26972 fail:
26973 return NULL;
26974 }
26975
26976
26977 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26978 PyObject *resultobj = 0;
26979 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
26980 wxBitmap *arg2 = 0 ;
26981 wxPoint *arg3 = 0 ;
26982 bool arg4 = (bool) false ;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 void *argp2 = 0 ;
26986 int res2 = 0 ;
26987 wxPoint temp3 ;
26988 bool val4 ;
26989 int ecode4 = 0 ;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 PyObject * obj2 = 0 ;
26993 PyObject * obj3 = 0 ;
26994 char * kwnames[] = {
26995 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
26996 };
26997
26998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27002 }
27003 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
27005 if (!SWIG_IsOK(res2)) {
27006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
27007 }
27008 if (!argp2) {
27009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
27010 }
27011 arg2 = reinterpret_cast< wxBitmap * >(argp2);
27012 {
27013 arg3 = &temp3;
27014 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27015 }
27016 if (obj3) {
27017 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27018 if (!SWIG_IsOK(ecode4)) {
27019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
27020 }
27021 arg4 = static_cast< bool >(val4);
27022 }
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 resultobj = SWIG_Py_Void();
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 SWIGINTERN PyObject *_wrap_PseudoDC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj = 0;
27038 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27039 wxString *arg2 = 0 ;
27040 int arg3 ;
27041 int arg4 ;
27042 void *argp1 = 0 ;
27043 int res1 = 0 ;
27044 bool temp2 = false ;
27045 int val3 ;
27046 int ecode3 = 0 ;
27047 int val4 ;
27048 int ecode4 = 0 ;
27049 PyObject * obj0 = 0 ;
27050 PyObject * obj1 = 0 ;
27051 PyObject * obj2 = 0 ;
27052 PyObject * obj3 = 0 ;
27053 char * kwnames[] = {
27054 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
27055 };
27056
27057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27059 if (!SWIG_IsOK(res1)) {
27060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27061 }
27062 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27063 {
27064 arg2 = wxString_in_helper(obj1);
27065 if (arg2 == NULL) SWIG_fail;
27066 temp2 = true;
27067 }
27068 ecode3 = SWIG_AsVal_int(obj2, &val3);
27069 if (!SWIG_IsOK(ecode3)) {
27070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawText" "', expected argument " "3"" of type '" "int""'");
27071 }
27072 arg3 = static_cast< int >(val3);
27073 ecode4 = SWIG_AsVal_int(obj3, &val4);
27074 if (!SWIG_IsOK(ecode4)) {
27075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawText" "', expected argument " "4"" of type '" "int""'");
27076 }
27077 arg4 = static_cast< int >(val4);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 resultobj = SWIG_Py_Void();
27085 {
27086 if (temp2)
27087 delete arg2;
27088 }
27089 return resultobj;
27090 fail:
27091 {
27092 if (temp2)
27093 delete arg2;
27094 }
27095 return NULL;
27096 }
27097
27098
27099 SWIGINTERN PyObject *_wrap_PseudoDC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj = 0;
27101 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27102 wxString *arg2 = 0 ;
27103 wxPoint *arg3 = 0 ;
27104 void *argp1 = 0 ;
27105 int res1 = 0 ;
27106 bool temp2 = false ;
27107 wxPoint temp3 ;
27108 PyObject * obj0 = 0 ;
27109 PyObject * obj1 = 0 ;
27110 PyObject * obj2 = 0 ;
27111 char * kwnames[] = {
27112 (char *) "self",(char *) "text",(char *) "pt", NULL
27113 };
27114
27115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27119 }
27120 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27121 {
27122 arg2 = wxString_in_helper(obj1);
27123 if (arg2 == NULL) SWIG_fail;
27124 temp2 = true;
27125 }
27126 {
27127 arg3 = &temp3;
27128 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27129 }
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = SWIG_Py_Void();
27137 {
27138 if (temp2)
27139 delete arg2;
27140 }
27141 return resultobj;
27142 fail:
27143 {
27144 if (temp2)
27145 delete arg2;
27146 }
27147 return NULL;
27148 }
27149
27150
27151 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27152 PyObject *resultobj = 0;
27153 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27154 wxString *arg2 = 0 ;
27155 int arg3 ;
27156 int arg4 ;
27157 double arg5 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 bool temp2 = false ;
27161 int val3 ;
27162 int ecode3 = 0 ;
27163 int val4 ;
27164 int ecode4 = 0 ;
27165 double val5 ;
27166 int ecode5 = 0 ;
27167 PyObject * obj0 = 0 ;
27168 PyObject * obj1 = 0 ;
27169 PyObject * obj2 = 0 ;
27170 PyObject * obj3 = 0 ;
27171 PyObject * obj4 = 0 ;
27172 char * kwnames[] = {
27173 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
27174 };
27175
27176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27178 if (!SWIG_IsOK(res1)) {
27179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27180 }
27181 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27182 {
27183 arg2 = wxString_in_helper(obj1);
27184 if (arg2 == NULL) SWIG_fail;
27185 temp2 = true;
27186 }
27187 ecode3 = SWIG_AsVal_int(obj2, &val3);
27188 if (!SWIG_IsOK(ecode3)) {
27189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
27190 }
27191 arg3 = static_cast< int >(val3);
27192 ecode4 = SWIG_AsVal_int(obj3, &val4);
27193 if (!SWIG_IsOK(ecode4)) {
27194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
27195 }
27196 arg4 = static_cast< int >(val4);
27197 ecode5 = SWIG_AsVal_double(obj4, &val5);
27198 if (!SWIG_IsOK(ecode5)) {
27199 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
27200 }
27201 arg5 = static_cast< double >(val5);
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = SWIG_Py_Void();
27209 {
27210 if (temp2)
27211 delete arg2;
27212 }
27213 return resultobj;
27214 fail:
27215 {
27216 if (temp2)
27217 delete arg2;
27218 }
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj = 0;
27225 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27226 wxString *arg2 = 0 ;
27227 wxPoint *arg3 = 0 ;
27228 double arg4 ;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 bool temp2 = false ;
27232 wxPoint temp3 ;
27233 double val4 ;
27234 int ecode4 = 0 ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 PyObject * obj2 = 0 ;
27238 PyObject * obj3 = 0 ;
27239 char * kwnames[] = {
27240 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
27241 };
27242
27243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27247 }
27248 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27249 {
27250 arg2 = wxString_in_helper(obj1);
27251 if (arg2 == NULL) SWIG_fail;
27252 temp2 = true;
27253 }
27254 {
27255 arg3 = &temp3;
27256 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27257 }
27258 ecode4 = SWIG_AsVal_double(obj3, &val4);
27259 if (!SWIG_IsOK(ecode4)) {
27260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
27261 }
27262 arg4 = static_cast< double >(val4);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 resultobj = SWIG_Py_Void();
27270 {
27271 if (temp2)
27272 delete arg2;
27273 }
27274 return resultobj;
27275 fail:
27276 {
27277 if (temp2)
27278 delete arg2;
27279 }
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj = 0;
27286 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27287 int arg2 ;
27288 wxPoint *arg3 = (wxPoint *) 0 ;
27289 int arg4 = (int) 0 ;
27290 int arg5 = (int) 0 ;
27291 void *argp1 = 0 ;
27292 int res1 = 0 ;
27293 int val4 ;
27294 int ecode4 = 0 ;
27295 int val5 ;
27296 int ecode5 = 0 ;
27297 PyObject * obj0 = 0 ;
27298 PyObject * obj1 = 0 ;
27299 PyObject * obj2 = 0 ;
27300 PyObject * obj3 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:PseudoDC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLines" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27309 }
27310 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27311 {
27312 arg3 = wxPoint_LIST_helper(obj1, &arg2);
27313 if (arg3 == NULL) SWIG_fail;
27314 }
27315 if (obj2) {
27316 ecode4 = SWIG_AsVal_int(obj2, &val4);
27317 if (!SWIG_IsOK(ecode4)) {
27318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLines" "', expected argument " "4"" of type '" "int""'");
27319 }
27320 arg4 = static_cast< int >(val4);
27321 }
27322 if (obj3) {
27323 ecode5 = SWIG_AsVal_int(obj3, &val5);
27324 if (!SWIG_IsOK(ecode5)) {
27325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLines" "', expected argument " "5"" of type '" "int""'");
27326 }
27327 arg5 = static_cast< int >(val5);
27328 }
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
27332 wxPyEndAllowThreads(__tstate);
27333 if (PyErr_Occurred()) SWIG_fail;
27334 }
27335 resultobj = SWIG_Py_Void();
27336 {
27337 if (arg3) delete [] arg3;
27338 }
27339 return resultobj;
27340 fail:
27341 {
27342 if (arg3) delete [] arg3;
27343 }
27344 return NULL;
27345 }
27346
27347
27348 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj = 0;
27350 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27351 int arg2 ;
27352 wxPoint *arg3 = (wxPoint *) 0 ;
27353 int arg4 = (int) 0 ;
27354 int arg5 = (int) 0 ;
27355 int arg6 = (int) wxODDEVEN_RULE ;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 int val4 ;
27359 int ecode4 = 0 ;
27360 int val5 ;
27361 int ecode5 = 0 ;
27362 int val6 ;
27363 int ecode6 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 PyObject * obj2 = 0 ;
27367 PyObject * obj3 = 0 ;
27368 PyObject * obj4 = 0 ;
27369 char * kwnames[] = {
27370 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
27371 };
27372
27373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:PseudoDC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27377 }
27378 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27379 {
27380 arg3 = wxPoint_LIST_helper(obj1, &arg2);
27381 if (arg3 == NULL) SWIG_fail;
27382 }
27383 if (obj2) {
27384 ecode4 = SWIG_AsVal_int(obj2, &val4);
27385 if (!SWIG_IsOK(ecode4)) {
27386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
27387 }
27388 arg4 = static_cast< int >(val4);
27389 }
27390 if (obj3) {
27391 ecode5 = SWIG_AsVal_int(obj3, &val5);
27392 if (!SWIG_IsOK(ecode5)) {
27393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
27394 }
27395 arg5 = static_cast< int >(val5);
27396 }
27397 if (obj4) {
27398 ecode6 = SWIG_AsVal_int(obj4, &val6);
27399 if (!SWIG_IsOK(ecode6)) {
27400 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
27401 }
27402 arg6 = static_cast< int >(val6);
27403 }
27404 {
27405 PyThreadState* __tstate = wxPyBeginAllowThreads();
27406 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 resultobj = SWIG_Py_Void();
27411 {
27412 if (arg3) delete [] arg3;
27413 }
27414 return resultobj;
27415 fail:
27416 {
27417 if (arg3) delete [] arg3;
27418 }
27419 return NULL;
27420 }
27421
27422
27423 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj = 0;
27425 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27426 wxString *arg2 = 0 ;
27427 wxRect *arg3 = 0 ;
27428 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
27429 int arg5 = (int) -1 ;
27430 void *argp1 = 0 ;
27431 int res1 = 0 ;
27432 bool temp2 = false ;
27433 wxRect temp3 ;
27434 int val4 ;
27435 int ecode4 = 0 ;
27436 int val5 ;
27437 int ecode5 = 0 ;
27438 PyObject * obj0 = 0 ;
27439 PyObject * obj1 = 0 ;
27440 PyObject * obj2 = 0 ;
27441 PyObject * obj3 = 0 ;
27442 PyObject * obj4 = 0 ;
27443 char * kwnames[] = {
27444 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
27445 };
27446
27447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:PseudoDC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27453 {
27454 arg2 = wxString_in_helper(obj1);
27455 if (arg2 == NULL) SWIG_fail;
27456 temp2 = true;
27457 }
27458 {
27459 arg3 = &temp3;
27460 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
27461 }
27462 if (obj3) {
27463 ecode4 = SWIG_AsVal_int(obj3, &val4);
27464 if (!SWIG_IsOK(ecode4)) {
27465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
27466 }
27467 arg4 = static_cast< int >(val4);
27468 }
27469 if (obj4) {
27470 ecode5 = SWIG_AsVal_int(obj4, &val5);
27471 if (!SWIG_IsOK(ecode5)) {
27472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
27473 }
27474 arg5 = static_cast< int >(val5);
27475 }
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_Py_Void();
27483 {
27484 if (temp2)
27485 delete arg2;
27486 }
27487 return resultobj;
27488 fail:
27489 {
27490 if (temp2)
27491 delete arg2;
27492 }
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_PseudoDC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj = 0;
27499 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27500 wxString *arg2 = 0 ;
27501 wxBitmap *arg3 = 0 ;
27502 wxRect *arg4 = 0 ;
27503 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
27504 int arg6 = (int) -1 ;
27505 void *argp1 = 0 ;
27506 int res1 = 0 ;
27507 bool temp2 = false ;
27508 void *argp3 = 0 ;
27509 int res3 = 0 ;
27510 wxRect temp4 ;
27511 int val5 ;
27512 int ecode5 = 0 ;
27513 int val6 ;
27514 int ecode6 = 0 ;
27515 PyObject * obj0 = 0 ;
27516 PyObject * obj1 = 0 ;
27517 PyObject * obj2 = 0 ;
27518 PyObject * obj3 = 0 ;
27519 PyObject * obj4 = 0 ;
27520 PyObject * obj5 = 0 ;
27521 char * kwnames[] = {
27522 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
27523 };
27524
27525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:PseudoDC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27527 if (!SWIG_IsOK(res1)) {
27528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27529 }
27530 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27531 {
27532 arg2 = wxString_in_helper(obj1);
27533 if (arg2 == NULL) SWIG_fail;
27534 temp2 = true;
27535 }
27536 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
27537 if (!SWIG_IsOK(res3)) {
27538 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
27539 }
27540 if (!argp3) {
27541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
27542 }
27543 arg3 = reinterpret_cast< wxBitmap * >(argp3);
27544 {
27545 arg4 = &temp4;
27546 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27547 }
27548 if (obj4) {
27549 ecode5 = SWIG_AsVal_int(obj4, &val5);
27550 if (!SWIG_IsOK(ecode5)) {
27551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
27552 }
27553 arg5 = static_cast< int >(val5);
27554 }
27555 if (obj5) {
27556 ecode6 = SWIG_AsVal_int(obj5, &val6);
27557 if (!SWIG_IsOK(ecode6)) {
27558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
27559 }
27560 arg6 = static_cast< int >(val6);
27561 }
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->DrawLabel((wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_Py_Void();
27569 {
27570 if (temp2)
27571 delete arg2;
27572 }
27573 return resultobj;
27574 fail:
27575 {
27576 if (temp2)
27577 delete arg2;
27578 }
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_PseudoDC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27584 PyObject *resultobj = 0;
27585 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27586 int arg2 ;
27587 wxPoint *arg3 = (wxPoint *) 0 ;
27588 void *argp1 = 0 ;
27589 int res1 = 0 ;
27590 PyObject * obj0 = 0 ;
27591 PyObject * obj1 = 0 ;
27592 char * kwnames[] = {
27593 (char *) "self",(char *) "points", NULL
27594 };
27595
27596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
27597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27598 if (!SWIG_IsOK(res1)) {
27599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawSpline" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27600 }
27601 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27602 {
27603 arg3 = wxPoint_LIST_helper(obj1, &arg2);
27604 if (arg3 == NULL) SWIG_fail;
27605 }
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 (arg1)->DrawSpline(arg2,arg3);
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 resultobj = SWIG_Py_Void();
27613 {
27614 if (arg3) delete [] arg3;
27615 }
27616 return resultobj;
27617 fail:
27618 {
27619 if (arg3) delete [] arg3;
27620 }
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_PseudoDC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27626 PyObject *resultobj = 0;
27627 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27628 void *argp1 = 0 ;
27629 int res1 = 0 ;
27630 PyObject *swig_obj[1] ;
27631
27632 if (!args) SWIG_fail;
27633 swig_obj[0] = args;
27634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27635 if (!SWIG_IsOK(res1)) {
27636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_Clear" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27637 }
27638 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 (arg1)->Clear();
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 resultobj = SWIG_Py_Void();
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 SWIGINTERN PyObject *_wrap_PseudoDC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27653 PyObject *resultobj = 0;
27654 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27655 wxFont *arg2 = 0 ;
27656 void *argp1 = 0 ;
27657 int res1 = 0 ;
27658 void *argp2 = 0 ;
27659 int res2 = 0 ;
27660 PyObject * obj0 = 0 ;
27661 PyObject * obj1 = 0 ;
27662 char * kwnames[] = {
27663 (char *) "self",(char *) "font", NULL
27664 };
27665
27666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
27667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27668 if (!SWIG_IsOK(res1)) {
27669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetFont" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27670 }
27671 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
27673 if (!SWIG_IsOK(res2)) {
27674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
27675 }
27676 if (!argp2) {
27677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
27678 }
27679 arg2 = reinterpret_cast< wxFont * >(argp2);
27680 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 (arg1)->SetFont((wxFont const &)*arg2);
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 resultobj = SWIG_Py_Void();
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_PseudoDC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj = 0;
27695 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27696 wxPen *arg2 = 0 ;
27697 void *argp1 = 0 ;
27698 int res1 = 0 ;
27699 void *argp2 = 0 ;
27700 int res2 = 0 ;
27701 PyObject * obj0 = 0 ;
27702 PyObject * obj1 = 0 ;
27703 char * kwnames[] = {
27704 (char *) "self",(char *) "pen", NULL
27705 };
27706
27707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
27708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27709 if (!SWIG_IsOK(res1)) {
27710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27711 }
27712 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27713 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
27714 if (!SWIG_IsOK(res2)) {
27715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
27716 }
27717 if (!argp2) {
27718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
27719 }
27720 arg2 = reinterpret_cast< wxPen * >(argp2);
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 (arg1)->SetPen((wxPen const &)*arg2);
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 resultobj = SWIG_Py_Void();
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_PseudoDC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj = 0;
27736 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27737 wxBrush *arg2 = 0 ;
27738 void *argp1 = 0 ;
27739 int res1 = 0 ;
27740 void *argp2 = 0 ;
27741 int res2 = 0 ;
27742 PyObject * obj0 = 0 ;
27743 PyObject * obj1 = 0 ;
27744 char * kwnames[] = {
27745 (char *) "self",(char *) "brush", NULL
27746 };
27747
27748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
27749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27750 if (!SWIG_IsOK(res1)) {
27751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBrush" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27752 }
27753 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27754 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
27755 if (!SWIG_IsOK(res2)) {
27756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
27757 }
27758 if (!argp2) {
27759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
27760 }
27761 arg2 = reinterpret_cast< wxBrush * >(argp2);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 (arg1)->SetBrush((wxBrush const &)*arg2);
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 resultobj = SWIG_Py_Void();
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj = 0;
27777 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27778 wxBrush *arg2 = 0 ;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 void *argp2 = 0 ;
27782 int res2 = 0 ;
27783 PyObject * obj0 = 0 ;
27784 PyObject * obj1 = 0 ;
27785 char * kwnames[] = {
27786 (char *) "self",(char *) "brush", NULL
27787 };
27788
27789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
27790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27791 if (!SWIG_IsOK(res1)) {
27792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27793 }
27794 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
27796 if (!SWIG_IsOK(res2)) {
27797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
27798 }
27799 if (!argp2) {
27800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
27801 }
27802 arg2 = reinterpret_cast< wxBrush * >(argp2);
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 (arg1)->SetBackground((wxBrush const &)*arg2);
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 resultobj = SWIG_Py_Void();
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj = 0;
27818 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27819 int arg2 ;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 int val2 ;
27823 int ecode2 = 0 ;
27824 PyObject * obj0 = 0 ;
27825 PyObject * obj1 = 0 ;
27826 char * kwnames[] = {
27827 (char *) "self",(char *) "mode", NULL
27828 };
27829
27830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
27831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27832 if (!SWIG_IsOK(res1)) {
27833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27834 }
27835 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27836 ecode2 = SWIG_AsVal_int(obj1, &val2);
27837 if (!SWIG_IsOK(ecode2)) {
27838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
27839 }
27840 arg2 = static_cast< int >(val2);
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 (arg1)->SetBackgroundMode(arg2);
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 resultobj = SWIG_Py_Void();
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 SWIGINTERN PyObject *_wrap_PseudoDC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27855 PyObject *resultobj = 0;
27856 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27857 wxPalette *arg2 = 0 ;
27858 void *argp1 = 0 ;
27859 int res1 = 0 ;
27860 void *argp2 = 0 ;
27861 int res2 = 0 ;
27862 PyObject * obj0 = 0 ;
27863 PyObject * obj1 = 0 ;
27864 char * kwnames[] = {
27865 (char *) "self",(char *) "palette", NULL
27866 };
27867
27868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
27869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPalette" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27872 }
27873 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27874 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
27875 if (!SWIG_IsOK(res2)) {
27876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
27877 }
27878 if (!argp2) {
27879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
27880 }
27881 arg2 = reinterpret_cast< wxPalette * >(argp2);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 (arg1)->SetPalette((wxPalette const &)*arg2);
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_Py_Void();
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj = 0;
27897 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27898 wxColour *arg2 = 0 ;
27899 void *argp1 = 0 ;
27900 int res1 = 0 ;
27901 wxColour temp2 ;
27902 PyObject * obj0 = 0 ;
27903 PyObject * obj1 = 0 ;
27904 char * kwnames[] = {
27905 (char *) "self",(char *) "colour", NULL
27906 };
27907
27908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
27909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextForeground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27912 }
27913 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27914 {
27915 arg2 = &temp2;
27916 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
27917 }
27918 {
27919 PyThreadState* __tstate = wxPyBeginAllowThreads();
27920 (arg1)->SetTextForeground((wxColour const &)*arg2);
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 resultobj = SWIG_Py_Void();
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj = 0;
27933 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27934 wxColour *arg2 = 0 ;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 wxColour temp2 ;
27938 PyObject * obj0 = 0 ;
27939 PyObject * obj1 = 0 ;
27940 char * kwnames[] = {
27941 (char *) "self",(char *) "colour", NULL
27942 };
27943
27944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
27945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27946 if (!SWIG_IsOK(res1)) {
27947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27948 }
27949 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27950 {
27951 arg2 = &temp2;
27952 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
27953 }
27954 {
27955 PyThreadState* __tstate = wxPyBeginAllowThreads();
27956 (arg1)->SetTextBackground((wxColour const &)*arg2);
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 resultobj = SWIG_Py_Void();
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 SWIGINTERN PyObject *_wrap_PseudoDC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj = 0;
27969 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27970 int arg2 ;
27971 void *argp1 = 0 ;
27972 int res1 = 0 ;
27973 int val2 ;
27974 int ecode2 = 0 ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "function", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27985 }
27986 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27987 ecode2 = SWIG_AsVal_int(obj1, &val2);
27988 if (!SWIG_IsOK(ecode2)) {
27989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
27990 }
27991 arg2 = static_cast< int >(val2);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->SetLogicalFunction(arg2);
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_Py_Void();
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *PseudoDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28006 PyObject *obj;
28007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28008 SWIG_TypeNewClientData(SWIGTYPE_p_wxPseudoDC, SWIG_NewClientData(obj));
28009 return SWIG_Py_Void();
28010 }
28011
28012 SWIGINTERN PyObject *PseudoDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28013 return SWIG_Python_InitShadowInstance(args);
28014 }
28015
28016 static PyMethodDef SwigMethods[] = {
28017 { (char *)"new_GDIObject", (PyCFunction)_wrap_new_GDIObject, METH_NOARGS, NULL},
28018 { (char *)"delete_GDIObject", (PyCFunction)_wrap_delete_GDIObject, METH_O, NULL},
28019 { (char *)"GDIObject_IsNull", (PyCFunction)_wrap_GDIObject_IsNull, METH_O, NULL},
28020 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
28021 { (char *)"GDIObject_swiginit", GDIObject_swiginit, METH_VARARGS, NULL},
28022 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
28023 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
28024 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
28025 { (char *)"delete_Colour", (PyCFunction)_wrap_delete_Colour, METH_O, NULL},
28026 { (char *)"Colour_Red", (PyCFunction)_wrap_Colour_Red, METH_O, NULL},
28027 { (char *)"Colour_Green", (PyCFunction)_wrap_Colour_Green, METH_O, NULL},
28028 { (char *)"Colour_Blue", (PyCFunction)_wrap_Colour_Blue, METH_O, NULL},
28029 { (char *)"Colour_Ok", (PyCFunction)_wrap_Colour_Ok, METH_O, NULL},
28030 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
28031 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
28032 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
28033 { (char *)"Colour_GetAsString", (PyCFunction) _wrap_Colour_GetAsString, METH_VARARGS | METH_KEYWORDS, NULL},
28034 { (char *)"Colour_GetPixel", (PyCFunction)_wrap_Colour_GetPixel, METH_O, NULL},
28035 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
28036 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
28037 { (char *)"Colour_Get", (PyCFunction)_wrap_Colour_Get, METH_O, NULL},
28038 { (char *)"Colour_GetRGB", (PyCFunction)_wrap_Colour_GetRGB, METH_O, NULL},
28039 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
28040 { (char *)"Colour_swiginit", Colour_swiginit, METH_VARARGS, NULL},
28041 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
28042 { (char *)"delete_Palette", (PyCFunction)_wrap_delete_Palette, METH_O, NULL},
28043 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
28044 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
28045 { (char *)"Palette_GetColoursCount", (PyCFunction)_wrap_Palette_GetColoursCount, METH_O, NULL},
28046 { (char *)"Palette_Ok", (PyCFunction)_wrap_Palette_Ok, METH_O, NULL},
28047 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
28048 { (char *)"Palette_swiginit", Palette_swiginit, METH_VARARGS, NULL},
28049 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
28050 { (char *)"delete_Pen", (PyCFunction)_wrap_delete_Pen, METH_O, NULL},
28051 { (char *)"Pen_GetCap", (PyCFunction)_wrap_Pen_GetCap, METH_O, NULL},
28052 { (char *)"Pen_GetColour", (PyCFunction)_wrap_Pen_GetColour, METH_O, NULL},
28053 { (char *)"Pen_GetJoin", (PyCFunction)_wrap_Pen_GetJoin, METH_O, NULL},
28054 { (char *)"Pen_GetStyle", (PyCFunction)_wrap_Pen_GetStyle, METH_O, NULL},
28055 { (char *)"Pen_GetWidth", (PyCFunction)_wrap_Pen_GetWidth, METH_O, NULL},
28056 { (char *)"Pen_Ok", (PyCFunction)_wrap_Pen_Ok, METH_O, NULL},
28057 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
28058 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28059 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
28060 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28061 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
28062 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
28063 { (char *)"Pen_GetDashes", (PyCFunction)_wrap_Pen_GetDashes, METH_O, NULL},
28064 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
28065 { (char *)"Pen_GetDashCount", (PyCFunction)_wrap_Pen_GetDashCount, METH_O, NULL},
28066 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
28067 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
28068 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
28069 { (char *)"Pen_swiginit", Pen_swiginit, METH_VARARGS, NULL},
28070 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
28071 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28072 { (char *)"delete_Brush", (PyCFunction)_wrap_delete_Brush, METH_O, NULL},
28073 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28074 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28075 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
28076 { (char *)"Brush_GetColour", (PyCFunction)_wrap_Brush_GetColour, METH_O, NULL},
28077 { (char *)"Brush_GetStyle", (PyCFunction)_wrap_Brush_GetStyle, METH_O, NULL},
28078 { (char *)"Brush_GetStipple", (PyCFunction)_wrap_Brush_GetStipple, METH_O, NULL},
28079 { (char *)"Brush_IsHatch", (PyCFunction)_wrap_Brush_IsHatch, METH_O, NULL},
28080 { (char *)"Brush_Ok", (PyCFunction)_wrap_Brush_Ok, METH_O, NULL},
28081 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
28082 { (char *)"Brush_swiginit", Brush_swiginit, METH_VARARGS, NULL},
28083 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28084 { (char *)"delete_Bitmap", (PyCFunction)_wrap_delete_Bitmap, METH_O, NULL},
28085 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28086 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28087 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
28088 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
28089 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
28090 { (char *)"Bitmap_Ok", (PyCFunction)_wrap_Bitmap_Ok, METH_O, NULL},
28091 { (char *)"Bitmap_GetWidth", (PyCFunction)_wrap_Bitmap_GetWidth, METH_O, NULL},
28092 { (char *)"Bitmap_GetHeight", (PyCFunction)_wrap_Bitmap_GetHeight, METH_O, NULL},
28093 { (char *)"Bitmap_GetDepth", (PyCFunction)_wrap_Bitmap_GetDepth, METH_O, NULL},
28094 { (char *)"Bitmap_GetSize", (PyCFunction)_wrap_Bitmap_GetSize, METH_O, NULL},
28095 { (char *)"Bitmap_ConvertToImage", (PyCFunction)_wrap_Bitmap_ConvertToImage, METH_O, NULL},
28096 { (char *)"Bitmap_GetMask", (PyCFunction)_wrap_Bitmap_GetMask, METH_O, NULL},
28097 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
28098 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
28099 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28100 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
28101 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
28102 { (char *)"Bitmap_GetPalette", (PyCFunction)_wrap_Bitmap_GetPalette, METH_O, NULL},
28103 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28104 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
28105 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
28106 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
28107 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28108 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
28109 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
28110 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
28111 { (char *)"Bitmap_swiginit", Bitmap_swiginit, METH_VARARGS, NULL},
28112 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
28113 { (char *)"delete_Mask", (PyCFunction)_wrap_delete_Mask, METH_O, NULL},
28114 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
28115 { (char *)"Mask_swiginit", Mask_swiginit, METH_VARARGS, NULL},
28116 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
28117 { (char *)"delete_Icon", (PyCFunction)_wrap_delete_Icon, METH_O, NULL},
28118 { (char *)"new_EmptyIcon", (PyCFunction)_wrap_new_EmptyIcon, METH_NOARGS, NULL},
28119 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
28120 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28121 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
28122 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
28123 { (char *)"Icon_Ok", (PyCFunction)_wrap_Icon_Ok, METH_O, NULL},
28124 { (char *)"Icon_GetWidth", (PyCFunction)_wrap_Icon_GetWidth, METH_O, NULL},
28125 { (char *)"Icon_GetHeight", (PyCFunction)_wrap_Icon_GetHeight, METH_O, NULL},
28126 { (char *)"Icon_GetDepth", (PyCFunction)_wrap_Icon_GetDepth, METH_O, NULL},
28127 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
28128 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
28129 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
28130 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28131 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
28132 { (char *)"Icon_swiginit", Icon_swiginit, METH_VARARGS, NULL},
28133 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
28134 { (char *)"delete_IconLocation", (PyCFunction)_wrap_delete_IconLocation, METH_O, NULL},
28135 { (char *)"IconLocation_IsOk", (PyCFunction)_wrap_IconLocation_IsOk, METH_O, NULL},
28136 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
28137 { (char *)"IconLocation_GetFileName", (PyCFunction)_wrap_IconLocation_GetFileName, METH_O, NULL},
28138 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
28139 { (char *)"IconLocation_GetIndex", (PyCFunction)_wrap_IconLocation_GetIndex, METH_O, NULL},
28140 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
28141 { (char *)"IconLocation_swiginit", IconLocation_swiginit, METH_VARARGS, NULL},
28142 { (char *)"new_IconBundle", (PyCFunction)_wrap_new_IconBundle, METH_NOARGS, NULL},
28143 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
28144 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28145 { (char *)"delete_IconBundle", (PyCFunction)_wrap_delete_IconBundle, METH_O, NULL},
28146 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28147 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
28148 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28149 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
28150 { (char *)"IconBundle_swiginit", IconBundle_swiginit, METH_VARARGS, NULL},
28151 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
28152 { (char *)"delete_Cursor", (PyCFunction)_wrap_delete_Cursor, METH_O, NULL},
28153 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
28154 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
28155 { (char *)"Cursor_Ok", (PyCFunction)_wrap_Cursor_Ok, METH_O, NULL},
28156 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
28157 { (char *)"Cursor_swiginit", Cursor_swiginit, METH_VARARGS, NULL},
28158 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
28159 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28160 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
28161 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
28162 { (char *)"delete_Region", (PyCFunction)_wrap_delete_Region, METH_O, NULL},
28163 { (char *)"Region_Clear", (PyCFunction)_wrap_Region_Clear, METH_O, NULL},
28164 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
28165 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
28166 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28167 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
28168 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
28169 { (char *)"Region_GetBox", (PyCFunction)_wrap_Region_GetBox, METH_O, NULL},
28170 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
28171 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
28172 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28173 { (char *)"Region_IsEmpty", (PyCFunction)_wrap_Region_IsEmpty, METH_O, NULL},
28174 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
28175 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
28176 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28177 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
28178 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
28179 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28180 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
28181 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
28182 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28183 { (char *)"Region_ConvertToBitmap", (PyCFunction)_wrap_Region_ConvertToBitmap, METH_O, NULL},
28184 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28185 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
28186 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
28187 { (char *)"Region_swiginit", Region_swiginit, METH_VARARGS, NULL},
28188 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
28189 { (char *)"delete_RegionIterator", (PyCFunction)_wrap_delete_RegionIterator, METH_O, NULL},
28190 { (char *)"RegionIterator_GetX", (PyCFunction)_wrap_RegionIterator_GetX, METH_O, NULL},
28191 { (char *)"RegionIterator_GetY", (PyCFunction)_wrap_RegionIterator_GetY, METH_O, NULL},
28192 { (char *)"RegionIterator_GetW", (PyCFunction)_wrap_RegionIterator_GetW, METH_O, NULL},
28193 { (char *)"RegionIterator_GetWidth", (PyCFunction)_wrap_RegionIterator_GetWidth, METH_O, NULL},
28194 { (char *)"RegionIterator_GetH", (PyCFunction)_wrap_RegionIterator_GetH, METH_O, NULL},
28195 { (char *)"RegionIterator_GetHeight", (PyCFunction)_wrap_RegionIterator_GetHeight, METH_O, NULL},
28196 { (char *)"RegionIterator_GetRect", (PyCFunction)_wrap_RegionIterator_GetRect, METH_O, NULL},
28197 { (char *)"RegionIterator_HaveRects", (PyCFunction)_wrap_RegionIterator_HaveRects, METH_O, NULL},
28198 { (char *)"RegionIterator_Reset", (PyCFunction)_wrap_RegionIterator_Reset, METH_O, NULL},
28199 { (char *)"RegionIterator_Next", (PyCFunction)_wrap_RegionIterator_Next, METH_O, NULL},
28200 { (char *)"RegionIterator___nonzero__", (PyCFunction)_wrap_RegionIterator___nonzero__, METH_O, NULL},
28201 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
28202 { (char *)"RegionIterator_swiginit", RegionIterator_swiginit, METH_VARARGS, NULL},
28203 { (char *)"new_NativeFontInfo", (PyCFunction)_wrap_new_NativeFontInfo, METH_NOARGS, NULL},
28204 { (char *)"delete_NativeFontInfo", (PyCFunction)_wrap_delete_NativeFontInfo, METH_O, NULL},
28205 { (char *)"NativeFontInfo_Init", (PyCFunction)_wrap_NativeFontInfo_Init, METH_O, NULL},
28206 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
28207 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction)_wrap_NativeFontInfo_GetPointSize, METH_O, NULL},
28208 { (char *)"NativeFontInfo_GetStyle", (PyCFunction)_wrap_NativeFontInfo_GetStyle, METH_O, NULL},
28209 { (char *)"NativeFontInfo_GetWeight", (PyCFunction)_wrap_NativeFontInfo_GetWeight, METH_O, NULL},
28210 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction)_wrap_NativeFontInfo_GetUnderlined, METH_O, NULL},
28211 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction)_wrap_NativeFontInfo_GetFaceName, METH_O, NULL},
28212 { (char *)"NativeFontInfo_GetFamily", (PyCFunction)_wrap_NativeFontInfo_GetFamily, METH_O, NULL},
28213 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction)_wrap_NativeFontInfo_GetEncoding, METH_O, NULL},
28214 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28215 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28216 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
28217 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
28218 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
28219 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
28220 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28221 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
28222 { (char *)"NativeFontInfo_ToString", (PyCFunction)_wrap_NativeFontInfo_ToString, METH_O, NULL},
28223 { (char *)"NativeFontInfo___str__", (PyCFunction)_wrap_NativeFontInfo___str__, METH_O, NULL},
28224 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
28225 { (char *)"NativeFontInfo_ToUserString", (PyCFunction)_wrap_NativeFontInfo_ToUserString, METH_O, NULL},
28226 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
28227 { (char *)"NativeFontInfo_swiginit", NativeFontInfo_swiginit, METH_VARARGS, NULL},
28228 { (char *)"NativeEncodingInfo_facename_set", _wrap_NativeEncodingInfo_facename_set, METH_VARARGS, NULL},
28229 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction)_wrap_NativeEncodingInfo_facename_get, METH_O, NULL},
28230 { (char *)"NativeEncodingInfo_encoding_set", _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS, NULL},
28231 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction)_wrap_NativeEncodingInfo_encoding_get, METH_O, NULL},
28232 { (char *)"new_NativeEncodingInfo", (PyCFunction)_wrap_new_NativeEncodingInfo, METH_NOARGS, NULL},
28233 { (char *)"delete_NativeEncodingInfo", (PyCFunction)_wrap_delete_NativeEncodingInfo, METH_O, NULL},
28234 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
28235 { (char *)"NativeEncodingInfo_ToString", (PyCFunction)_wrap_NativeEncodingInfo_ToString, METH_O, NULL},
28236 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
28237 { (char *)"NativeEncodingInfo_swiginit", NativeEncodingInfo_swiginit, METH_VARARGS, NULL},
28238 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28239 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28240 { (char *)"new_FontMapper", (PyCFunction)_wrap_new_FontMapper, METH_NOARGS, NULL},
28241 { (char *)"delete_FontMapper", (PyCFunction)_wrap_delete_FontMapper, METH_O, NULL},
28242 { (char *)"FontMapper_Get", (PyCFunction)_wrap_FontMapper_Get, METH_NOARGS, NULL},
28243 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
28244 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28245 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction)_wrap_FontMapper_GetSupportedEncodingsCount, METH_NOARGS, NULL},
28246 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28247 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
28248 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
28249 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
28250 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
28251 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction)_wrap_FontMapper_GetDefaultConfigPath, METH_NOARGS, NULL},
28252 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28253 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
28254 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
28255 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
28256 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
28257 { (char *)"FontMapper_swiginit", FontMapper_swiginit, METH_VARARGS, NULL},
28258 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
28259 { (char *)"delete_Font", (PyCFunction)_wrap_delete_Font, METH_O, NULL},
28260 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28261 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
28262 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
28263 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
28264 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
28265 { (char *)"Font_Ok", (PyCFunction)_wrap_Font_Ok, METH_O, NULL},
28266 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
28267 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
28268 { (char *)"Font_GetPointSize", (PyCFunction)_wrap_Font_GetPointSize, METH_O, NULL},
28269 { (char *)"Font_GetPixelSize", (PyCFunction)_wrap_Font_GetPixelSize, METH_O, NULL},
28270 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction)_wrap_Font_IsUsingSizeInPixels, METH_O, NULL},
28271 { (char *)"Font_GetFamily", (PyCFunction)_wrap_Font_GetFamily, METH_O, NULL},
28272 { (char *)"Font_GetStyle", (PyCFunction)_wrap_Font_GetStyle, METH_O, NULL},
28273 { (char *)"Font_GetWeight", (PyCFunction)_wrap_Font_GetWeight, METH_O, NULL},
28274 { (char *)"Font_GetUnderlined", (PyCFunction)_wrap_Font_GetUnderlined, METH_O, NULL},
28275 { (char *)"Font_GetFaceName", (PyCFunction)_wrap_Font_GetFaceName, METH_O, NULL},
28276 { (char *)"Font_GetEncoding", (PyCFunction)_wrap_Font_GetEncoding, METH_O, NULL},
28277 { (char *)"Font_GetNativeFontInfo", (PyCFunction)_wrap_Font_GetNativeFontInfo, METH_O, NULL},
28278 { (char *)"Font_IsFixedWidth", (PyCFunction)_wrap_Font_IsFixedWidth, METH_O, NULL},
28279 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoDesc, METH_O, NULL},
28280 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoUserDesc, METH_O, NULL},
28281 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28282 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
28283 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
28284 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
28285 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
28286 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
28287 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
28288 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28289 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28290 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
28291 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
28292 { (char *)"Font_GetFamilyString", (PyCFunction)_wrap_Font_GetFamilyString, METH_O, NULL},
28293 { (char *)"Font_GetStyleString", (PyCFunction)_wrap_Font_GetStyleString, METH_O, NULL},
28294 { (char *)"Font_GetWeightString", (PyCFunction)_wrap_Font_GetWeightString, METH_O, NULL},
28295 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
28296 { (char *)"Font_GetNoAntiAliasing", (PyCFunction)_wrap_Font_GetNoAntiAliasing, METH_O, NULL},
28297 { (char *)"Font_GetDefaultEncoding", (PyCFunction)_wrap_Font_GetDefaultEncoding, METH_NOARGS, NULL},
28298 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
28299 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
28300 { (char *)"Font_swiginit", Font_swiginit, METH_VARARGS, NULL},
28301 { (char *)"new_FontEnumerator", (PyCFunction)_wrap_new_FontEnumerator, METH_NOARGS, NULL},
28302 { (char *)"delete_FontEnumerator", (PyCFunction)_wrap_delete_FontEnumerator, METH_O, NULL},
28303 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28304 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
28305 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
28306 { (char *)"FontEnumerator_GetEncodings", (PyCFunction)_wrap_FontEnumerator_GetEncodings, METH_NOARGS, NULL},
28307 { (char *)"FontEnumerator_GetFacenames", (PyCFunction)_wrap_FontEnumerator_GetFacenames, METH_NOARGS, NULL},
28308 { (char *)"FontEnumerator_IsValidFacename", (PyCFunction) _wrap_FontEnumerator_IsValidFacename, METH_VARARGS | METH_KEYWORDS, NULL},
28309 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
28310 { (char *)"FontEnumerator_swiginit", FontEnumerator_swiginit, METH_VARARGS, NULL},
28311 { (char *)"LanguageInfo_Language_set", _wrap_LanguageInfo_Language_set, METH_VARARGS, NULL},
28312 { (char *)"LanguageInfo_Language_get", (PyCFunction)_wrap_LanguageInfo_Language_get, METH_O, NULL},
28313 { (char *)"LanguageInfo_CanonicalName_set", _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS, NULL},
28314 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction)_wrap_LanguageInfo_CanonicalName_get, METH_O, NULL},
28315 { (char *)"LanguageInfo_Description_set", _wrap_LanguageInfo_Description_set, METH_VARARGS, NULL},
28316 { (char *)"LanguageInfo_Description_get", (PyCFunction)_wrap_LanguageInfo_Description_get, METH_O, NULL},
28317 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
28318 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
28319 { (char *)"delete_Locale", (PyCFunction)_wrap_delete_Locale, METH_O, NULL},
28320 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
28321 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
28322 { (char *)"Locale_GetSystemLanguage", (PyCFunction)_wrap_Locale_GetSystemLanguage, METH_NOARGS, NULL},
28323 { (char *)"Locale_GetSystemEncoding", (PyCFunction)_wrap_Locale_GetSystemEncoding, METH_NOARGS, NULL},
28324 { (char *)"Locale_GetSystemEncodingName", (PyCFunction)_wrap_Locale_GetSystemEncodingName, METH_NOARGS, NULL},
28325 { (char *)"Locale_IsOk", (PyCFunction)_wrap_Locale_IsOk, METH_O, NULL},
28326 { (char *)"Locale_GetLocale", (PyCFunction)_wrap_Locale_GetLocale, METH_O, NULL},
28327 { (char *)"Locale_GetLanguage", (PyCFunction)_wrap_Locale_GetLanguage, METH_O, NULL},
28328 { (char *)"Locale_GetSysName", (PyCFunction)_wrap_Locale_GetSysName, METH_O, NULL},
28329 { (char *)"Locale_GetCanonicalName", (PyCFunction)_wrap_Locale_GetCanonicalName, METH_O, NULL},
28330 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
28331 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
28332 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
28333 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28334 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
28335 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
28336 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
28337 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
28338 { (char *)"Locale_GetName", (PyCFunction)_wrap_Locale_GetName, METH_O, NULL},
28339 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
28340 { (char *)"Locale_swiginit", Locale_swiginit, METH_VARARGS, NULL},
28341 { (char *)"GetLocale", (PyCFunction)_wrap_GetLocale, METH_NOARGS, NULL},
28342 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
28343 { (char *)"new_EncodingConverter", (PyCFunction)_wrap_new_EncodingConverter, METH_NOARGS, NULL},
28344 { (char *)"delete_EncodingConverter", (PyCFunction)_wrap_delete_EncodingConverter, METH_O, NULL},
28345 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
28346 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
28347 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
28348 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
28349 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
28350 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
28351 { (char *)"EncodingConverter_swiginit", EncodingConverter_swiginit, METH_VARARGS, NULL},
28352 { (char *)"delete_DC", (PyCFunction)_wrap_delete_DC, METH_O, NULL},
28353 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
28354 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28355 { (char *)"DC_GradientFillConcentric", (PyCFunction) _wrap_DC_GradientFillConcentric, METH_VARARGS | METH_KEYWORDS, NULL},
28356 { (char *)"DC_GradientFillLinear", (PyCFunction) _wrap_DC_GradientFillLinear, METH_VARARGS | METH_KEYWORDS, NULL},
28357 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
28358 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28359 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
28360 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
28361 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
28362 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28363 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
28364 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28365 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
28366 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
28367 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
28368 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28369 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28370 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28371 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
28372 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
28373 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28374 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
28375 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
28376 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28377 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
28378 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
28379 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
28380 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
28381 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28382 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28383 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28384 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28385 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28386 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
28387 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28388 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
28389 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28390 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
28391 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28392 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28393 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28394 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
28395 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
28396 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
28397 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
28398 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
28399 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
28400 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
28401 { (char *)"DC_Clear", (PyCFunction)_wrap_DC_Clear, METH_O, NULL},
28402 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
28403 { (char *)"DC_EndDoc", (PyCFunction)_wrap_DC_EndDoc, METH_O, NULL},
28404 { (char *)"DC_StartPage", (PyCFunction)_wrap_DC_StartPage, METH_O, NULL},
28405 { (char *)"DC_EndPage", (PyCFunction)_wrap_DC_EndPage, METH_O, NULL},
28406 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
28407 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
28408 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28409 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28410 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
28411 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
28412 { (char *)"DC_DestroyClippingRegion", (PyCFunction)_wrap_DC_DestroyClippingRegion, METH_O, NULL},
28413 { (char *)"DC_GetClippingBox", (PyCFunction)_wrap_DC_GetClippingBox, METH_O, NULL},
28414 { (char *)"DC_GetClippingRect", (PyCFunction)_wrap_DC_GetClippingRect, METH_O, NULL},
28415 { (char *)"DC_GetCharHeight", (PyCFunction)_wrap_DC_GetCharHeight, METH_O, NULL},
28416 { (char *)"DC_GetCharWidth", (PyCFunction)_wrap_DC_GetCharWidth, METH_O, NULL},
28417 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
28418 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
28419 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
28420 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
28421 { (char *)"DC_GetSize", (PyCFunction)_wrap_DC_GetSize, METH_O, NULL},
28422 { (char *)"DC_GetSizeTuple", (PyCFunction)_wrap_DC_GetSizeTuple, METH_O, NULL},
28423 { (char *)"DC_GetSizeMM", (PyCFunction)_wrap_DC_GetSizeMM, METH_O, NULL},
28424 { (char *)"DC_GetSizeMMTuple", (PyCFunction)_wrap_DC_GetSizeMMTuple, METH_O, NULL},
28425 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
28426 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
28427 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
28428 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
28429 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
28430 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
28431 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
28432 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
28433 { (char *)"DC_CanDrawBitmap", (PyCFunction)_wrap_DC_CanDrawBitmap, METH_O, NULL},
28434 { (char *)"DC_CanGetTextExtent", (PyCFunction)_wrap_DC_CanGetTextExtent, METH_O, NULL},
28435 { (char *)"DC_GetDepth", (PyCFunction)_wrap_DC_GetDepth, METH_O, NULL},
28436 { (char *)"DC_GetPPI", (PyCFunction)_wrap_DC_GetPPI, METH_O, NULL},
28437 { (char *)"DC_Ok", (PyCFunction)_wrap_DC_Ok, METH_O, NULL},
28438 { (char *)"DC_GetBackgroundMode", (PyCFunction)_wrap_DC_GetBackgroundMode, METH_O, NULL},
28439 { (char *)"DC_GetBackground", (PyCFunction)_wrap_DC_GetBackground, METH_O, NULL},
28440 { (char *)"DC_GetBrush", (PyCFunction)_wrap_DC_GetBrush, METH_O, NULL},
28441 { (char *)"DC_GetFont", (PyCFunction)_wrap_DC_GetFont, METH_O, NULL},
28442 { (char *)"DC_GetPen", (PyCFunction)_wrap_DC_GetPen, METH_O, NULL},
28443 { (char *)"DC_GetTextBackground", (PyCFunction)_wrap_DC_GetTextBackground, METH_O, NULL},
28444 { (char *)"DC_GetTextForeground", (PyCFunction)_wrap_DC_GetTextForeground, METH_O, NULL},
28445 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
28446 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28447 { (char *)"DC_GetMapMode", (PyCFunction)_wrap_DC_GetMapMode, METH_O, NULL},
28448 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
28449 { (char *)"DC_GetUserScale", (PyCFunction)_wrap_DC_GetUserScale, METH_O, NULL},
28450 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
28451 { (char *)"DC_GetLogicalScale", (PyCFunction)_wrap_DC_GetLogicalScale, METH_O, NULL},
28452 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
28453 { (char *)"DC_GetLogicalOrigin", (PyCFunction)_wrap_DC_GetLogicalOrigin, METH_O, NULL},
28454 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction)_wrap_DC_GetLogicalOriginTuple, METH_O, NULL},
28455 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
28456 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28457 { (char *)"DC_GetDeviceOrigin", (PyCFunction)_wrap_DC_GetDeviceOrigin, METH_O, NULL},
28458 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction)_wrap_DC_GetDeviceOriginTuple, METH_O, NULL},
28459 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
28460 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28461 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
28462 { (char *)"DC_GetLogicalFunction", (PyCFunction)_wrap_DC_GetLogicalFunction, METH_O, NULL},
28463 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
28464 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction)_wrap_DC_ComputeScaleAndOrigin, METH_O, NULL},
28465 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
28466 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28467 { (char *)"DC_ResetBoundingBox", (PyCFunction)_wrap_DC_ResetBoundingBox, METH_O, NULL},
28468 { (char *)"DC_MinX", (PyCFunction)_wrap_DC_MinX, METH_O, NULL},
28469 { (char *)"DC_MaxX", (PyCFunction)_wrap_DC_MaxX, METH_O, NULL},
28470 { (char *)"DC_MinY", (PyCFunction)_wrap_DC_MinY, METH_O, NULL},
28471 { (char *)"DC_MaxY", (PyCFunction)_wrap_DC_MaxY, METH_O, NULL},
28472 { (char *)"DC_GetBoundingBox", (PyCFunction)_wrap_DC_GetBoundingBox, METH_O, NULL},
28473 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
28474 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
28475 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
28476 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
28477 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
28478 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
28479 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
28480 { (char *)"new_MemoryDC", (PyCFunction)_wrap_new_MemoryDC, METH_NOARGS, NULL},
28481 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
28482 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
28483 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
28484 { (char *)"MemoryDC_swiginit", MemoryDC_swiginit, METH_VARARGS, NULL},
28485 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
28486 { (char *)"delete_BufferedDC", (PyCFunction)_wrap_delete_BufferedDC, METH_O, NULL},
28487 { (char *)"BufferedDC_UnMask", (PyCFunction)_wrap_BufferedDC_UnMask, METH_O, NULL},
28488 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
28489 { (char *)"BufferedDC_swiginit", BufferedDC_swiginit, METH_VARARGS, NULL},
28490 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28491 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
28492 { (char *)"BufferedPaintDC_swiginit", BufferedPaintDC_swiginit, METH_VARARGS, NULL},
28493 { (char *)"new_ScreenDC", (PyCFunction)_wrap_new_ScreenDC, METH_NOARGS, NULL},
28494 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
28495 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
28496 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction)_wrap_ScreenDC_EndDrawingOnTop, METH_O, NULL},
28497 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
28498 { (char *)"ScreenDC_swiginit", ScreenDC_swiginit, METH_VARARGS, NULL},
28499 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
28500 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
28501 { (char *)"ClientDC_swiginit", ClientDC_swiginit, METH_VARARGS, NULL},
28502 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
28503 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
28504 { (char *)"PaintDC_swiginit", PaintDC_swiginit, METH_VARARGS, NULL},
28505 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
28506 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
28507 { (char *)"WindowDC_swiginit", WindowDC_swiginit, METH_VARARGS, NULL},
28508 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
28509 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
28510 { (char *)"MirrorDC_swiginit", MirrorDC_swiginit, METH_VARARGS, NULL},
28511 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
28512 { (char *)"PostScriptDC_GetPrintData", (PyCFunction)_wrap_PostScriptDC_GetPrintData, METH_O, NULL},
28513 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
28514 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
28515 { (char *)"PostScriptDC_GetResolution", (PyCFunction)_wrap_PostScriptDC_GetResolution, METH_NOARGS, NULL},
28516 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
28517 { (char *)"PostScriptDC_swiginit", PostScriptDC_swiginit, METH_VARARGS, NULL},
28518 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
28519 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
28520 { (char *)"MetaFile_swiginit", MetaFile_swiginit, METH_VARARGS, NULL},
28521 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
28522 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
28523 { (char *)"MetaFileDC_swiginit", MetaFileDC_swiginit, METH_VARARGS, NULL},
28524 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
28525 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
28526 { (char *)"PrinterDC_swiginit", PrinterDC_swiginit, METH_VARARGS, NULL},
28527 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
28528 { (char *)"delete_ImageList", (PyCFunction)_wrap_delete_ImageList, METH_O, NULL},
28529 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
28530 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
28531 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28532 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28533 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28534 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
28535 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
28536 { (char *)"ImageList_GetImageCount", (PyCFunction)_wrap_ImageList_GetImageCount, METH_O, NULL},
28537 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
28538 { (char *)"ImageList_RemoveAll", (PyCFunction)_wrap_ImageList_RemoveAll, METH_O, NULL},
28539 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
28540 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
28541 { (char *)"ImageList_swiginit", ImageList_swiginit, METH_VARARGS, NULL},
28542 { (char *)"new_StockGDI", (PyCFunction)_wrap_new_StockGDI, METH_NOARGS, NULL},
28543 { (char *)"delete_StockGDI", (PyCFunction)_wrap_delete_StockGDI, METH_O, NULL},
28544 { (char *)"StockGDI_DeleteAll", (PyCFunction)_wrap_StockGDI_DeleteAll, METH_NOARGS, NULL},
28545 { (char *)"StockGDI_instance", (PyCFunction)_wrap_StockGDI_instance, METH_NOARGS, NULL},
28546 { (char *)"StockGDI_GetBrush", (PyCFunction) _wrap_StockGDI_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28547 { (char *)"StockGDI_GetColour", (PyCFunction) _wrap_StockGDI_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
28548 { (char *)"StockGDI_GetCursor", (PyCFunction) _wrap_StockGDI_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
28549 { (char *)"StockGDI_GetPen", (PyCFunction) _wrap_StockGDI_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
28550 { (char *)"StockGDI_GetFont", (PyCFunction) _wrap_StockGDI_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
28551 { (char *)"StockGDI_swigregister", StockGDI_swigregister, METH_VARARGS, NULL},
28552 { (char *)"StockGDI_swiginit", StockGDI_swiginit, METH_VARARGS, NULL},
28553 { (char *)"new_GDIObjListBase", (PyCFunction)_wrap_new_GDIObjListBase, METH_NOARGS, NULL},
28554 { (char *)"delete_GDIObjListBase", (PyCFunction)_wrap_delete_GDIObjListBase, METH_O, NULL},
28555 { (char *)"GDIObjListBase_swigregister", GDIObjListBase_swigregister, METH_VARARGS, NULL},
28556 { (char *)"GDIObjListBase_swiginit", GDIObjListBase_swiginit, METH_VARARGS, NULL},
28557 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
28558 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
28559 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
28560 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
28561 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28562 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28563 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28564 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
28565 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
28566 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
28567 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
28568 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
28569 { (char *)"new_ColourDatabase", (PyCFunction)_wrap_new_ColourDatabase, METH_NOARGS, NULL},
28570 { (char *)"delete_ColourDatabase", (PyCFunction)_wrap_delete_ColourDatabase, METH_O, NULL},
28571 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
28572 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
28573 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
28574 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
28575 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
28576 { (char *)"ColourDatabase_swiginit", ColourDatabase_swiginit, METH_VARARGS, NULL},
28577 { (char *)"_wxPyInitTheFontList", (PyCFunction)_wrap__wxPyInitTheFontList, METH_NOARGS, NULL},
28578 { (char *)"_wxPyInitThePenList", (PyCFunction)_wrap__wxPyInitThePenList, METH_NOARGS, NULL},
28579 { (char *)"_wxPyInitTheBrushList", (PyCFunction)_wrap__wxPyInitTheBrushList, METH_NOARGS, NULL},
28580 { (char *)"_wxPyInitTheColourDatabase", (PyCFunction)_wrap__wxPyInitTheColourDatabase, METH_NOARGS, NULL},
28581 { (char *)"new_Effects", (PyCFunction)_wrap_new_Effects, METH_NOARGS, NULL},
28582 { (char *)"Effects_GetHighlightColour", (PyCFunction)_wrap_Effects_GetHighlightColour, METH_O, NULL},
28583 { (char *)"Effects_GetLightShadow", (PyCFunction)_wrap_Effects_GetLightShadow, METH_O, NULL},
28584 { (char *)"Effects_GetFaceColour", (PyCFunction)_wrap_Effects_GetFaceColour, METH_O, NULL},
28585 { (char *)"Effects_GetMediumShadow", (PyCFunction)_wrap_Effects_GetMediumShadow, METH_O, NULL},
28586 { (char *)"Effects_GetDarkShadow", (PyCFunction)_wrap_Effects_GetDarkShadow, METH_O, NULL},
28587 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
28588 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
28589 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
28590 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
28591 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
28592 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
28593 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
28594 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28595 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
28596 { (char *)"Effects_swiginit", Effects_swiginit, METH_VARARGS, NULL},
28597 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
28598 { (char *)"delete_SplitterRenderParams", (PyCFunction)_wrap_delete_SplitterRenderParams, METH_O, NULL},
28599 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction)_wrap_SplitterRenderParams_widthSash_get, METH_O, NULL},
28600 { (char *)"SplitterRenderParams_border_get", (PyCFunction)_wrap_SplitterRenderParams_border_get, METH_O, NULL},
28601 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction)_wrap_SplitterRenderParams_isHotSensitive_get, METH_O, NULL},
28602 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
28603 { (char *)"SplitterRenderParams_swiginit", SplitterRenderParams_swiginit, METH_VARARGS, NULL},
28604 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
28605 { (char *)"delete_RendererVersion", (PyCFunction)_wrap_delete_RendererVersion, METH_O, NULL},
28606 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
28607 { (char *)"RendererVersion_version_get", (PyCFunction)_wrap_RendererVersion_version_get, METH_O, NULL},
28608 { (char *)"RendererVersion_age_get", (PyCFunction)_wrap_RendererVersion_age_get, METH_O, NULL},
28609 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
28610 { (char *)"RendererVersion_swiginit", RendererVersion_swiginit, METH_VARARGS, NULL},
28611 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
28612 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
28613 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
28614 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
28615 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
28616 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
28617 { (char *)"RendererNative_DrawCheckBox", (PyCFunction) _wrap_RendererNative_DrawCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
28618 { (char *)"RendererNative_DrawPushButton", (PyCFunction) _wrap_RendererNative_DrawPushButton, METH_VARARGS | METH_KEYWORDS, NULL},
28619 { (char *)"RendererNative_DrawItemSelectionRect", (PyCFunction) _wrap_RendererNative_DrawItemSelectionRect, METH_VARARGS | METH_KEYWORDS, NULL},
28620 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
28621 { (char *)"RendererNative_Get", (PyCFunction)_wrap_RendererNative_Get, METH_NOARGS, NULL},
28622 { (char *)"RendererNative_GetGeneric", (PyCFunction)_wrap_RendererNative_GetGeneric, METH_NOARGS, NULL},
28623 { (char *)"RendererNative_GetDefault", (PyCFunction)_wrap_RendererNative_GetDefault, METH_NOARGS, NULL},
28624 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
28625 { (char *)"RendererNative_GetVersion", (PyCFunction)_wrap_RendererNative_GetVersion, METH_O, NULL},
28626 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
28627 { (char *)"new_PseudoDC", (PyCFunction)_wrap_new_PseudoDC, METH_NOARGS, NULL},
28628 { (char *)"PseudoDC_BeginDrawing", (PyCFunction)_wrap_PseudoDC_BeginDrawing, METH_O, NULL},
28629 { (char *)"PseudoDC_EndDrawing", (PyCFunction)_wrap_PseudoDC_EndDrawing, METH_O, NULL},
28630 { (char *)"delete_PseudoDC", (PyCFunction)_wrap_delete_PseudoDC, METH_O, NULL},
28631 { (char *)"PseudoDC_RemoveAll", (PyCFunction)_wrap_PseudoDC_RemoveAll, METH_O, NULL},
28632 { (char *)"PseudoDC_GetLen", (PyCFunction)_wrap_PseudoDC_GetLen, METH_O, NULL},
28633 { (char *)"PseudoDC_SetId", (PyCFunction) _wrap_PseudoDC_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
28634 { (char *)"PseudoDC_ClearId", (PyCFunction) _wrap_PseudoDC_ClearId, METH_VARARGS | METH_KEYWORDS, NULL},
28635 { (char *)"PseudoDC_RemoveId", (PyCFunction) _wrap_PseudoDC_RemoveId, METH_VARARGS | METH_KEYWORDS, NULL},
28636 { (char *)"PseudoDC_TranslateId", (PyCFunction) _wrap_PseudoDC_TranslateId, METH_VARARGS | METH_KEYWORDS, NULL},
28637 { (char *)"PseudoDC_DrawIdToDC", (PyCFunction) _wrap_PseudoDC_DrawIdToDC, METH_VARARGS | METH_KEYWORDS, NULL},
28638 { (char *)"PseudoDC_SetIdBounds", (PyCFunction) _wrap_PseudoDC_SetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
28639 { (char *)"PseudoDC_GetIdBounds", (PyCFunction) _wrap_PseudoDC_GetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
28640 { (char *)"PseudoDC_DrawToDCClipped", (PyCFunction) _wrap_PseudoDC_DrawToDCClipped, METH_VARARGS | METH_KEYWORDS, NULL},
28641 { (char *)"PseudoDC_DrawToDCClippedRgn", (PyCFunction) _wrap_PseudoDC_DrawToDCClippedRgn, METH_VARARGS | METH_KEYWORDS, NULL},
28642 { (char *)"PseudoDC_DrawToDC", (PyCFunction) _wrap_PseudoDC_DrawToDC, METH_VARARGS | METH_KEYWORDS, NULL},
28643 { (char *)"PseudoDC_FloodFill", (PyCFunction) _wrap_PseudoDC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
28644 { (char *)"PseudoDC_FloodFillPoint", (PyCFunction) _wrap_PseudoDC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28645 { (char *)"PseudoDC_DrawLine", (PyCFunction) _wrap_PseudoDC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
28646 { (char *)"PseudoDC_DrawLinePoint", (PyCFunction) _wrap_PseudoDC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
28647 { (char *)"PseudoDC_CrossHair", (PyCFunction) _wrap_PseudoDC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
28648 { (char *)"PseudoDC_CrossHairPoint", (PyCFunction) _wrap_PseudoDC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28649 { (char *)"PseudoDC_DrawArc", (PyCFunction) _wrap_PseudoDC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
28650 { (char *)"PseudoDC_DrawArcPoint", (PyCFunction) _wrap_PseudoDC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28651 { (char *)"PseudoDC_DrawCheckMark", (PyCFunction) _wrap_PseudoDC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
28652 { (char *)"PseudoDC_DrawCheckMarkRect", (PyCFunction) _wrap_PseudoDC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
28653 { (char *)"PseudoDC_DrawEllipticArc", (PyCFunction) _wrap_PseudoDC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
28654 { (char *)"PseudoDC_DrawEllipticArcPointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28655 { (char *)"PseudoDC_DrawPoint", (PyCFunction) _wrap_PseudoDC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28656 { (char *)"PseudoDC_DrawPointPoint", (PyCFunction) _wrap_PseudoDC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28657 { (char *)"PseudoDC_DrawRectangle", (PyCFunction) _wrap_PseudoDC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
28658 { (char *)"PseudoDC_DrawRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
28659 { (char *)"PseudoDC_DrawRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28660 { (char *)"PseudoDC_DrawRoundedRectangle", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
28661 { (char *)"PseudoDC_DrawRoundedRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
28662 { (char *)"PseudoDC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28663 { (char *)"PseudoDC_DrawCircle", (PyCFunction) _wrap_PseudoDC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
28664 { (char *)"PseudoDC_DrawCirclePoint", (PyCFunction) _wrap_PseudoDC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
28665 { (char *)"PseudoDC_DrawEllipse", (PyCFunction) _wrap_PseudoDC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
28666 { (char *)"PseudoDC_DrawEllipseRect", (PyCFunction) _wrap_PseudoDC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
28667 { (char *)"PseudoDC_DrawEllipsePointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
28668 { (char *)"PseudoDC_DrawIcon", (PyCFunction) _wrap_PseudoDC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
28669 { (char *)"PseudoDC_DrawIconPoint", (PyCFunction) _wrap_PseudoDC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28670 { (char *)"PseudoDC_DrawBitmap", (PyCFunction) _wrap_PseudoDC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
28671 { (char *)"PseudoDC_DrawBitmapPoint", (PyCFunction) _wrap_PseudoDC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28672 { (char *)"PseudoDC_DrawText", (PyCFunction) _wrap_PseudoDC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
28673 { (char *)"PseudoDC_DrawTextPoint", (PyCFunction) _wrap_PseudoDC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28674 { (char *)"PseudoDC_DrawRotatedText", (PyCFunction) _wrap_PseudoDC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
28675 { (char *)"PseudoDC_DrawRotatedTextPoint", (PyCFunction) _wrap_PseudoDC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
28676 { (char *)"PseudoDC_DrawLines", (PyCFunction) _wrap_PseudoDC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
28677 { (char *)"PseudoDC_DrawPolygon", (PyCFunction) _wrap_PseudoDC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
28678 { (char *)"PseudoDC_DrawLabel", (PyCFunction) _wrap_PseudoDC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
28679 { (char *)"PseudoDC_DrawImageLabel", (PyCFunction) _wrap_PseudoDC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
28680 { (char *)"PseudoDC_DrawSpline", (PyCFunction) _wrap_PseudoDC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
28681 { (char *)"PseudoDC_Clear", (PyCFunction)_wrap_PseudoDC_Clear, METH_O, NULL},
28682 { (char *)"PseudoDC_SetFont", (PyCFunction) _wrap_PseudoDC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
28683 { (char *)"PseudoDC_SetPen", (PyCFunction) _wrap_PseudoDC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
28684 { (char *)"PseudoDC_SetBrush", (PyCFunction) _wrap_PseudoDC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
28685 { (char *)"PseudoDC_SetBackground", (PyCFunction) _wrap_PseudoDC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28686 { (char *)"PseudoDC_SetBackgroundMode", (PyCFunction) _wrap_PseudoDC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
28687 { (char *)"PseudoDC_SetPalette", (PyCFunction) _wrap_PseudoDC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
28688 { (char *)"PseudoDC_SetTextForeground", (PyCFunction) _wrap_PseudoDC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
28689 { (char *)"PseudoDC_SetTextBackground", (PyCFunction) _wrap_PseudoDC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
28690 { (char *)"PseudoDC_SetLogicalFunction", (PyCFunction) _wrap_PseudoDC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
28691 { (char *)"PseudoDC_swigregister", PseudoDC_swigregister, METH_VARARGS, NULL},
28692 { (char *)"PseudoDC_swiginit", PseudoDC_swiginit, METH_VARARGS, NULL},
28693 { NULL, NULL, 0, NULL }
28694 };
28695
28696
28697 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
28698
28699 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
28700 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
28701 }
28702 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
28703 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
28704 }
28705 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
28706 return (void *)((wxGDIObject *) ((wxIcon *) x));
28707 }
28708 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
28709 return (void *)((wxGDIObject *) ((wxPalette *) x));
28710 }
28711 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
28712 return (void *)((wxGDIObject *) ((wxPen *) x));
28713 }
28714 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
28715 return (void *)((wxGDIObject *) ((wxFont *) x));
28716 }
28717 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
28718 return (void *)((wxGDIObject *) ((wxCursor *) x));
28719 }
28720 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
28721 return (void *)((wxGDIObject *) ((wxBitmap *) x));
28722 }
28723 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
28724 return (void *)((wxGDIObject *) ((wxRegion *) x));
28725 }
28726 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
28727 return (void *)((wxGDIObject *) ((wxBrush *) x));
28728 }
28729 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
28730 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
28731 }
28732 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
28733 return (void *)((wxDC *) ((wxScreenDC *) x));
28734 }
28735 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
28736 return (void *)((wxDC *) ((wxMirrorDC *) x));
28737 }
28738 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
28739 return (void *)((wxDC *) ((wxMemoryDC *) x));
28740 }
28741 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
28742 return (void *)((wxDC *) ((wxWindowDC *) x));
28743 }
28744 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
28745 return (void *)((wxDC *) ((wxMetaFileDC *) x));
28746 }
28747 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
28748 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
28749 }
28750 static void *_p_wxClientDCTo_p_wxDC(void *x) {
28751 return (void *)((wxDC *) ((wxClientDC *) x));
28752 }
28753 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
28754 return (void *)((wxDC *) ((wxPaintDC *) x));
28755 }
28756 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
28757 return (void *)((wxDC *) ((wxPostScriptDC *) x));
28758 }
28759 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
28760 return (void *)((wxDC *) ((wxPrinterDC *) x));
28761 }
28762 static void *_p_wxBrushListTo_p_wxGDIObjListBase(void *x) {
28763 return (void *)((wxGDIObjListBase *) ((wxBrushList *) x));
28764 }
28765 static void *_p_wxFontListTo_p_wxGDIObjListBase(void *x) {
28766 return (void *)((wxGDIObjListBase *) ((wxFontList *) x));
28767 }
28768 static void *_p_wxPenListTo_p_wxGDIObjListBase(void *x) {
28769 return (void *)((wxGDIObjListBase *) ((wxPenList *) x));
28770 }
28771 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
28772 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
28773 }
28774 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
28775 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
28776 }
28777 static void *_p_wxPenTo_p_wxObject(void *x) {
28778 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
28779 }
28780 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
28781 return (void *)((wxObject *) ((wxRegionIterator *) x));
28782 }
28783 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
28784 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
28785 }
28786 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
28787 return (void *)((wxObject *) ((wxSizerItem *) x));
28788 }
28789 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
28790 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
28791 }
28792 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
28793 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
28794 }
28795 static void *_p_wxIconTo_p_wxObject(void *x) {
28796 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
28797 }
28798 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
28799 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
28800 }
28801 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
28802 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
28803 }
28804 static void *_p_wxSizerTo_p_wxObject(void *x) {
28805 return (void *)((wxObject *) ((wxSizer *) x));
28806 }
28807 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
28808 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
28809 }
28810 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
28811 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
28812 }
28813 static void *_p_wxEventTo_p_wxObject(void *x) {
28814 return (void *)((wxObject *) ((wxEvent *) x));
28815 }
28816 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
28817 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
28818 }
28819 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
28820 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
28821 }
28822 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
28823 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
28824 }
28825 static void *_p_wxPseudoDCTo_p_wxObject(void *x) {
28826 return (void *)((wxObject *) ((wxPseudoDC *) x));
28827 }
28828 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
28829 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
28830 }
28831 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
28832 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
28833 }
28834 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
28835 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
28836 }
28837 static void *_p_wxDCTo_p_wxObject(void *x) {
28838 return (void *)((wxObject *) ((wxDC *) x));
28839 }
28840 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
28841 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
28842 }
28843 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
28844 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
28845 }
28846 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
28847 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
28848 }
28849 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
28850 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
28851 }
28852 static void *_p_wxControlTo_p_wxObject(void *x) {
28853 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
28854 }
28855 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
28856 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
28857 }
28858 static void *_p_wxClientDCTo_p_wxObject(void *x) {
28859 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
28860 }
28861 static void *_p_wxFSFileTo_p_wxObject(void *x) {
28862 return (void *)((wxObject *) ((wxFSFile *) x));
28863 }
28864 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
28865 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
28866 }
28867 static void *_p_wxRegionTo_p_wxObject(void *x) {
28868 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
28869 }
28870 static void *_p_wxPySizerTo_p_wxObject(void *x) {
28871 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
28872 }
28873 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
28874 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
28875 }
28876 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
28877 return (void *)((wxObject *) ((wxGDIObject *) x));
28878 }
28879 static void *_p_wxEffectsTo_p_wxObject(void *x) {
28880 return (void *)((wxObject *) ((wxEffects *) x));
28881 }
28882 static void *_p_wxPyEventTo_p_wxObject(void *x) {
28883 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
28884 }
28885 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
28886 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
28887 }
28888 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
28889 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
28890 }
28891 static void *_p_wxShowEventTo_p_wxObject(void *x) {
28892 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
28893 }
28894 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
28895 return (void *)((wxObject *) ((wxMenuItem *) x));
28896 }
28897 static void *_p_wxDateEventTo_p_wxObject(void *x) {
28898 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
28899 }
28900 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
28901 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
28902 }
28903 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
28904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
28905 }
28906 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
28907 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
28908 }
28909 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
28910 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
28911 }
28912 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
28913 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
28914 }
28915 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
28916 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
28917 }
28918 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
28919 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
28920 }
28921 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
28922 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
28923 }
28924 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
28925 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
28926 }
28927 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
28928 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
28929 }
28930 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
28931 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
28932 }
28933 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
28934 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
28935 }
28936 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
28937 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
28938 }
28939 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
28940 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
28941 }
28942 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
28943 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
28944 }
28945 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
28946 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
28947 }
28948 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
28949 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
28950 }
28951 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
28952 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
28953 }
28954 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
28955 return (void *)((wxObject *) ((wxImageHandler *) x));
28956 }
28957 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
28958 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
28959 }
28960 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
28961 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
28962 }
28963 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
28964 return (void *)((wxObject *) ((wxEvtHandler *) x));
28965 }
28966 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
28967 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
28968 }
28969 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
28970 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
28971 }
28972 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
28973 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
28974 }
28975 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
28976 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
28977 }
28978 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
28979 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
28980 }
28981 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
28982 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
28983 }
28984 static void *_p_wxImageTo_p_wxObject(void *x) {
28985 return (void *)((wxObject *) ((wxImage *) x));
28986 }
28987 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
28988 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
28989 }
28990 static void *_p_wxPaletteTo_p_wxObject(void *x) {
28991 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
28992 }
28993 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
28994 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
28995 }
28996 static void *_p_wxImageListTo_p_wxObject(void *x) {
28997 return (void *)((wxObject *) ((wxImageList *) x));
28998 }
28999 static void *_p_wxCursorTo_p_wxObject(void *x) {
29000 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
29001 }
29002 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
29003 return (void *)((wxObject *) ((wxEncodingConverter *) x));
29004 }
29005 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
29006 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
29007 }
29008 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
29009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
29010 }
29011 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
29012 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
29013 }
29014 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
29015 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
29016 }
29017 static void *_p_wxWindowTo_p_wxObject(void *x) {
29018 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
29019 }
29020 static void *_p_wxMenuTo_p_wxObject(void *x) {
29021 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
29022 }
29023 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
29024 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
29025 }
29026 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
29027 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
29028 }
29029 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
29030 return (void *)((wxObject *) ((wxFileSystem *) x));
29031 }
29032 static void *_p_wxBitmapTo_p_wxObject(void *x) {
29033 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
29034 }
29035 static void *_p_wxMaskTo_p_wxObject(void *x) {
29036 return (void *)((wxObject *) ((wxMask *) x));
29037 }
29038 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
29039 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
29040 }
29041 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
29042 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
29043 }
29044 static void *_p_wxPyAppTo_p_wxObject(void *x) {
29045 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
29046 }
29047 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
29048 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
29049 }
29050 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
29051 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
29052 }
29053 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
29054 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
29055 }
29056 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
29057 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
29058 }
29059 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
29060 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
29061 }
29062 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
29063 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
29064 }
29065 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
29066 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
29067 }
29068 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
29069 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
29070 }
29071 static void *_p_wxFontTo_p_wxObject(void *x) {
29072 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
29073 }
29074 static void *_p_wxBrushTo_p_wxObject(void *x) {
29075 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
29076 }
29077 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
29078 return (void *)((wxObject *) ((wxMetaFile *) x));
29079 }
29080 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
29081 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
29082 }
29083 static void *_p_wxColourTo_p_wxObject(void *x) {
29084 return (void *)((wxObject *) ((wxColour *) x));
29085 }
29086 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
29087 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
29088 }
29089 static void *_p_wxValidatorTo_p_wxObject(void *x) {
29090 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
29091 }
29092 static void *_p_wxControlTo_p_wxWindow(void *x) {
29093 return (void *)((wxWindow *) ((wxControl *) x));
29094 }
29095 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
29096 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
29097 }
29098 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
29099 return (void *)((wxWindow *) ((wxMenuBar *) x));
29100 }
29101 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
29102 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
29103 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};
29104 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
29105 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
29106 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
29107 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
29108 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
29109 static swig_type_info _swigt__p_wxBrush = {"_p_wxBrush", "wxBrush *", 0, 0, (void*)0, 0};
29110 static swig_type_info _swigt__p_wxBrushList = {"_p_wxBrushList", "wxBrushList *", 0, 0, (void*)0, 0};
29111 static swig_type_info _swigt__p_wxBufferedDC = {"_p_wxBufferedDC", "wxBufferedDC *", 0, 0, (void*)0, 0};
29112 static swig_type_info _swigt__p_wxBufferedPaintDC = {"_p_wxBufferedPaintDC", "wxBufferedPaintDC *", 0, 0, (void*)0, 0};
29113 static swig_type_info _swigt__p_wxClientDC = {"_p_wxClientDC", "wxClientDC *", 0, 0, (void*)0, 0};
29114 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
29115 static swig_type_info _swigt__p_wxColourDatabase = {"_p_wxColourDatabase", "wxColourDatabase *", 0, 0, (void*)0, 0};
29116 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
29117 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
29118 static swig_type_info _swigt__p_wxDash = {"_p_wxDash", "wxDash *", 0, 0, (void*)0, 0};
29119 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
29120 static swig_type_info _swigt__p_wxEffects = {"_p_wxEffects", "wxEffects *", 0, 0, (void*)0, 0};
29121 static swig_type_info _swigt__p_wxEncodingConverter = {"_p_wxEncodingConverter", "wxEncodingConverter *", 0, 0, (void*)0, 0};
29122 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
29123 static swig_type_info _swigt__p_wxFontList = {"_p_wxFontList", "wxFontList *", 0, 0, (void*)0, 0};
29124 static swig_type_info _swigt__p_wxFontMapper = {"_p_wxFontMapper", "wxFontMapper *", 0, 0, (void*)0, 0};
29125 static swig_type_info _swigt__p_wxGDIObjListBase = {"_p_wxGDIObjListBase", "wxGDIObjListBase *", 0, 0, (void*)0, 0};
29126 static swig_type_info _swigt__p_wxGDIObject = {"_p_wxGDIObject", "wxGDIObject *", 0, 0, (void*)0, 0};
29127 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
29128 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
29129 static swig_type_info _swigt__p_wxIconLocation = {"_p_wxIconLocation", "wxIconLocation *", 0, 0, (void*)0, 0};
29130 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
29131 static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
29132 static swig_type_info _swigt__p_wxLanguageInfo = {"_p_wxLanguageInfo", "wxLanguageInfo *", 0, 0, (void*)0, 0};
29133 static swig_type_info _swigt__p_wxLocale = {"_p_wxLocale", "wxLocale *", 0, 0, (void*)0, 0};
29134 static swig_type_info _swigt__p_wxMask = {"_p_wxMask", "wxMask *", 0, 0, (void*)0, 0};
29135 static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
29136 static swig_type_info _swigt__p_wxMetaFile = {"_p_wxMetaFile", "wxMetaFile *", 0, 0, (void*)0, 0};
29137 static swig_type_info _swigt__p_wxMetaFileDC = {"_p_wxMetaFileDC", "wxMetaFileDC *", 0, 0, (void*)0, 0};
29138 static swig_type_info _swigt__p_wxMirrorDC = {"_p_wxMirrorDC", "wxMirrorDC *", 0, 0, (void*)0, 0};
29139 static swig_type_info _swigt__p_wxNativeEncodingInfo = {"_p_wxNativeEncodingInfo", "wxNativeEncodingInfo *", 0, 0, (void*)0, 0};
29140 static swig_type_info _swigt__p_wxNativeFontInfo = {"_p_wxNativeFontInfo", "wxNativeFontInfo *", 0, 0, (void*)0, 0};
29141 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
29142 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
29143 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
29144 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
29145 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
29146 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
29147 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
29148 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
29149 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
29150 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
29151 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
29152 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
29153 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
29154 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
29155 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
29156 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
29157 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
29158 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
29159 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
29160 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
29161 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
29162 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
29163 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
29164 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
29165 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
29166 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
29167 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
29168 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
29169 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
29170 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
29171 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
29172 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
29173 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
29174 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
29175 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
29176 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
29177 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
29178 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
29179 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
29180 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
29181 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
29182 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
29183 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
29184 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
29185 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
29186 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
29187 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
29188 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
29189 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
29190 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
29191 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
29192 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
29193 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
29194 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
29195 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
29196 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
29197 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
29198 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
29199 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
29200 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
29201 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
29202 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
29203 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
29204 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
29205 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
29206 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
29207 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
29208 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
29209 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
29210 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
29211 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
29212 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
29213 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
29214 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
29215 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
29216 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
29217 static swig_type_info _swigt__p_wxPaintDC = {"_p_wxPaintDC", "wxPaintDC *", 0, 0, (void*)0, 0};
29218 static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, (void*)0, 0};
29219 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
29220 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
29221 static swig_type_info _swigt__p_wxPenList = {"_p_wxPenList", "wxPenList *", 0, 0, (void*)0, 0};
29222 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
29223 static swig_type_info _swigt__p_wxPostScriptDC = {"_p_wxPostScriptDC", "wxPostScriptDC *", 0, 0, (void*)0, 0};
29224 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};
29225 static swig_type_info _swigt__p_wxPrinterDC = {"_p_wxPrinterDC", "wxPrinterDC *", 0, 0, (void*)0, 0};
29226 static swig_type_info _swigt__p_wxPseudoDC = {"_p_wxPseudoDC", "wxPseudoDC *", 0, 0, (void*)0, 0};
29227 static swig_type_info _swigt__p_wxPyFontEnumerator = {"_p_wxPyFontEnumerator", "wxPyFontEnumerator *", 0, 0, (void*)0, 0};
29228 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
29229 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
29230 static swig_type_info _swigt__p_wxRegionIterator = {"_p_wxRegionIterator", "wxRegionIterator *", 0, 0, (void*)0, 0};
29231 static swig_type_info _swigt__p_wxRendererNative = {"_p_wxRendererNative", "wxRendererNative *", 0, 0, (void*)0, 0};
29232 static swig_type_info _swigt__p_wxRendererVersion = {"_p_wxRendererVersion", "wxRendererVersion *", 0, 0, (void*)0, 0};
29233 static swig_type_info _swigt__p_wxScreenDC = {"_p_wxScreenDC", "wxScreenDC *", 0, 0, (void*)0, 0};
29234 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
29235 static swig_type_info _swigt__p_wxSplitterRenderParams = {"_p_wxSplitterRenderParams", "wxSplitterRenderParams *", 0, 0, (void*)0, 0};
29236 static swig_type_info _swigt__p_wxStockGDI = {"_p_wxStockGDI", "wxStockGDI *", 0, 0, (void*)0, 0};
29237 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
29238 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
29239 static swig_type_info _swigt__p_wxWindowDC = {"_p_wxWindowDC", "wxWindowDC *", 0, 0, (void*)0, 0};
29240
29241 static swig_type_info *swig_type_initial[] = {
29242 &_swigt__p_char,
29243 &_swigt__p_double,
29244 &_swigt__p_form_ops_t,
29245 &_swigt__p_int,
29246 &_swigt__p_unsigned_char,
29247 &_swigt__p_unsigned_int,
29248 &_swigt__p_unsigned_long,
29249 &_swigt__p_wxANIHandler,
29250 &_swigt__p_wxAcceleratorTable,
29251 &_swigt__p_wxActivateEvent,
29252 &_swigt__p_wxBMPHandler,
29253 &_swigt__p_wxBitmap,
29254 &_swigt__p_wxBoxSizer,
29255 &_swigt__p_wxBrush,
29256 &_swigt__p_wxBrushList,
29257 &_swigt__p_wxBufferedDC,
29258 &_swigt__p_wxBufferedPaintDC,
29259 &_swigt__p_wxCURHandler,
29260 &_swigt__p_wxChildFocusEvent,
29261 &_swigt__p_wxClientDC,
29262 &_swigt__p_wxClipboardTextEvent,
29263 &_swigt__p_wxCloseEvent,
29264 &_swigt__p_wxColour,
29265 &_swigt__p_wxColourDatabase,
29266 &_swigt__p_wxCommandEvent,
29267 &_swigt__p_wxContextMenuEvent,
29268 &_swigt__p_wxControl,
29269 &_swigt__p_wxControlWithItems,
29270 &_swigt__p_wxCursor,
29271 &_swigt__p_wxDC,
29272 &_swigt__p_wxDash,
29273 &_swigt__p_wxDateEvent,
29274 &_swigt__p_wxDisplayChangedEvent,
29275 &_swigt__p_wxDropFilesEvent,
29276 &_swigt__p_wxDuplexMode,
29277 &_swigt__p_wxEffects,
29278 &_swigt__p_wxEncodingConverter,
29279 &_swigt__p_wxEraseEvent,
29280 &_swigt__p_wxEvent,
29281 &_swigt__p_wxEvtHandler,
29282 &_swigt__p_wxFSFile,
29283 &_swigt__p_wxFileSystem,
29284 &_swigt__p_wxFlexGridSizer,
29285 &_swigt__p_wxFocusEvent,
29286 &_swigt__p_wxFont,
29287 &_swigt__p_wxFontList,
29288 &_swigt__p_wxFontMapper,
29289 &_swigt__p_wxGBSizerItem,
29290 &_swigt__p_wxGDIObjListBase,
29291 &_swigt__p_wxGDIObject,
29292 &_swigt__p_wxGIFHandler,
29293 &_swigt__p_wxGridBagSizer,
29294 &_swigt__p_wxGridSizer,
29295 &_swigt__p_wxICOHandler,
29296 &_swigt__p_wxIcon,
29297 &_swigt__p_wxIconBundle,
29298 &_swigt__p_wxIconLocation,
29299 &_swigt__p_wxIconizeEvent,
29300 &_swigt__p_wxIdleEvent,
29301 &_swigt__p_wxImage,
29302 &_swigt__p_wxImageHandler,
29303 &_swigt__p_wxImageList,
29304 &_swigt__p_wxIndividualLayoutConstraint,
29305 &_swigt__p_wxInitDialogEvent,
29306 &_swigt__p_wxJPEGHandler,
29307 &_swigt__p_wxKeyEvent,
29308 &_swigt__p_wxLanguageInfo,
29309 &_swigt__p_wxLayoutConstraints,
29310 &_swigt__p_wxLocale,
29311 &_swigt__p_wxMask,
29312 &_swigt__p_wxMaximizeEvent,
29313 &_swigt__p_wxMemoryDC,
29314 &_swigt__p_wxMenu,
29315 &_swigt__p_wxMenuBar,
29316 &_swigt__p_wxMenuEvent,
29317 &_swigt__p_wxMenuItem,
29318 &_swigt__p_wxMetaFile,
29319 &_swigt__p_wxMetaFileDC,
29320 &_swigt__p_wxMirrorDC,
29321 &_swigt__p_wxMouseCaptureChangedEvent,
29322 &_swigt__p_wxMouseEvent,
29323 &_swigt__p_wxMoveEvent,
29324 &_swigt__p_wxNativeEncodingInfo,
29325 &_swigt__p_wxNativeFontInfo,
29326 &_swigt__p_wxNavigationKeyEvent,
29327 &_swigt__p_wxNcPaintEvent,
29328 &_swigt__p_wxNotifyEvent,
29329 &_swigt__p_wxObject,
29330 &_swigt__p_wxPCXHandler,
29331 &_swigt__p_wxPNGHandler,
29332 &_swigt__p_wxPNMHandler,
29333 &_swigt__p_wxPaintDC,
29334 &_swigt__p_wxPaintEvent,
29335 &_swigt__p_wxPalette,
29336 &_swigt__p_wxPaletteChangedEvent,
29337 &_swigt__p_wxPaperSize,
29338 &_swigt__p_wxPen,
29339 &_swigt__p_wxPenList,
29340 &_swigt__p_wxPoint,
29341 &_swigt__p_wxPostScriptDC,
29342 &_swigt__p_wxPrintData,
29343 &_swigt__p_wxPrinterDC,
29344 &_swigt__p_wxPseudoDC,
29345 &_swigt__p_wxPyApp,
29346 &_swigt__p_wxPyCommandEvent,
29347 &_swigt__p_wxPyEvent,
29348 &_swigt__p_wxPyFontEnumerator,
29349 &_swigt__p_wxPyImageHandler,
29350 &_swigt__p_wxPySizer,
29351 &_swigt__p_wxPyValidator,
29352 &_swigt__p_wxQueryNewPaletteEvent,
29353 &_swigt__p_wxRect,
29354 &_swigt__p_wxRegion,
29355 &_swigt__p_wxRegionIterator,
29356 &_swigt__p_wxRendererNative,
29357 &_swigt__p_wxRendererVersion,
29358 &_swigt__p_wxScreenDC,
29359 &_swigt__p_wxScrollEvent,
29360 &_swigt__p_wxScrollWinEvent,
29361 &_swigt__p_wxSetCursorEvent,
29362 &_swigt__p_wxShowEvent,
29363 &_swigt__p_wxSize,
29364 &_swigt__p_wxSizeEvent,
29365 &_swigt__p_wxSizer,
29366 &_swigt__p_wxSizerItem,
29367 &_swigt__p_wxSplitterRenderParams,
29368 &_swigt__p_wxStaticBoxSizer,
29369 &_swigt__p_wxStdDialogButtonSizer,
29370 &_swigt__p_wxStockGDI,
29371 &_swigt__p_wxString,
29372 &_swigt__p_wxSysColourChangedEvent,
29373 &_swigt__p_wxTIFFHandler,
29374 &_swigt__p_wxUpdateUIEvent,
29375 &_swigt__p_wxValidator,
29376 &_swigt__p_wxWindow,
29377 &_swigt__p_wxWindowCreateEvent,
29378 &_swigt__p_wxWindowDC,
29379 &_swigt__p_wxWindowDestroyEvent,
29380 &_swigt__p_wxXPMHandler,
29381 };
29382
29383 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
29384 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
29385 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
29386 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
29387 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
29388 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
29389 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
29390 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
29391 static swig_cast_info _swigc__p_wxBrush[] = { {&_swigt__p_wxBrush, 0, 0, 0},{0, 0, 0, 0}};
29392 static swig_cast_info _swigc__p_wxBrushList[] = { {&_swigt__p_wxBrushList, 0, 0, 0},{0, 0, 0, 0}};
29393 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}};
29394 static swig_cast_info _swigc__p_wxBufferedPaintDC[] = { {&_swigt__p_wxBufferedPaintDC, 0, 0, 0},{0, 0, 0, 0}};
29395 static swig_cast_info _swigc__p_wxClientDC[] = { {&_swigt__p_wxClientDC, 0, 0, 0},{0, 0, 0, 0}};
29396 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
29397 static swig_cast_info _swigc__p_wxColourDatabase[] = { {&_swigt__p_wxColourDatabase, 0, 0, 0},{0, 0, 0, 0}};
29398 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
29399 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}};
29400 static swig_cast_info _swigc__p_wxDash[] = { {&_swigt__p_wxDash, 0, 0, 0},{0, 0, 0, 0}};
29401 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
29402 static swig_cast_info _swigc__p_wxEffects[] = { {&_swigt__p_wxEffects, 0, 0, 0},{0, 0, 0, 0}};
29403 static swig_cast_info _swigc__p_wxEncodingConverter[] = { {&_swigt__p_wxEncodingConverter, 0, 0, 0},{0, 0, 0, 0}};
29404 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
29405 static swig_cast_info _swigc__p_wxFontList[] = { {&_swigt__p_wxFontList, 0, 0, 0},{0, 0, 0, 0}};
29406 static swig_cast_info _swigc__p_wxFontMapper[] = { {&_swigt__p_wxFontMapper, 0, 0, 0},{0, 0, 0, 0}};
29407 static swig_cast_info _swigc__p_wxGDIObjListBase[] = { {&_swigt__p_wxGDIObjListBase, 0, 0, 0}, {&_swigt__p_wxBrushList, _p_wxBrushListTo_p_wxGDIObjListBase, 0, 0}, {&_swigt__p_wxFontList, _p_wxFontListTo_p_wxGDIObjListBase, 0, 0}, {&_swigt__p_wxPenList, _p_wxPenListTo_p_wxGDIObjListBase, 0, 0},{0, 0, 0, 0}};
29408 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}};
29409 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
29410 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
29411 static swig_cast_info _swigc__p_wxIconLocation[] = { {&_swigt__p_wxIconLocation, 0, 0, 0},{0, 0, 0, 0}};
29412 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
29413 static swig_cast_info _swigc__p_wxImageList[] = { {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
29414 static swig_cast_info _swigc__p_wxLanguageInfo[] = { {&_swigt__p_wxLanguageInfo, 0, 0, 0},{0, 0, 0, 0}};
29415 static swig_cast_info _swigc__p_wxLocale[] = { {&_swigt__p_wxLocale, 0, 0, 0},{0, 0, 0, 0}};
29416 static swig_cast_info _swigc__p_wxMask[] = { {&_swigt__p_wxMask, 0, 0, 0},{0, 0, 0, 0}};
29417 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}};
29418 static swig_cast_info _swigc__p_wxMetaFile[] = { {&_swigt__p_wxMetaFile, 0, 0, 0},{0, 0, 0, 0}};
29419 static swig_cast_info _swigc__p_wxMetaFileDC[] = { {&_swigt__p_wxMetaFileDC, 0, 0, 0},{0, 0, 0, 0}};
29420 static swig_cast_info _swigc__p_wxMirrorDC[] = { {&_swigt__p_wxMirrorDC, 0, 0, 0},{0, 0, 0, 0}};
29421 static swig_cast_info _swigc__p_wxNativeEncodingInfo[] = { {&_swigt__p_wxNativeEncodingInfo, 0, 0, 0},{0, 0, 0, 0}};
29422 static swig_cast_info _swigc__p_wxNativeFontInfo[] = { {&_swigt__p_wxNativeFontInfo, 0, 0, 0},{0, 0, 0, 0}};
29423 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
29424 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
29425 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
29426 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
29427 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
29428 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
29429 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
29430 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
29431 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
29432 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
29433 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
29434 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
29435 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
29436 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
29437 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
29438 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
29439 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
29440 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
29441 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
29442 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
29443 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
29444 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
29445 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
29446 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
29447 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
29448 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
29449 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
29450 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
29451 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
29452 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
29453 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
29454 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
29455 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
29456 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
29457 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
29458 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
29459 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
29460 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
29461 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
29462 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
29463 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
29464 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
29465 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
29466 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
29467 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
29468 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
29469 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
29470 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
29471 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
29472 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
29473 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
29474 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
29475 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
29476 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
29477 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
29478 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
29479 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
29480 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
29481 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
29482 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
29483 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
29484 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
29485 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
29486 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
29487 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
29488 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
29489 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
29490 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
29491 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
29492 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
29493 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
29494 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
29495 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
29496 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
29497 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
29498 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_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMask, _p_wxMaskTo_p_wxObject, 0, 0}, {&_swigt__p_wxPseudoDC, _p_wxPseudoDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxFont, _p_wxFontTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClientDC, _p_wxClientDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxMemoryDC, _p_wxMemoryDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxRegion, _p_wxRegionTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxDC, _p_wxDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxIcon, _p_wxIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDC, _p_wxWindowDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxGDIObject, _p_wxGDIObjectTo_p_wxObject, 0, 0}, {&_swigt__p_wxEffects, _p_wxEffectsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPostScriptDC, _p_wxPostScriptDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintDC, _p_wxPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinterDC, _p_wxPrinterDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxScreenDC, _p_wxScreenDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBufferedDC, _p_wxBufferedDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPalette, _p_wxPaletteTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageList, _p_wxImageListTo_p_wxObject, 0, 0}, {&_swigt__p_wxCursor, _p_wxCursorTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxMirrorDC, _p_wxMirrorDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxEncodingConverter, _p_wxEncodingConverterTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFileDC, _p_wxMetaFileDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxBitmap, _p_wxBitmapTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBrush, _p_wxBrushTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFile, _p_wxMetaFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxColour, _p_wxColourTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
29499 static swig_cast_info _swigc__p_wxPaintDC[] = { {&_swigt__p_wxPaintDC, 0, 0, 0},{0, 0, 0, 0}};
29500 static swig_cast_info _swigc__p_wxPalette[] = { {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
29501 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
29502 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
29503 static swig_cast_info _swigc__p_wxPenList[] = { {&_swigt__p_wxPenList, 0, 0, 0},{0, 0, 0, 0}};
29504 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
29505 static swig_cast_info _swigc__p_wxPostScriptDC[] = { {&_swigt__p_wxPostScriptDC, 0, 0, 0},{0, 0, 0, 0}};
29506 static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
29507 static swig_cast_info _swigc__p_wxPrinterDC[] = { {&_swigt__p_wxPrinterDC, 0, 0, 0},{0, 0, 0, 0}};
29508 static swig_cast_info _swigc__p_wxPseudoDC[] = { {&_swigt__p_wxPseudoDC, 0, 0, 0},{0, 0, 0, 0}};
29509 static swig_cast_info _swigc__p_wxPyFontEnumerator[] = { {&_swigt__p_wxPyFontEnumerator, 0, 0, 0},{0, 0, 0, 0}};
29510 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
29511 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
29512 static swig_cast_info _swigc__p_wxRegionIterator[] = { {&_swigt__p_wxRegionIterator, 0, 0, 0},{0, 0, 0, 0}};
29513 static swig_cast_info _swigc__p_wxRendererNative[] = { {&_swigt__p_wxRendererNative, 0, 0, 0},{0, 0, 0, 0}};
29514 static swig_cast_info _swigc__p_wxRendererVersion[] = { {&_swigt__p_wxRendererVersion, 0, 0, 0},{0, 0, 0, 0}};
29515 static swig_cast_info _swigc__p_wxScreenDC[] = { {&_swigt__p_wxScreenDC, 0, 0, 0},{0, 0, 0, 0}};
29516 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
29517 static swig_cast_info _swigc__p_wxSplitterRenderParams[] = { {&_swigt__p_wxSplitterRenderParams, 0, 0, 0},{0, 0, 0, 0}};
29518 static swig_cast_info _swigc__p_wxStockGDI[] = { {&_swigt__p_wxStockGDI, 0, 0, 0},{0, 0, 0, 0}};
29519 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
29520 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}};
29521 static swig_cast_info _swigc__p_wxWindowDC[] = { {&_swigt__p_wxWindowDC, 0, 0, 0},{0, 0, 0, 0}};
29522
29523 static swig_cast_info *swig_cast_initial[] = {
29524 _swigc__p_char,
29525 _swigc__p_double,
29526 _swigc__p_form_ops_t,
29527 _swigc__p_int,
29528 _swigc__p_unsigned_char,
29529 _swigc__p_unsigned_int,
29530 _swigc__p_unsigned_long,
29531 _swigc__p_wxANIHandler,
29532 _swigc__p_wxAcceleratorTable,
29533 _swigc__p_wxActivateEvent,
29534 _swigc__p_wxBMPHandler,
29535 _swigc__p_wxBitmap,
29536 _swigc__p_wxBoxSizer,
29537 _swigc__p_wxBrush,
29538 _swigc__p_wxBrushList,
29539 _swigc__p_wxBufferedDC,
29540 _swigc__p_wxBufferedPaintDC,
29541 _swigc__p_wxCURHandler,
29542 _swigc__p_wxChildFocusEvent,
29543 _swigc__p_wxClientDC,
29544 _swigc__p_wxClipboardTextEvent,
29545 _swigc__p_wxCloseEvent,
29546 _swigc__p_wxColour,
29547 _swigc__p_wxColourDatabase,
29548 _swigc__p_wxCommandEvent,
29549 _swigc__p_wxContextMenuEvent,
29550 _swigc__p_wxControl,
29551 _swigc__p_wxControlWithItems,
29552 _swigc__p_wxCursor,
29553 _swigc__p_wxDC,
29554 _swigc__p_wxDash,
29555 _swigc__p_wxDateEvent,
29556 _swigc__p_wxDisplayChangedEvent,
29557 _swigc__p_wxDropFilesEvent,
29558 _swigc__p_wxDuplexMode,
29559 _swigc__p_wxEffects,
29560 _swigc__p_wxEncodingConverter,
29561 _swigc__p_wxEraseEvent,
29562 _swigc__p_wxEvent,
29563 _swigc__p_wxEvtHandler,
29564 _swigc__p_wxFSFile,
29565 _swigc__p_wxFileSystem,
29566 _swigc__p_wxFlexGridSizer,
29567 _swigc__p_wxFocusEvent,
29568 _swigc__p_wxFont,
29569 _swigc__p_wxFontList,
29570 _swigc__p_wxFontMapper,
29571 _swigc__p_wxGBSizerItem,
29572 _swigc__p_wxGDIObjListBase,
29573 _swigc__p_wxGDIObject,
29574 _swigc__p_wxGIFHandler,
29575 _swigc__p_wxGridBagSizer,
29576 _swigc__p_wxGridSizer,
29577 _swigc__p_wxICOHandler,
29578 _swigc__p_wxIcon,
29579 _swigc__p_wxIconBundle,
29580 _swigc__p_wxIconLocation,
29581 _swigc__p_wxIconizeEvent,
29582 _swigc__p_wxIdleEvent,
29583 _swigc__p_wxImage,
29584 _swigc__p_wxImageHandler,
29585 _swigc__p_wxImageList,
29586 _swigc__p_wxIndividualLayoutConstraint,
29587 _swigc__p_wxInitDialogEvent,
29588 _swigc__p_wxJPEGHandler,
29589 _swigc__p_wxKeyEvent,
29590 _swigc__p_wxLanguageInfo,
29591 _swigc__p_wxLayoutConstraints,
29592 _swigc__p_wxLocale,
29593 _swigc__p_wxMask,
29594 _swigc__p_wxMaximizeEvent,
29595 _swigc__p_wxMemoryDC,
29596 _swigc__p_wxMenu,
29597 _swigc__p_wxMenuBar,
29598 _swigc__p_wxMenuEvent,
29599 _swigc__p_wxMenuItem,
29600 _swigc__p_wxMetaFile,
29601 _swigc__p_wxMetaFileDC,
29602 _swigc__p_wxMirrorDC,
29603 _swigc__p_wxMouseCaptureChangedEvent,
29604 _swigc__p_wxMouseEvent,
29605 _swigc__p_wxMoveEvent,
29606 _swigc__p_wxNativeEncodingInfo,
29607 _swigc__p_wxNativeFontInfo,
29608 _swigc__p_wxNavigationKeyEvent,
29609 _swigc__p_wxNcPaintEvent,
29610 _swigc__p_wxNotifyEvent,
29611 _swigc__p_wxObject,
29612 _swigc__p_wxPCXHandler,
29613 _swigc__p_wxPNGHandler,
29614 _swigc__p_wxPNMHandler,
29615 _swigc__p_wxPaintDC,
29616 _swigc__p_wxPaintEvent,
29617 _swigc__p_wxPalette,
29618 _swigc__p_wxPaletteChangedEvent,
29619 _swigc__p_wxPaperSize,
29620 _swigc__p_wxPen,
29621 _swigc__p_wxPenList,
29622 _swigc__p_wxPoint,
29623 _swigc__p_wxPostScriptDC,
29624 _swigc__p_wxPrintData,
29625 _swigc__p_wxPrinterDC,
29626 _swigc__p_wxPseudoDC,
29627 _swigc__p_wxPyApp,
29628 _swigc__p_wxPyCommandEvent,
29629 _swigc__p_wxPyEvent,
29630 _swigc__p_wxPyFontEnumerator,
29631 _swigc__p_wxPyImageHandler,
29632 _swigc__p_wxPySizer,
29633 _swigc__p_wxPyValidator,
29634 _swigc__p_wxQueryNewPaletteEvent,
29635 _swigc__p_wxRect,
29636 _swigc__p_wxRegion,
29637 _swigc__p_wxRegionIterator,
29638 _swigc__p_wxRendererNative,
29639 _swigc__p_wxRendererVersion,
29640 _swigc__p_wxScreenDC,
29641 _swigc__p_wxScrollEvent,
29642 _swigc__p_wxScrollWinEvent,
29643 _swigc__p_wxSetCursorEvent,
29644 _swigc__p_wxShowEvent,
29645 _swigc__p_wxSize,
29646 _swigc__p_wxSizeEvent,
29647 _swigc__p_wxSizer,
29648 _swigc__p_wxSizerItem,
29649 _swigc__p_wxSplitterRenderParams,
29650 _swigc__p_wxStaticBoxSizer,
29651 _swigc__p_wxStdDialogButtonSizer,
29652 _swigc__p_wxStockGDI,
29653 _swigc__p_wxString,
29654 _swigc__p_wxSysColourChangedEvent,
29655 _swigc__p_wxTIFFHandler,
29656 _swigc__p_wxUpdateUIEvent,
29657 _swigc__p_wxValidator,
29658 _swigc__p_wxWindow,
29659 _swigc__p_wxWindowCreateEvent,
29660 _swigc__p_wxWindowDC,
29661 _swigc__p_wxWindowDestroyEvent,
29662 _swigc__p_wxXPMHandler,
29663 };
29664
29665
29666 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
29667
29668 static swig_const_info swig_const_table[] = {
29669 {0, 0, 0, 0.0, 0, 0}};
29670
29671 #ifdef __cplusplus
29672 }
29673 #endif
29674 /* -----------------------------------------------------------------------------
29675 * Type initialization:
29676 * This problem is tough by the requirement that no dynamic
29677 * memory is used. Also, since swig_type_info structures store pointers to
29678 * swig_cast_info structures and swig_cast_info structures store pointers back
29679 * to swig_type_info structures, we need some lookup code at initialization.
29680 * The idea is that swig generates all the structures that are needed.
29681 * The runtime then collects these partially filled structures.
29682 * The SWIG_InitializeModule function takes these initial arrays out of
29683 * swig_module, and does all the lookup, filling in the swig_module.types
29684 * array with the correct data and linking the correct swig_cast_info
29685 * structures together.
29686 *
29687 * The generated swig_type_info structures are assigned staticly to an initial
29688 * array. We just loop though that array, and handle each type individually.
29689 * First we lookup if this type has been already loaded, and if so, use the
29690 * loaded structure instead of the generated one. Then we have to fill in the
29691 * cast linked list. The cast data is initially stored in something like a
29692 * two-dimensional array. Each row corresponds to a type (there are the same
29693 * number of rows as there are in the swig_type_initial array). Each entry in
29694 * a column is one of the swig_cast_info structures for that type.
29695 * The cast_initial array is actually an array of arrays, because each row has
29696 * a variable number of columns. So to actually build the cast linked list,
29697 * we find the array of casts associated with the type, and loop through it
29698 * adding the casts to the list. The one last trick we need to do is making
29699 * sure the type pointer in the swig_cast_info struct is correct.
29700 *
29701 * First off, we lookup the cast->type name to see if it is already loaded.
29702 * There are three cases to handle:
29703 * 1) If the cast->type has already been loaded AND the type we are adding
29704 * casting info to has not been loaded (it is in this module), THEN we
29705 * replace the cast->type pointer with the type pointer that has already
29706 * been loaded.
29707 * 2) If BOTH types (the one we are adding casting info to, and the
29708 * cast->type) are loaded, THEN the cast info has already been loaded by
29709 * the previous module so we just ignore it.
29710 * 3) Finally, if cast->type has not already been loaded, then we add that
29711 * swig_cast_info to the linked list (because the cast->type) pointer will
29712 * be correct.
29713 * ----------------------------------------------------------------------------- */
29714
29715 #ifdef __cplusplus
29716 extern "C" {
29717 #if 0
29718 } /* c-mode */
29719 #endif
29720 #endif
29721
29722 #if 0
29723 #define SWIGRUNTIME_DEBUG
29724 #endif
29725
29726 SWIGRUNTIME void
29727 SWIG_InitializeModule(void *clientdata) {
29728 size_t i;
29729 swig_module_info *module_head;
29730 static int init_run = 0;
29731
29732 clientdata = clientdata;
29733
29734 if (init_run) return;
29735 init_run = 1;
29736
29737 /* Initialize the swig_module */
29738 swig_module.type_initial = swig_type_initial;
29739 swig_module.cast_initial = swig_cast_initial;
29740
29741 /* Try and load any already created modules */
29742 module_head = SWIG_GetModule(clientdata);
29743 if (module_head) {
29744 swig_module.next = module_head->next;
29745 module_head->next = &swig_module;
29746 } else {
29747 /* This is the first module loaded */
29748 swig_module.next = &swig_module;
29749 SWIG_SetModule(clientdata, &swig_module);
29750 }
29751
29752 /* Now work on filling in swig_module.types */
29753 #ifdef SWIGRUNTIME_DEBUG
29754 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
29755 #endif
29756 for (i = 0; i < swig_module.size; ++i) {
29757 swig_type_info *type = 0;
29758 swig_type_info *ret;
29759 swig_cast_info *cast;
29760
29761 #ifdef SWIGRUNTIME_DEBUG
29762 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
29763 #endif
29764
29765 /* if there is another module already loaded */
29766 if (swig_module.next != &swig_module) {
29767 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
29768 }
29769 if (type) {
29770 /* Overwrite clientdata field */
29771 #ifdef SWIGRUNTIME_DEBUG
29772 printf("SWIG_InitializeModule: found type %s\n", type->name);
29773 #endif
29774 if (swig_module.type_initial[i]->clientdata) {
29775 type->clientdata = swig_module.type_initial[i]->clientdata;
29776 #ifdef SWIGRUNTIME_DEBUG
29777 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
29778 #endif
29779 }
29780 } else {
29781 type = swig_module.type_initial[i];
29782 }
29783
29784 /* Insert casting types */
29785 cast = swig_module.cast_initial[i];
29786 while (cast->type) {
29787 /* Don't need to add information already in the list */
29788 ret = 0;
29789 #ifdef SWIGRUNTIME_DEBUG
29790 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
29791 #endif
29792 if (swig_module.next != &swig_module) {
29793 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
29794 #ifdef SWIGRUNTIME_DEBUG
29795 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
29796 #endif
29797 }
29798 if (ret) {
29799 if (type == swig_module.type_initial[i]) {
29800 #ifdef SWIGRUNTIME_DEBUG
29801 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
29802 #endif
29803 cast->type = ret;
29804 ret = 0;
29805 } else {
29806 /* Check for casting already in the list */
29807 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
29808 #ifdef SWIGRUNTIME_DEBUG
29809 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
29810 #endif
29811 if (!ocast) ret = 0;
29812 }
29813 }
29814
29815 if (!ret) {
29816 #ifdef SWIGRUNTIME_DEBUG
29817 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
29818 #endif
29819 if (type->cast) {
29820 type->cast->prev = cast;
29821 cast->next = type->cast;
29822 }
29823 type->cast = cast;
29824 }
29825 cast++;
29826 }
29827 /* Set entry in modules->types array equal to the type */
29828 swig_module.types[i] = type;
29829 }
29830 swig_module.types[i] = 0;
29831
29832 #ifdef SWIGRUNTIME_DEBUG
29833 printf("**** SWIG_InitializeModule: Cast List ******\n");
29834 for (i = 0; i < swig_module.size; ++i) {
29835 int j = 0;
29836 swig_cast_info *cast = swig_module.cast_initial[i];
29837 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
29838 while (cast->type) {
29839 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
29840 cast++;
29841 ++j;
29842 }
29843 printf("---- Total casts: %d\n",j);
29844 }
29845 printf("**** SWIG_InitializeModule: Cast List ******\n");
29846 #endif
29847 }
29848
29849 /* This function will propagate the clientdata field of type to
29850 * any new swig_type_info structures that have been added into the list
29851 * of equivalent types. It is like calling
29852 * SWIG_TypeClientData(type, clientdata) a second time.
29853 */
29854 SWIGRUNTIME void
29855 SWIG_PropagateClientData(void) {
29856 size_t i;
29857 swig_cast_info *equiv;
29858 static int init_run = 0;
29859
29860 if (init_run) return;
29861 init_run = 1;
29862
29863 for (i = 0; i < swig_module.size; i++) {
29864 if (swig_module.types[i]->clientdata) {
29865 equiv = swig_module.types[i]->cast;
29866 while (equiv) {
29867 if (!equiv->converter) {
29868 if (equiv->type && !equiv->type->clientdata)
29869 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
29870 }
29871 equiv = equiv->next;
29872 }
29873 }
29874 }
29875 }
29876
29877 #ifdef __cplusplus
29878 #if 0
29879 {
29880 /* c-mode */
29881 #endif
29882 }
29883 #endif
29884
29885
29886
29887 #ifdef __cplusplus
29888 extern "C" {
29889 #endif
29890
29891 /* Python-specific SWIG API */
29892 #define SWIG_newvarlink() SWIG_Python_newvarlink()
29893 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
29894 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
29895
29896 /* -----------------------------------------------------------------------------
29897 * global variable support code.
29898 * ----------------------------------------------------------------------------- */
29899
29900 typedef struct swig_globalvar {
29901 char *name; /* Name of global variable */
29902 PyObject *(*get_attr)(void); /* Return the current value */
29903 int (*set_attr)(PyObject *); /* Set the value */
29904 struct swig_globalvar *next;
29905 } swig_globalvar;
29906
29907 typedef struct swig_varlinkobject {
29908 PyObject_HEAD
29909 swig_globalvar *vars;
29910 } swig_varlinkobject;
29911
29912 SWIGINTERN PyObject *
29913 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
29914 return PyString_FromString("<Swig global variables>");
29915 }
29916
29917 SWIGINTERN PyObject *
29918 swig_varlink_str(swig_varlinkobject *v) {
29919 PyObject *str = PyString_FromString("(");
29920 swig_globalvar *var;
29921 for (var = v->vars; var; var=var->next) {
29922 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
29923 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
29924 }
29925 PyString_ConcatAndDel(&str,PyString_FromString(")"));
29926 return str;
29927 }
29928
29929 SWIGINTERN int
29930 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
29931 PyObject *str = swig_varlink_str(v);
29932 fprintf(fp,"Swig global variables ");
29933 fprintf(fp,"%s\n", PyString_AsString(str));
29934 Py_DECREF(str);
29935 return 0;
29936 }
29937
29938 SWIGINTERN void
29939 swig_varlink_dealloc(swig_varlinkobject *v) {
29940 swig_globalvar *var = v->vars;
29941 while (var) {
29942 swig_globalvar *n = var->next;
29943 free(var->name);
29944 free(var);
29945 var = n;
29946 }
29947 }
29948
29949 SWIGINTERN PyObject *
29950 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
29951 PyObject *res = NULL;
29952 swig_globalvar *var = v->vars;
29953 while (var) {
29954 if (strcmp(var->name,n) == 0) {
29955 res = (*var->get_attr)();
29956 break;
29957 }
29958 var = var->next;
29959 }
29960 if (res == NULL && !PyErr_Occurred()) {
29961 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29962 }
29963 return res;
29964 }
29965
29966 SWIGINTERN int
29967 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
29968 int res = 1;
29969 swig_globalvar *var = v->vars;
29970 while (var) {
29971 if (strcmp(var->name,n) == 0) {
29972 res = (*var->set_attr)(p);
29973 break;
29974 }
29975 var = var->next;
29976 }
29977 if (res == 1 && !PyErr_Occurred()) {
29978 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
29979 }
29980 return res;
29981 }
29982
29983 SWIGINTERN PyTypeObject*
29984 swig_varlink_type(void) {
29985 static char varlink__doc__[] = "Swig var link object";
29986 static PyTypeObject varlink_type;
29987 static int type_init = 0;
29988 if (!type_init) {
29989 const PyTypeObject tmp
29990 = {
29991 PyObject_HEAD_INIT(NULL)
29992 0, /* Number of items in variable part (ob_size) */
29993 (char *)"swigvarlink", /* Type name (tp_name) */
29994 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
29995 0, /* Itemsize (tp_itemsize) */
29996 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
29997 (printfunc) swig_varlink_print, /* Print (tp_print) */
29998 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
29999 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
30000 0, /* tp_compare */
30001 (reprfunc) swig_varlink_repr, /* tp_repr */
30002 0, /* tp_as_number */
30003 0, /* tp_as_sequence */
30004 0, /* tp_as_mapping */
30005 0, /* tp_hash */
30006 0, /* tp_call */
30007 (reprfunc)swig_varlink_str, /* tp_str */
30008 0, /* tp_getattro */
30009 0, /* tp_setattro */
30010 0, /* tp_as_buffer */
30011 0, /* tp_flags */
30012 varlink__doc__, /* tp_doc */
30013 0, /* tp_traverse */
30014 0, /* tp_clear */
30015 0, /* tp_richcompare */
30016 0, /* tp_weaklistoffset */
30017 #if PY_VERSION_HEX >= 0x02020000
30018 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
30019 #endif
30020 #if PY_VERSION_HEX >= 0x02030000
30021 0, /* tp_del */
30022 #endif
30023 #ifdef COUNT_ALLOCS
30024 0,0,0,0 /* tp_alloc -> tp_next */
30025 #endif
30026 };
30027 varlink_type = tmp;
30028 varlink_type.ob_type = &PyType_Type;
30029 type_init = 1;
30030 }
30031 return &varlink_type;
30032 }
30033
30034 /* Create a variable linking object for use later */
30035 SWIGINTERN PyObject *
30036 SWIG_Python_newvarlink(void) {
30037 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
30038 if (result) {
30039 result->vars = 0;
30040 }
30041 return ((PyObject*) result);
30042 }
30043
30044 SWIGINTERN void
30045 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
30046 swig_varlinkobject *v = (swig_varlinkobject *) p;
30047 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
30048 if (gv) {
30049 size_t size = strlen(name)+1;
30050 gv->name = (char *)malloc(size);
30051 if (gv->name) {
30052 strncpy(gv->name,name,size);
30053 gv->get_attr = get_attr;
30054 gv->set_attr = set_attr;
30055 gv->next = v->vars;
30056 }
30057 }
30058 v->vars = gv;
30059 }
30060
30061 SWIGINTERN PyObject *
30062 SWIG_globals() {
30063 static PyObject *_SWIG_globals = 0;
30064 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
30065 return _SWIG_globals;
30066 }
30067
30068 /* -----------------------------------------------------------------------------
30069 * constants/methods manipulation
30070 * ----------------------------------------------------------------------------- */
30071
30072 /* Install Constants */
30073 SWIGINTERN void
30074 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
30075 PyObject *obj = 0;
30076 size_t i;
30077 for (i = 0; constants[i].type; ++i) {
30078 switch(constants[i].type) {
30079 case SWIG_PY_POINTER:
30080 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
30081 break;
30082 case SWIG_PY_BINARY:
30083 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
30084 break;
30085 default:
30086 obj = 0;
30087 break;
30088 }
30089 if (obj) {
30090 PyDict_SetItemString(d, constants[i].name, obj);
30091 Py_DECREF(obj);
30092 }
30093 }
30094 }
30095
30096 /* -----------------------------------------------------------------------------*/
30097 /* Fix SwigMethods to carry the callback ptrs when needed */
30098 /* -----------------------------------------------------------------------------*/
30099
30100 SWIGINTERN void
30101 SWIG_Python_FixMethods(PyMethodDef *methods,
30102 swig_const_info *const_table,
30103 swig_type_info **types,
30104 swig_type_info **types_initial) {
30105 size_t i;
30106 for (i = 0; methods[i].ml_name; ++i) {
30107 const char *c = methods[i].ml_doc;
30108 if (c && (c = strstr(c, "swig_ptr: "))) {
30109 int j;
30110 swig_const_info *ci = 0;
30111 const char *name = c + 10;
30112 for (j = 0; const_table[j].type; ++j) {
30113 if (strncmp(const_table[j].name, name,
30114 strlen(const_table[j].name)) == 0) {
30115 ci = &(const_table[j]);
30116 break;
30117 }
30118 }
30119 if (ci) {
30120 size_t shift = (ci->ptype) - types;
30121 swig_type_info *ty = types_initial[shift];
30122 size_t ldoc = (c - methods[i].ml_doc);
30123 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
30124 char *ndoc = (char*)malloc(ldoc + lptr + 10);
30125 if (ndoc) {
30126 char *buff = ndoc;
30127 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
30128 if (ptr) {
30129 strncpy(buff, methods[i].ml_doc, ldoc);
30130 buff += ldoc;
30131 strncpy(buff, "swig_ptr: ", 10);
30132 buff += 10;
30133 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
30134 methods[i].ml_doc = ndoc;
30135 }
30136 }
30137 }
30138 }
30139 }
30140 }
30141
30142 #ifdef __cplusplus
30143 }
30144 #endif
30145
30146 /* -----------------------------------------------------------------------------*
30147 * Partial Init method
30148 * -----------------------------------------------------------------------------*/
30149
30150 #ifdef __cplusplus
30151 extern "C"
30152 #endif
30153 SWIGEXPORT void SWIG_init(void) {
30154 PyObject *m, *d;
30155
30156 /* Fix SwigMethods to carry the callback ptrs when needed */
30157 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
30158
30159 m = Py_InitModule((char *) SWIG_name, SwigMethods);
30160 d = PyModule_GetDict(m);
30161
30162 SWIG_InitializeModule(0);
30163 SWIG_InstallConstants(d,swig_const_table);
30164
30165
30166 SWIG_Python_SetConstant(d, "C2S_NAME",SWIG_From_int(static_cast< int >(wxC2S_NAME)));
30167 SWIG_Python_SetConstant(d, "C2S_CSS_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_CSS_SYNTAX)));
30168 SWIG_Python_SetConstant(d, "C2S_HTML_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_HTML_SYNTAX)));
30169 SWIG_Python_SetConstant(d, "OutRegion",SWIG_From_int(static_cast< int >(wxOutRegion)));
30170 SWIG_Python_SetConstant(d, "PartRegion",SWIG_From_int(static_cast< int >(wxPartRegion)));
30171 SWIG_Python_SetConstant(d, "InRegion",SWIG_From_int(static_cast< int >(wxInRegion)));
30172 SWIG_Python_SetConstant(d, "FONTFAMILY_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DEFAULT)));
30173 SWIG_Python_SetConstant(d, "FONTFAMILY_DECORATIVE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DECORATIVE)));
30174 SWIG_Python_SetConstant(d, "FONTFAMILY_ROMAN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_ROMAN)));
30175 SWIG_Python_SetConstant(d, "FONTFAMILY_SCRIPT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SCRIPT)));
30176 SWIG_Python_SetConstant(d, "FONTFAMILY_SWISS",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SWISS)));
30177 SWIG_Python_SetConstant(d, "FONTFAMILY_MODERN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MODERN)));
30178 SWIG_Python_SetConstant(d, "FONTFAMILY_TELETYPE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_TELETYPE)));
30179 SWIG_Python_SetConstant(d, "FONTFAMILY_MAX",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MAX)));
30180 SWIG_Python_SetConstant(d, "FONTFAMILY_UNKNOWN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_UNKNOWN)));
30181 SWIG_Python_SetConstant(d, "FONTSTYLE_NORMAL",SWIG_From_int(static_cast< int >(wxFONTSTYLE_NORMAL)));
30182 SWIG_Python_SetConstant(d, "FONTSTYLE_ITALIC",SWIG_From_int(static_cast< int >(wxFONTSTYLE_ITALIC)));
30183 SWIG_Python_SetConstant(d, "FONTSTYLE_SLANT",SWIG_From_int(static_cast< int >(wxFONTSTYLE_SLANT)));
30184 SWIG_Python_SetConstant(d, "FONTSTYLE_MAX",SWIG_From_int(static_cast< int >(wxFONTSTYLE_MAX)));
30185 SWIG_Python_SetConstant(d, "FONTWEIGHT_NORMAL",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_NORMAL)));
30186 SWIG_Python_SetConstant(d, "FONTWEIGHT_LIGHT",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_LIGHT)));
30187 SWIG_Python_SetConstant(d, "FONTWEIGHT_BOLD",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_BOLD)));
30188 SWIG_Python_SetConstant(d, "FONTWEIGHT_MAX",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_MAX)));
30189 SWIG_Python_SetConstant(d, "FONTFLAG_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFLAG_DEFAULT)));
30190 SWIG_Python_SetConstant(d, "FONTFLAG_ITALIC",SWIG_From_int(static_cast< int >(wxFONTFLAG_ITALIC)));
30191 SWIG_Python_SetConstant(d, "FONTFLAG_SLANT",SWIG_From_int(static_cast< int >(wxFONTFLAG_SLANT)));
30192 SWIG_Python_SetConstant(d, "FONTFLAG_LIGHT",SWIG_From_int(static_cast< int >(wxFONTFLAG_LIGHT)));
30193 SWIG_Python_SetConstant(d, "FONTFLAG_BOLD",SWIG_From_int(static_cast< int >(wxFONTFLAG_BOLD)));
30194 SWIG_Python_SetConstant(d, "FONTFLAG_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_ANTIALIASED)));
30195 SWIG_Python_SetConstant(d, "FONTFLAG_NOT_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_NOT_ANTIALIASED)));
30196 SWIG_Python_SetConstant(d, "FONTFLAG_UNDERLINED",SWIG_From_int(static_cast< int >(wxFONTFLAG_UNDERLINED)));
30197 SWIG_Python_SetConstant(d, "FONTFLAG_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxFONTFLAG_STRIKETHROUGH)));
30198 SWIG_Python_SetConstant(d, "FONTFLAG_MASK",SWIG_From_int(static_cast< int >(wxFONTFLAG_MASK)));
30199 SWIG_Python_SetConstant(d, "FONTENCODING_SYSTEM",SWIG_From_int(static_cast< int >(wxFONTENCODING_SYSTEM)));
30200 SWIG_Python_SetConstant(d, "FONTENCODING_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTENCODING_DEFAULT)));
30201 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_1",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_1)));
30202 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_2",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_2)));
30203 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_3",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_3)));
30204 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_4",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_4)));
30205 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_5",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_5)));
30206 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_6",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_6)));
30207 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_7",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_7)));
30208 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_8",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_8)));
30209 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_9",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_9)));
30210 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_10",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_10)));
30211 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_11",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_11)));
30212 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_12",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_12)));
30213 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_13",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_13)));
30214 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_14",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_14)));
30215 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_15",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_15)));
30216 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_MAX)));
30217 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8)));
30218 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8_U",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8_U)));
30219 SWIG_Python_SetConstant(d, "FONTENCODING_ALTERNATIVE",SWIG_From_int(static_cast< int >(wxFONTENCODING_ALTERNATIVE)));
30220 SWIG_Python_SetConstant(d, "FONTENCODING_BULGARIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_BULGARIAN)));
30221 SWIG_Python_SetConstant(d, "FONTENCODING_CP437",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP437)));
30222 SWIG_Python_SetConstant(d, "FONTENCODING_CP850",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP850)));
30223 SWIG_Python_SetConstant(d, "FONTENCODING_CP852",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP852)));
30224 SWIG_Python_SetConstant(d, "FONTENCODING_CP855",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP855)));
30225 SWIG_Python_SetConstant(d, "FONTENCODING_CP866",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP866)));
30226 SWIG_Python_SetConstant(d, "FONTENCODING_CP874",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP874)));
30227 SWIG_Python_SetConstant(d, "FONTENCODING_CP932",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP932)));
30228 SWIG_Python_SetConstant(d, "FONTENCODING_CP936",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP936)));
30229 SWIG_Python_SetConstant(d, "FONTENCODING_CP949",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP949)));
30230 SWIG_Python_SetConstant(d, "FONTENCODING_CP950",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP950)));
30231 SWIG_Python_SetConstant(d, "FONTENCODING_CP1250",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1250)));
30232 SWIG_Python_SetConstant(d, "FONTENCODING_CP1251",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1251)));
30233 SWIG_Python_SetConstant(d, "FONTENCODING_CP1252",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1252)));
30234 SWIG_Python_SetConstant(d, "FONTENCODING_CP1253",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1253)));
30235 SWIG_Python_SetConstant(d, "FONTENCODING_CP1254",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1254)));
30236 SWIG_Python_SetConstant(d, "FONTENCODING_CP1255",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1255)));
30237 SWIG_Python_SetConstant(d, "FONTENCODING_CP1256",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1256)));
30238 SWIG_Python_SetConstant(d, "FONTENCODING_CP1257",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1257)));
30239 SWIG_Python_SetConstant(d, "FONTENCODING_CP12_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP12_MAX)));
30240 SWIG_Python_SetConstant(d, "FONTENCODING_UTF7",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF7)));
30241 SWIG_Python_SetConstant(d, "FONTENCODING_UTF8",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF8)));
30242 SWIG_Python_SetConstant(d, "FONTENCODING_EUC_JP",SWIG_From_int(static_cast< int >(wxFONTENCODING_EUC_JP)));
30243 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16BE)));
30244 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16LE)));
30245 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32BE)));
30246 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32LE)));
30247 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMAN)));
30248 SWIG_Python_SetConstant(d, "FONTENCODING_MACJAPANESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACJAPANESE)));
30249 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESETRAD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESETRAD)));
30250 SWIG_Python_SetConstant(d, "FONTENCODING_MACKOREAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKOREAN)));
30251 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABIC)));
30252 SWIG_Python_SetConstant(d, "FONTENCODING_MACHEBREW",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACHEBREW)));
30253 SWIG_Python_SetConstant(d, "FONTENCODING_MACGREEK",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGREEK)));
30254 SWIG_Python_SetConstant(d, "FONTENCODING_MACCYRILLIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCYRILLIC)));
30255 SWIG_Python_SetConstant(d, "FONTENCODING_MACDEVANAGARI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDEVANAGARI)));
30256 SWIG_Python_SetConstant(d, "FONTENCODING_MACGURMUKHI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGURMUKHI)));
30257 SWIG_Python_SetConstant(d, "FONTENCODING_MACGUJARATI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGUJARATI)));
30258 SWIG_Python_SetConstant(d, "FONTENCODING_MACORIYA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACORIYA)));
30259 SWIG_Python_SetConstant(d, "FONTENCODING_MACBENGALI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBENGALI)));
30260 SWIG_Python_SetConstant(d, "FONTENCODING_MACTAMIL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTAMIL)));
30261 SWIG_Python_SetConstant(d, "FONTENCODING_MACTELUGU",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTELUGU)));
30262 SWIG_Python_SetConstant(d, "FONTENCODING_MACKANNADA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKANNADA)));
30263 SWIG_Python_SetConstant(d, "FONTENCODING_MACMALAJALAM",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMALAJALAM)));
30264 SWIG_Python_SetConstant(d, "FONTENCODING_MACSINHALESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSINHALESE)));
30265 SWIG_Python_SetConstant(d, "FONTENCODING_MACBURMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBURMESE)));
30266 SWIG_Python_SetConstant(d, "FONTENCODING_MACKHMER",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKHMER)));
30267 SWIG_Python_SetConstant(d, "FONTENCODING_MACTHAI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTHAI)));
30268 SWIG_Python_SetConstant(d, "FONTENCODING_MACLAOTIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACLAOTIAN)));
30269 SWIG_Python_SetConstant(d, "FONTENCODING_MACGEORGIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGEORGIAN)));
30270 SWIG_Python_SetConstant(d, "FONTENCODING_MACARMENIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARMENIAN)));
30271 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESESIMP",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESESIMP)));
30272 SWIG_Python_SetConstant(d, "FONTENCODING_MACTIBETAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTIBETAN)));
30273 SWIG_Python_SetConstant(d, "FONTENCODING_MACMONGOLIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMONGOLIAN)));
30274 SWIG_Python_SetConstant(d, "FONTENCODING_MACETHIOPIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACETHIOPIC)));
30275 SWIG_Python_SetConstant(d, "FONTENCODING_MACCENTRALEUR",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCENTRALEUR)));
30276 SWIG_Python_SetConstant(d, "FONTENCODING_MACVIATNAMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACVIATNAMESE)));
30277 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABICEXT",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABICEXT)));
30278 SWIG_Python_SetConstant(d, "FONTENCODING_MACSYMBOL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSYMBOL)));
30279 SWIG_Python_SetConstant(d, "FONTENCODING_MACDINGBATS",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDINGBATS)));
30280 SWIG_Python_SetConstant(d, "FONTENCODING_MACTURKISH",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTURKISH)));
30281 SWIG_Python_SetConstant(d, "FONTENCODING_MACCROATIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCROATIAN)));
30282 SWIG_Python_SetConstant(d, "FONTENCODING_MACICELANDIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACICELANDIC)));
30283 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMANIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMANIAN)));
30284 SWIG_Python_SetConstant(d, "FONTENCODING_MACCELTIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCELTIC)));
30285 SWIG_Python_SetConstant(d, "FONTENCODING_MACGAELIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGAELIC)));
30286 SWIG_Python_SetConstant(d, "FONTENCODING_MACKEYBOARD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKEYBOARD)));
30287 SWIG_Python_SetConstant(d, "FONTENCODING_MACMIN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMIN)));
30288 SWIG_Python_SetConstant(d, "FONTENCODING_MACMAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMAX)));
30289 SWIG_Python_SetConstant(d, "FONTENCODING_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MAX)));
30290 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16)));
30291 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32)));
30292 SWIG_Python_SetConstant(d, "FONTENCODING_UNICODE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UNICODE)));
30293 SWIG_Python_SetConstant(d, "FONTENCODING_GB2312",SWIG_From_int(static_cast< int >(wxFONTENCODING_GB2312)));
30294 SWIG_Python_SetConstant(d, "FONTENCODING_BIG5",SWIG_From_int(static_cast< int >(wxFONTENCODING_BIG5)));
30295 SWIG_Python_SetConstant(d, "FONTENCODING_SHIFT_JIS",SWIG_From_int(static_cast< int >(wxFONTENCODING_SHIFT_JIS)));
30296
30297 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
30298
30299 SWIG_Python_SetConstant(d, "LANGUAGE_DEFAULT",SWIG_From_int(static_cast< int >(wxLANGUAGE_DEFAULT)));
30300 SWIG_Python_SetConstant(d, "LANGUAGE_UNKNOWN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UNKNOWN)));
30301 SWIG_Python_SetConstant(d, "LANGUAGE_ABKHAZIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ABKHAZIAN)));
30302 SWIG_Python_SetConstant(d, "LANGUAGE_AFAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFAR)));
30303 SWIG_Python_SetConstant(d, "LANGUAGE_AFRIKAANS",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFRIKAANS)));
30304 SWIG_Python_SetConstant(d, "LANGUAGE_ALBANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ALBANIAN)));
30305 SWIG_Python_SetConstant(d, "LANGUAGE_AMHARIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AMHARIC)));
30306 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC)));
30307 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_ALGERIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_ALGERIA)));
30308 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_BAHRAIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_BAHRAIN)));
30309 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_EGYPT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_EGYPT)));
30310 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_IRAQ",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_IRAQ)));
30311 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_JORDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_JORDAN)));
30312 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_KUWAIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_KUWAIT)));
30313 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LEBANON",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LEBANON)));
30314 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LIBYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LIBYA)));
30315 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_MOROCCO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_MOROCCO)));
30316 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_OMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_OMAN)));
30317 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_QATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_QATAR)));
30318 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SAUDI_ARABIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
30319 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SUDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SUDAN)));
30320 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SYRIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SYRIA)));
30321 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_TUNISIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_TUNISIA)));
30322 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_UAE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_UAE)));
30323 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_YEMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_YEMEN)));
30324 SWIG_Python_SetConstant(d, "LANGUAGE_ARMENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARMENIAN)));
30325 SWIG_Python_SetConstant(d, "LANGUAGE_ASSAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ASSAMESE)));
30326 SWIG_Python_SetConstant(d, "LANGUAGE_AYMARA",SWIG_From_int(static_cast< int >(wxLANGUAGE_AYMARA)));
30327 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI)));
30328 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_CYRILLIC)));
30329 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_LATIN)));
30330 SWIG_Python_SetConstant(d, "LANGUAGE_BASHKIR",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASHKIR)));
30331 SWIG_Python_SetConstant(d, "LANGUAGE_BASQUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASQUE)));
30332 SWIG_Python_SetConstant(d, "LANGUAGE_BELARUSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BELARUSIAN)));
30333 SWIG_Python_SetConstant(d, "LANGUAGE_BENGALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BENGALI)));
30334 SWIG_Python_SetConstant(d, "LANGUAGE_BHUTANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BHUTANI)));
30335 SWIG_Python_SetConstant(d, "LANGUAGE_BIHARI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BIHARI)));
30336 SWIG_Python_SetConstant(d, "LANGUAGE_BISLAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_BISLAMA)));
30337 SWIG_Python_SetConstant(d, "LANGUAGE_BRETON",SWIG_From_int(static_cast< int >(wxLANGUAGE_BRETON)));
30338 SWIG_Python_SetConstant(d, "LANGUAGE_BULGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BULGARIAN)));
30339 SWIG_Python_SetConstant(d, "LANGUAGE_BURMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BURMESE)));
30340 SWIG_Python_SetConstant(d, "LANGUAGE_CAMBODIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CAMBODIAN)));
30341 SWIG_Python_SetConstant(d, "LANGUAGE_CATALAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CATALAN)));
30342 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE)));
30343 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SIMPLIFIED",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SIMPLIFIED)));
30344 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TRADITIONAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TRADITIONAL)));
30345 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_HONGKONG",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_HONGKONG)));
30346 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_MACAU",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_MACAU)));
30347 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SINGAPORE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SINGAPORE)));
30348 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TAIWAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TAIWAN)));
30349 SWIG_Python_SetConstant(d, "LANGUAGE_CORSICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CORSICAN)));
30350 SWIG_Python_SetConstant(d, "LANGUAGE_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CROATIAN)));
30351 SWIG_Python_SetConstant(d, "LANGUAGE_CZECH",SWIG_From_int(static_cast< int >(wxLANGUAGE_CZECH)));
30352 SWIG_Python_SetConstant(d, "LANGUAGE_DANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DANISH)));
30353 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH)));
30354 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH_BELGIAN)));
30355 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH)));
30356 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_UK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_UK)));
30357 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_US)));
30358 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_AUSTRALIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_AUSTRALIA)));
30359 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BELIZE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BELIZE)));
30360 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BOTSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BOTSWANA)));
30361 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CANADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CANADA)));
30362 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CARIBBEAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CARIBBEAN)));
30363 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_DENMARK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_DENMARK)));
30364 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_EIRE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_EIRE)));
30365 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_JAMAICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_JAMAICA)));
30366 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_NEW_ZEALAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
30367 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_PHILIPPINES",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_PHILIPPINES)));
30368 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_SOUTH_AFRICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
30369 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_TRINIDAD",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_TRINIDAD)));
30370 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_ZIMBABWE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_ZIMBABWE)));
30371 SWIG_Python_SetConstant(d, "LANGUAGE_ESPERANTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESPERANTO)));
30372 SWIG_Python_SetConstant(d, "LANGUAGE_ESTONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESTONIAN)));
30373 SWIG_Python_SetConstant(d, "LANGUAGE_FAEROESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_FAEROESE)));
30374 SWIG_Python_SetConstant(d, "LANGUAGE_FARSI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FARSI)));
30375 SWIG_Python_SetConstant(d, "LANGUAGE_FIJI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FIJI)));
30376 SWIG_Python_SetConstant(d, "LANGUAGE_FINNISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FINNISH)));
30377 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH)));
30378 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_BELGIAN)));
30379 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_CANADIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_CANADIAN)));
30380 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_LUXEMBOURG)));
30381 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_MONACO",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_MONACO)));
30382 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_SWISS)));
30383 SWIG_Python_SetConstant(d, "LANGUAGE_FRISIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRISIAN)));
30384 SWIG_Python_SetConstant(d, "LANGUAGE_GALICIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GALICIAN)));
30385 SWIG_Python_SetConstant(d, "LANGUAGE_GEORGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GEORGIAN)));
30386 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN)));
30387 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_AUSTRIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_AUSTRIAN)));
30388 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_BELGIUM",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_BELGIUM)));
30389 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LIECHTENSTEIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
30390 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LUXEMBOURG)));
30391 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_SWISS)));
30392 SWIG_Python_SetConstant(d, "LANGUAGE_GREEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREEK)));
30393 SWIG_Python_SetConstant(d, "LANGUAGE_GREENLANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREENLANDIC)));
30394 SWIG_Python_SetConstant(d, "LANGUAGE_GUARANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUARANI)));
30395 SWIG_Python_SetConstant(d, "LANGUAGE_GUJARATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUJARATI)));
30396 SWIG_Python_SetConstant(d, "LANGUAGE_HAUSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_HAUSA)));
30397 SWIG_Python_SetConstant(d, "LANGUAGE_HEBREW",SWIG_From_int(static_cast< int >(wxLANGUAGE_HEBREW)));
30398 SWIG_Python_SetConstant(d, "LANGUAGE_HINDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_HINDI)));
30399 SWIG_Python_SetConstant(d, "LANGUAGE_HUNGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_HUNGARIAN)));
30400 SWIG_Python_SetConstant(d, "LANGUAGE_ICELANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ICELANDIC)));
30401 SWIG_Python_SetConstant(d, "LANGUAGE_INDONESIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_INDONESIAN)));
30402 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUA)));
30403 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUE)));
30404 SWIG_Python_SetConstant(d, "LANGUAGE_INUKTITUT",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUKTITUT)));
30405 SWIG_Python_SetConstant(d, "LANGUAGE_INUPIAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUPIAK)));
30406 SWIG_Python_SetConstant(d, "LANGUAGE_IRISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_IRISH)));
30407 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN)));
30408 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN_SWISS)));
30409 SWIG_Python_SetConstant(d, "LANGUAGE_JAPANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAPANESE)));
30410 SWIG_Python_SetConstant(d, "LANGUAGE_JAVANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAVANESE)));
30411 SWIG_Python_SetConstant(d, "LANGUAGE_KANNADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KANNADA)));
30412 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI)));
30413 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI_INDIA)));
30414 SWIG_Python_SetConstant(d, "LANGUAGE_KAZAKH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KAZAKH)));
30415 SWIG_Python_SetConstant(d, "LANGUAGE_KERNEWEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_KERNEWEK)));
30416 SWIG_Python_SetConstant(d, "LANGUAGE_KINYARWANDA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KINYARWANDA)));
30417 SWIG_Python_SetConstant(d, "LANGUAGE_KIRGHIZ",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRGHIZ)));
30418 SWIG_Python_SetConstant(d, "LANGUAGE_KIRUNDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRUNDI)));
30419 SWIG_Python_SetConstant(d, "LANGUAGE_KONKANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KONKANI)));
30420 SWIG_Python_SetConstant(d, "LANGUAGE_KOREAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_KOREAN)));
30421 SWIG_Python_SetConstant(d, "LANGUAGE_KURDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KURDISH)));
30422 SWIG_Python_SetConstant(d, "LANGUAGE_LAOTHIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LAOTHIAN)));
30423 SWIG_Python_SetConstant(d, "LANGUAGE_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATIN)));
30424 SWIG_Python_SetConstant(d, "LANGUAGE_LATVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATVIAN)));
30425 SWIG_Python_SetConstant(d, "LANGUAGE_LINGALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_LINGALA)));
30426 SWIG_Python_SetConstant(d, "LANGUAGE_LITHUANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LITHUANIAN)));
30427 SWIG_Python_SetConstant(d, "LANGUAGE_MACEDONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MACEDONIAN)));
30428 SWIG_Python_SetConstant(d, "LANGUAGE_MALAGASY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAGASY)));
30429 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY)));
30430 SWIG_Python_SetConstant(d, "LANGUAGE_MALAYALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAYALAM)));
30431 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_BRUNEI_DARUSSALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
30432 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_MALAYSIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_MALAYSIA)));
30433 SWIG_Python_SetConstant(d, "LANGUAGE_MALTESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALTESE)));
30434 SWIG_Python_SetConstant(d, "LANGUAGE_MANIPURI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MANIPURI)));
30435 SWIG_Python_SetConstant(d, "LANGUAGE_MAORI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MAORI)));
30436 SWIG_Python_SetConstant(d, "LANGUAGE_MARATHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MARATHI)));
30437 SWIG_Python_SetConstant(d, "LANGUAGE_MOLDAVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MOLDAVIAN)));
30438 SWIG_Python_SetConstant(d, "LANGUAGE_MONGOLIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MONGOLIAN)));
30439 SWIG_Python_SetConstant(d, "LANGUAGE_NAURU",SWIG_From_int(static_cast< int >(wxLANGUAGE_NAURU)));
30440 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI)));
30441 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI_INDIA)));
30442 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_BOKMAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_BOKMAL)));
30443 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_NYNORSK",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_NYNORSK)));
30444 SWIG_Python_SetConstant(d, "LANGUAGE_OCCITAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_OCCITAN)));
30445 SWIG_Python_SetConstant(d, "LANGUAGE_ORIYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ORIYA)));
30446 SWIG_Python_SetConstant(d, "LANGUAGE_OROMO",SWIG_From_int(static_cast< int >(wxLANGUAGE_OROMO)));
30447 SWIG_Python_SetConstant(d, "LANGUAGE_PASHTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_PASHTO)));
30448 SWIG_Python_SetConstant(d, "LANGUAGE_POLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_POLISH)));
30449 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE)));
30450 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE_BRAZILIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
30451 SWIG_Python_SetConstant(d, "LANGUAGE_PUNJABI",SWIG_From_int(static_cast< int >(wxLANGUAGE_PUNJABI)));
30452 SWIG_Python_SetConstant(d, "LANGUAGE_QUECHUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_QUECHUA)));
30453 SWIG_Python_SetConstant(d, "LANGUAGE_RHAETO_ROMANCE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RHAETO_ROMANCE)));
30454 SWIG_Python_SetConstant(d, "LANGUAGE_ROMANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ROMANIAN)));
30455 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN)));
30456 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN_UKRAINE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN_UKRAINE)));
30457 SWIG_Python_SetConstant(d, "LANGUAGE_SAMOAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SAMOAN)));
30458 SWIG_Python_SetConstant(d, "LANGUAGE_SANGHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANGHO)));
30459 SWIG_Python_SetConstant(d, "LANGUAGE_SANSKRIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANSKRIT)));
30460 SWIG_Python_SetConstant(d, "LANGUAGE_SCOTS_GAELIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SCOTS_GAELIC)));
30461 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN)));
30462 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_CYRILLIC)));
30463 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_LATIN)));
30464 SWIG_Python_SetConstant(d, "LANGUAGE_SERBO_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBO_CROATIAN)));
30465 SWIG_Python_SetConstant(d, "LANGUAGE_SESOTHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SESOTHO)));
30466 SWIG_Python_SetConstant(d, "LANGUAGE_SETSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SETSWANA)));
30467 SWIG_Python_SetConstant(d, "LANGUAGE_SHONA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SHONA)));
30468 SWIG_Python_SetConstant(d, "LANGUAGE_SINDHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINDHI)));
30469 SWIG_Python_SetConstant(d, "LANGUAGE_SINHALESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINHALESE)));
30470 SWIG_Python_SetConstant(d, "LANGUAGE_SISWATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SISWATI)));
30471 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVAK)));
30472 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVENIAN)));
30473 SWIG_Python_SetConstant(d, "LANGUAGE_SOMALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SOMALI)));
30474 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH)));
30475 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ARGENTINA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ARGENTINA)));
30476 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_BOLIVIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_BOLIVIA)));
30477 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_CHILE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_CHILE)));
30478 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COLOMBIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COLOMBIA)));
30479 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COSTA_RICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COSTA_RICA)));
30480 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_DOMINICAN_REPUBLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
30481 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ECUADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ECUADOR)));
30482 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_EL_SALVADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_EL_SALVADOR)));
30483 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_GUATEMALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_GUATEMALA)));
30484 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_HONDURAS",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_HONDURAS)));
30485 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MEXICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MEXICAN)));
30486 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MODERN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MODERN)));
30487 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_NICARAGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_NICARAGUA)));
30488 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PANAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PANAMA)));
30489 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PARAGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PARAGUAY)));
30490 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PERU",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PERU)));
30491 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PUERTO_RICO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PUERTO_RICO)));
30492 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_URUGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_URUGUAY)));
30493 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_US)));
30494 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_VENEZUELA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_VENEZUELA)));
30495 SWIG_Python_SetConstant(d, "LANGUAGE_SUNDANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SUNDANESE)));
30496 SWIG_Python_SetConstant(d, "LANGUAGE_SWAHILI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWAHILI)));
30497 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH)));
30498 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH_FINLAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH_FINLAND)));
30499 SWIG_Python_SetConstant(d, "LANGUAGE_TAGALOG",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAGALOG)));
30500 SWIG_Python_SetConstant(d, "LANGUAGE_TAJIK",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAJIK)));
30501 SWIG_Python_SetConstant(d, "LANGUAGE_TAMIL",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAMIL)));
30502 SWIG_Python_SetConstant(d, "LANGUAGE_TATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_TATAR)));
30503 SWIG_Python_SetConstant(d, "LANGUAGE_TELUGU",SWIG_From_int(static_cast< int >(wxLANGUAGE_TELUGU)));
30504 SWIG_Python_SetConstant(d, "LANGUAGE_THAI",SWIG_From_int(static_cast< int >(wxLANGUAGE_THAI)));
30505 SWIG_Python_SetConstant(d, "LANGUAGE_TIBETAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIBETAN)));
30506 SWIG_Python_SetConstant(d, "LANGUAGE_TIGRINYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIGRINYA)));
30507 SWIG_Python_SetConstant(d, "LANGUAGE_TONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TONGA)));
30508 SWIG_Python_SetConstant(d, "LANGUAGE_TSONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TSONGA)));
30509 SWIG_Python_SetConstant(d, "LANGUAGE_TURKISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKISH)));
30510 SWIG_Python_SetConstant(d, "LANGUAGE_TURKMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKMEN)));
30511 SWIG_Python_SetConstant(d, "LANGUAGE_TWI",SWIG_From_int(static_cast< int >(wxLANGUAGE_TWI)));
30512 SWIG_Python_SetConstant(d, "LANGUAGE_UIGHUR",SWIG_From_int(static_cast< int >(wxLANGUAGE_UIGHUR)));
30513 SWIG_Python_SetConstant(d, "LANGUAGE_UKRAINIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UKRAINIAN)));
30514 SWIG_Python_SetConstant(d, "LANGUAGE_URDU",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU)));
30515 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_INDIA)));
30516 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_PAKISTAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_PAKISTAN)));
30517 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK)));
30518 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_CYRILLIC)));
30519 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_LATIN)));
30520 SWIG_Python_SetConstant(d, "LANGUAGE_VIETNAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_VIETNAMESE)));
30521 SWIG_Python_SetConstant(d, "LANGUAGE_VOLAPUK",SWIG_From_int(static_cast< int >(wxLANGUAGE_VOLAPUK)));
30522 SWIG_Python_SetConstant(d, "LANGUAGE_WELSH",SWIG_From_int(static_cast< int >(wxLANGUAGE_WELSH)));
30523 SWIG_Python_SetConstant(d, "LANGUAGE_WOLOF",SWIG_From_int(static_cast< int >(wxLANGUAGE_WOLOF)));
30524 SWIG_Python_SetConstant(d, "LANGUAGE_XHOSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_XHOSA)));
30525 SWIG_Python_SetConstant(d, "LANGUAGE_YIDDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_YIDDISH)));
30526 SWIG_Python_SetConstant(d, "LANGUAGE_YORUBA",SWIG_From_int(static_cast< int >(wxLANGUAGE_YORUBA)));
30527 SWIG_Python_SetConstant(d, "LANGUAGE_ZHUANG",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZHUANG)));
30528 SWIG_Python_SetConstant(d, "LANGUAGE_ZULU",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZULU)));
30529 SWIG_Python_SetConstant(d, "LANGUAGE_USER_DEFINED",SWIG_From_int(static_cast< int >(wxLANGUAGE_USER_DEFINED)));
30530 SWIG_Python_SetConstant(d, "LOCALE_CAT_NUMBER",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_NUMBER)));
30531 SWIG_Python_SetConstant(d, "LOCALE_CAT_DATE",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_DATE)));
30532 SWIG_Python_SetConstant(d, "LOCALE_CAT_MONEY",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MONEY)));
30533 SWIG_Python_SetConstant(d, "LOCALE_CAT_MAX",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MAX)));
30534 SWIG_Python_SetConstant(d, "LOCALE_THOUSANDS_SEP",SWIG_From_int(static_cast< int >(wxLOCALE_THOUSANDS_SEP)));
30535 SWIG_Python_SetConstant(d, "LOCALE_DECIMAL_POINT",SWIG_From_int(static_cast< int >(wxLOCALE_DECIMAL_POINT)));
30536 SWIG_Python_SetConstant(d, "LOCALE_LOAD_DEFAULT",SWIG_From_int(static_cast< int >(wxLOCALE_LOAD_DEFAULT)));
30537 SWIG_Python_SetConstant(d, "LOCALE_CONV_ENCODING",SWIG_From_int(static_cast< int >(wxLOCALE_CONV_ENCODING)));
30538 SWIG_Python_SetConstant(d, "CONVERT_STRICT",SWIG_From_int(static_cast< int >(wxCONVERT_STRICT)));
30539 SWIG_Python_SetConstant(d, "CONVERT_SUBSTITUTE",SWIG_From_int(static_cast< int >(wxCONVERT_SUBSTITUTE)));
30540 SWIG_Python_SetConstant(d, "PLATFORM_CURRENT",SWIG_From_int(static_cast< int >(wxPLATFORM_CURRENT)));
30541 SWIG_Python_SetConstant(d, "PLATFORM_UNIX",SWIG_From_int(static_cast< int >(wxPLATFORM_UNIX)));
30542 SWIG_Python_SetConstant(d, "PLATFORM_WINDOWS",SWIG_From_int(static_cast< int >(wxPLATFORM_WINDOWS)));
30543 SWIG_Python_SetConstant(d, "PLATFORM_OS2",SWIG_From_int(static_cast< int >(wxPLATFORM_OS2)));
30544 SWIG_Python_SetConstant(d, "PLATFORM_MAC",SWIG_From_int(static_cast< int >(wxPLATFORM_MAC)));
30545 SWIG_Python_SetConstant(d, "BUFFER_VIRTUAL_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_VIRTUAL_AREA)));
30546 SWIG_Python_SetConstant(d, "BUFFER_CLIENT_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_CLIENT_AREA)));
30547 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_NORMAL)));
30548 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_TRANSPARENT)));
30549 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_SELECTED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_SELECTED)));
30550 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_FOCUSED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_FOCUSED)));
30551 SWIG_Python_SetConstant(d, "IMAGE_LIST_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_NORMAL)));
30552 SWIG_Python_SetConstant(d, "IMAGE_LIST_SMALL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_SMALL)));
30553 SWIG_Python_SetConstant(d, "IMAGE_LIST_STATE",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_STATE)));
30554 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLACK)));
30555 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLUE)));
30556 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_CYAN)));
30557 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREEN)));
30558 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREY)));
30559 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_LIGHTGREY)));
30560 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_MEDIUMGREY)));
30561 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_RED",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_RED)));
30562 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_TRANSPARENT)));
30563 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_WHITE)));
30564 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLACK)));
30565 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLUE)));
30566 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_CYAN)));
30567 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_GREEN)));
30568 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_LIGHTGREY)));
30569 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_RED",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_RED)));
30570 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_WHITE)));
30571 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_CROSS)));
30572 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_HOURGLASS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_HOURGLASS)));
30573 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_STANDARD",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_STANDARD)));
30574 SWIG_Python_SetConstant(d, "StockGDI_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_ITALIC)));
30575 SWIG_Python_SetConstant(d, "StockGDI_FONT_NORMAL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_NORMAL)));
30576 SWIG_Python_SetConstant(d, "StockGDI_FONT_SMALL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SMALL)));
30577 SWIG_Python_SetConstant(d, "StockGDI_FONT_SWISS",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SWISS)));
30578 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACK)));
30579 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACKDASHED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACKDASHED)));
30580 SWIG_Python_SetConstant(d, "StockGDI_PEN_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_CYAN)));
30581 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREEN)));
30582 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREY)));
30583 SWIG_Python_SetConstant(d, "StockGDI_PEN_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_LIGHTGREY)));
30584 SWIG_Python_SetConstant(d, "StockGDI_PEN_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_MEDIUMGREY)));
30585 SWIG_Python_SetConstant(d, "StockGDI_PEN_RED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_RED)));
30586 SWIG_Python_SetConstant(d, "StockGDI_PEN_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_TRANSPARENT)));
30587 SWIG_Python_SetConstant(d, "StockGDI_PEN_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_WHITE)));
30588 SWIG_Python_SetConstant(d, "StockGDI_ITEMCOUNT",SWIG_From_int(static_cast< int >(wxStockGDI::ITEMCOUNT)));
30589 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
30590 SWIG_addvarlink(SWIG_globals(),(char*)"NullBitmap",NullBitmap_get, NullBitmap_set);
30591 SWIG_addvarlink(SWIG_globals(),(char*)"NullIcon",NullIcon_get, NullIcon_set);
30592 SWIG_addvarlink(SWIG_globals(),(char*)"NullCursor",NullCursor_get, NullCursor_set);
30593 SWIG_addvarlink(SWIG_globals(),(char*)"NullPen",NullPen_get, NullPen_set);
30594 SWIG_addvarlink(SWIG_globals(),(char*)"NullBrush",NullBrush_get, NullBrush_set);
30595 SWIG_addvarlink(SWIG_globals(),(char*)"NullPalette",NullPalette_get, NullPalette_set);
30596 SWIG_addvarlink(SWIG_globals(),(char*)"NullFont",NullFont_get, NullFont_set);
30597 SWIG_addvarlink(SWIG_globals(),(char*)"NullColour",NullColour_get, NullColour_set);
30598 SWIG_Python_SetConstant(d, "CONTROL_DISABLED",SWIG_From_int(static_cast< int >(wxCONTROL_DISABLED)));
30599 SWIG_Python_SetConstant(d, "CONTROL_FOCUSED",SWIG_From_int(static_cast< int >(wxCONTROL_FOCUSED)));
30600 SWIG_Python_SetConstant(d, "CONTROL_PRESSED",SWIG_From_int(static_cast< int >(wxCONTROL_PRESSED)));
30601 SWIG_Python_SetConstant(d, "CONTROL_ISDEFAULT",SWIG_From_int(static_cast< int >(wxCONTROL_ISDEFAULT)));
30602 SWIG_Python_SetConstant(d, "CONTROL_ISSUBMENU",SWIG_From_int(static_cast< int >(wxCONTROL_ISSUBMENU)));
30603 SWIG_Python_SetConstant(d, "CONTROL_EXPANDED",SWIG_From_int(static_cast< int >(wxCONTROL_EXPANDED)));
30604 SWIG_Python_SetConstant(d, "CONTROL_CURRENT",SWIG_From_int(static_cast< int >(wxCONTROL_CURRENT)));
30605 SWIG_Python_SetConstant(d, "CONTROL_SELECTED",SWIG_From_int(static_cast< int >(wxCONTROL_SELECTED)));
30606 SWIG_Python_SetConstant(d, "CONTROL_CHECKED",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKED)));
30607 SWIG_Python_SetConstant(d, "CONTROL_CHECKABLE",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKABLE)));
30608 SWIG_Python_SetConstant(d, "CONTROL_UNDETERMINED",SWIG_From_int(static_cast< int >(wxCONTROL_UNDETERMINED)));
30609 SWIG_Python_SetConstant(d, "CONTROL_FLAGS_MASK",SWIG_From_int(static_cast< int >(wxCONTROL_FLAGS_MASK)));
30610 SWIG_Python_SetConstant(d, "CONTROL_DIRTY",SWIG_From_int(static_cast< int >(wxCONTROL_DIRTY)));
30611 SWIG_Python_SetConstant(d, "RendererVersion_Current_Version",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Version)));
30612 SWIG_Python_SetConstant(d, "RendererVersion_Current_Age",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Age)));
30613
30614 // Work around a chicken/egg problem in drawlist.cpp
30615 wxPyDrawList_SetAPIPtr();
30616
30617 }
30618
wxWidgets (Impactor)