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


04a530c65b9505a3ce2f3a2ed8c4a3bfd7d04003
[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_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_double swig_types[2]
2469 #define SWIGTYPE_p_form_ops_t swig_types[3]
2470 #define SWIGTYPE_p_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxAlphaPixelData swig_types[11]
2478 #define SWIGTYPE_p_wxAlphaPixelData_Accessor swig_types[12]
2479 #define SWIGTYPE_p_wxBMPHandler swig_types[13]
2480 #define SWIGTYPE_p_wxBitmap swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBrush swig_types[16]
2483 #define SWIGTYPE_p_wxBrushList swig_types[17]
2484 #define SWIGTYPE_p_wxBufferedDC swig_types[18]
2485 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[19]
2486 #define SWIGTYPE_p_wxCURHandler swig_types[20]
2487 #define SWIGTYPE_p_wxChar swig_types[21]
2488 #define SWIGTYPE_p_wxChildFocusEvent swig_types[22]
2489 #define SWIGTYPE_p_wxClientDC swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxColourDatabase swig_types[27]
2494 #define SWIGTYPE_p_wxCommandEvent swig_types[28]
2495 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2496 #define SWIGTYPE_p_wxControl swig_types[30]
2497 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2498 #define SWIGTYPE_p_wxCursor swig_types[32]
2499 #define SWIGTYPE_p_wxDC swig_types[33]
2500 #define SWIGTYPE_p_wxDash swig_types[34]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[35]
2502 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[36]
2503 #define SWIGTYPE_p_wxDropFilesEvent swig_types[37]
2504 #define SWIGTYPE_p_wxDuplexMode swig_types[38]
2505 #define SWIGTYPE_p_wxEffects swig_types[39]
2506 #define SWIGTYPE_p_wxEncodingConverter swig_types[40]
2507 #define SWIGTYPE_p_wxEraseEvent swig_types[41]
2508 #define SWIGTYPE_p_wxEvent swig_types[42]
2509 #define SWIGTYPE_p_wxEvtHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFSFile swig_types[44]
2511 #define SWIGTYPE_p_wxFileSystem swig_types[45]
2512 #define SWIGTYPE_p_wxFlexGridSizer swig_types[46]
2513 #define SWIGTYPE_p_wxFocusEvent swig_types[47]
2514 #define SWIGTYPE_p_wxFont swig_types[48]
2515 #define SWIGTYPE_p_wxFontList swig_types[49]
2516 #define SWIGTYPE_p_wxFontMapper swig_types[50]
2517 #define SWIGTYPE_p_wxGBSizerItem swig_types[51]
2518 #define SWIGTYPE_p_wxGDIObjListBase swig_types[52]
2519 #define SWIGTYPE_p_wxGDIObject swig_types[53]
2520 #define SWIGTYPE_p_wxGIFHandler swig_types[54]
2521 #define SWIGTYPE_p_wxGridBagSizer swig_types[55]
2522 #define SWIGTYPE_p_wxGridSizer swig_types[56]
2523 #define SWIGTYPE_p_wxICOHandler swig_types[57]
2524 #define SWIGTYPE_p_wxIcon swig_types[58]
2525 #define SWIGTYPE_p_wxIconBundle swig_types[59]
2526 #define SWIGTYPE_p_wxIconLocation swig_types[60]
2527 #define SWIGTYPE_p_wxIconizeEvent swig_types[61]
2528 #define SWIGTYPE_p_wxIdleEvent swig_types[62]
2529 #define SWIGTYPE_p_wxImage swig_types[63]
2530 #define SWIGTYPE_p_wxImageHandler swig_types[64]
2531 #define SWIGTYPE_p_wxImageList swig_types[65]
2532 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[66]
2533 #define SWIGTYPE_p_wxInitDialogEvent swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLanguageInfo swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxLocale swig_types[72]
2539 #define SWIGTYPE_p_wxMask swig_types[73]
2540 #define SWIGTYPE_p_wxMaximizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxMemoryDC swig_types[75]
2542 #define SWIGTYPE_p_wxMenu swig_types[76]
2543 #define SWIGTYPE_p_wxMenuBar swig_types[77]
2544 #define SWIGTYPE_p_wxMenuEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMenuItem swig_types[79]
2546 #define SWIGTYPE_p_wxMetaFile swig_types[80]
2547 #define SWIGTYPE_p_wxMetaFileDC swig_types[81]
2548 #define SWIGTYPE_p_wxMirrorDC swig_types[82]
2549 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[83]
2550 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[84]
2551 #define SWIGTYPE_p_wxMouseEvent swig_types[85]
2552 #define SWIGTYPE_p_wxMoveEvent swig_types[86]
2553 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[87]
2554 #define SWIGTYPE_p_wxNativeFontInfo swig_types[88]
2555 #define SWIGTYPE_p_wxNativePixelData swig_types[89]
2556 #define SWIGTYPE_p_wxNativePixelData_Accessor swig_types[90]
2557 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[91]
2558 #define SWIGTYPE_p_wxNcPaintEvent swig_types[92]
2559 #define SWIGTYPE_p_wxNotifyEvent swig_types[93]
2560 #define SWIGTYPE_p_wxObject swig_types[94]
2561 #define SWIGTYPE_p_wxPCXHandler swig_types[95]
2562 #define SWIGTYPE_p_wxPNGHandler swig_types[96]
2563 #define SWIGTYPE_p_wxPNMHandler swig_types[97]
2564 #define SWIGTYPE_p_wxPaintDC swig_types[98]
2565 #define SWIGTYPE_p_wxPaintEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPalette swig_types[100]
2567 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPaperSize swig_types[102]
2569 #define SWIGTYPE_p_wxPen swig_types[103]
2570 #define SWIGTYPE_p_wxPenList swig_types[104]
2571 #define SWIGTYPE_p_wxPixelDataBase swig_types[105]
2572 #define SWIGTYPE_p_wxPoint swig_types[106]
2573 #define SWIGTYPE_p_wxPostScriptDC swig_types[107]
2574 #define SWIGTYPE_p_wxPrintData swig_types[108]
2575 #define SWIGTYPE_p_wxPrinterDC swig_types[109]
2576 #define SWIGTYPE_p_wxPseudoDC swig_types[110]
2577 #define SWIGTYPE_p_wxPyApp swig_types[111]
2578 #define SWIGTYPE_p_wxPyCommandEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPyEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[114]
2581 #define SWIGTYPE_p_wxPyImageHandler swig_types[115]
2582 #define SWIGTYPE_p_wxPyLocale swig_types[116]
2583 #define SWIGTYPE_p_wxPySizer swig_types[117]
2584 #define SWIGTYPE_p_wxPyValidator swig_types[118]
2585 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[119]
2586 #define SWIGTYPE_p_wxRect swig_types[120]
2587 #define SWIGTYPE_p_wxRegion swig_types[121]
2588 #define SWIGTYPE_p_wxRegionIterator swig_types[122]
2589 #define SWIGTYPE_p_wxRendererNative swig_types[123]
2590 #define SWIGTYPE_p_wxRendererVersion swig_types[124]
2591 #define SWIGTYPE_p_wxScreenDC swig_types[125]
2592 #define SWIGTYPE_p_wxScrollEvent swig_types[126]
2593 #define SWIGTYPE_p_wxScrollWinEvent swig_types[127]
2594 #define SWIGTYPE_p_wxSetCursorEvent swig_types[128]
2595 #define SWIGTYPE_p_wxShowEvent swig_types[129]
2596 #define SWIGTYPE_p_wxSize swig_types[130]
2597 #define SWIGTYPE_p_wxSizeEvent swig_types[131]
2598 #define SWIGTYPE_p_wxSizer swig_types[132]
2599 #define SWIGTYPE_p_wxSizerItem swig_types[133]
2600 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[134]
2601 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[135]
2602 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[136]
2603 #define SWIGTYPE_p_wxStockGDI swig_types[137]
2604 #define SWIGTYPE_p_wxString swig_types[138]
2605 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[139]
2606 #define SWIGTYPE_p_wxTIFFHandler swig_types[140]
2607 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[141]
2608 #define SWIGTYPE_p_wxValidator swig_types[142]
2609 #define SWIGTYPE_p_wxWindow swig_types[143]
2610 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[144]
2611 #define SWIGTYPE_p_wxWindowDC swig_types[145]
2612 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[146]
2613 #define SWIGTYPE_p_wxXPMHandler swig_types[147]
2614 static swig_type_info *swig_types[149];
2615 static swig_module_info swig_module = {swig_types, 148, 0, 0, 0, 0};
2616 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2617 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2618
2619 /* -------- TYPES TABLE (END) -------- */
2620
2621 #if (PY_VERSION_HEX <= 0x02000000)
2622 # if !defined(SWIG_PYTHON_CLASSIC)
2623 # error "This python version requires to use swig with the '-classic' option"
2624 # endif
2625 #endif
2626 #if (PY_VERSION_HEX <= 0x02020000)
2627 # error "This python version requires to use swig with the '-nomodern' option"
2628 #endif
2629 #if (PY_VERSION_HEX <= 0x02020000)
2630 # error "This python version requires to use swig with the '-nomodernargs' option"
2631 #endif
2632 #ifndef METH_O
2633 # error "This python version requires to use swig with the '-nofastunpack' option"
2634 #endif
2635
2636 /*-----------------------------------------------
2637 @(target):= _gdi_.so
2638 ------------------------------------------------*/
2639 #define SWIG_init init_gdi_
2640
2641 #define SWIG_name "_gdi_"
2642
2643 #define SWIGVERSION 0x010329
2644
2645
2646 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2647 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2648
2649
2650 #include <stdexcept>
2651
2652
2653 namespace swig {
2654 class PyObject_ptr {
2655 protected:
2656 PyObject *_obj;
2657
2658 public:
2659 PyObject_ptr() :_obj(0)
2660 {
2661 }
2662
2663 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2664 {
2665 Py_XINCREF(_obj);
2666 }
2667
2668 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2669 {
2670 if (initial_ref) Py_XINCREF(_obj);
2671 }
2672
2673 PyObject_ptr & operator=(const PyObject_ptr& item)
2674 {
2675 Py_XINCREF(item._obj);
2676 Py_XDECREF(_obj);
2677 _obj = item._obj;
2678 return *this;
2679 }
2680
2681 ~PyObject_ptr()
2682 {
2683 Py_XDECREF(_obj);
2684 }
2685
2686 operator PyObject *() const
2687 {
2688 return _obj;
2689 }
2690
2691 PyObject *operator->() const
2692 {
2693 return _obj;
2694 }
2695 };
2696 }
2697
2698
2699 namespace swig {
2700 struct PyObject_var : PyObject_ptr {
2701 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2702
2703 PyObject_var & operator = (PyObject* obj)
2704 {
2705 Py_XDECREF(_obj);
2706 _obj = obj;
2707 return *this;
2708 }
2709 };
2710 }
2711
2712
2713 #include "wx/wxPython/wxPython.h"
2714 #include "wx/wxPython/pyclasses.h"
2715
2716
2717 static const wxString wxPyEmptyString(wxEmptyString);
2718
2719 #define SWIG_From_long PyInt_FromLong
2720
2721
2722 SWIGINTERNINLINE PyObject *
2723 SWIG_From_int (int value)
2724 {
2725 return SWIG_From_long (value);
2726 }
2727
2728
2729 #include <limits.h>
2730 #ifndef LLONG_MIN
2731 # define LLONG_MIN LONG_LONG_MIN
2732 #endif
2733 #ifndef LLONG_MAX
2734 # define LLONG_MAX LONG_LONG_MAX
2735 #endif
2736 #ifndef ULLONG_MAX
2737 # define ULLONG_MAX ULONG_LONG_MAX
2738 #endif
2739
2740
2741 SWIGINTERN int
2742 SWIG_AsVal_long (PyObject* obj, long* val)
2743 {
2744 if (PyNumber_Check(obj)) {
2745 if (val) *val = PyInt_AsLong(obj);
2746 return SWIG_OK;
2747 }
2748 return SWIG_TypeError;
2749 }
2750
2751
2752 SWIGINTERN int
2753 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2754 {
2755 long v = 0;
2756 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2757 return SWIG_TypeError;
2758 }
2759 else if (val)
2760 *val = (unsigned long)v;
2761 return SWIG_OK;
2762 }
2763
2764
2765 SWIGINTERN int
2766 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
2767 {
2768 unsigned long v;
2769 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2770 if (SWIG_IsOK(res)) {
2771 if ((v > UCHAR_MAX)) {
2772 return SWIG_OverflowError;
2773 } else {
2774 if (val) *val = static_cast< unsigned char >(v);
2775 }
2776 }
2777 return res;
2778 }
2779
2780
2781 SWIGINTERNINLINE PyObject*
2782 SWIG_From_unsigned_SS_long (unsigned long value)
2783 {
2784 return (value > LONG_MAX) ?
2785 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2786 }
2787
2788
2789 SWIGINTERNINLINE PyObject *
2790 SWIG_From_unsigned_SS_char (unsigned char value)
2791 {
2792 return SWIG_From_unsigned_SS_long (value);
2793 }
2794
2795 SWIGINTERN bool wxColour___eq__(wxColour *self,PyObject *other){
2796 wxColour temp, *obj = &temp;
2797 if ( other == Py_None ) return false;
2798 if ( ! wxColour_helper(other, &obj) ) {
2799 PyErr_Clear();
2800 return false;
2801 }
2802 return self->operator==(*obj);
2803 }
2804 SWIGINTERN bool wxColour___ne__(wxColour *self,PyObject *other){
2805 wxColour temp, *obj = &temp;
2806 if ( other == Py_None ) return true;
2807 if ( ! wxColour_helper(other, &obj)) {
2808 PyErr_Clear();
2809 return true;
2810 }
2811 return self->operator!=(*obj);
2812 }
2813
2814 SWIGINTERN int
2815 SWIG_AsVal_bool (PyObject *obj, bool *val)
2816 {
2817 if (obj == Py_True) {
2818 if (val) *val = true;
2819 return SWIG_OK;
2820 } else if (obj == Py_False) {
2821 if (val) *val = false;
2822 return SWIG_OK;
2823 } else {
2824 long v = 0;
2825 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2826 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2827 return res;
2828 }
2829 }
2830
2831 SWIGINTERN PyObject *wxColour_Get(wxColour *self,bool includeAlpha=false){
2832 PyObject* rv = PyTuple_New(includeAlpha ? 4 : 3);
2833 int red = -1;
2834 int green = -1;
2835 int blue = -1;
2836 int alpha = wxALPHA_OPAQUE;
2837 if (self->Ok()) {
2838 red = self->Red();
2839 green = self->Green();
2840 blue = self->Blue();
2841 alpha = self->Alpha();
2842 }
2843 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
2844 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
2845 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
2846 if (includeAlpha)
2847 PyTuple_SetItem(rv, 3, PyInt_FromLong(alpha));
2848 return rv;
2849 }
2850 SWIGINTERN unsigned long wxColour_GetRGB(wxColour *self){
2851 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
2852 }
2853
2854 SWIGINTERN int
2855 SWIG_AsVal_int (PyObject * obj, int *val)
2856 {
2857 long v;
2858 int res = SWIG_AsVal_long (obj, &v);
2859 if (SWIG_IsOK(res)) {
2860 if ((v < INT_MIN || v > INT_MAX)) {
2861 return SWIG_OverflowError;
2862 } else {
2863 if (val) *val = static_cast< int >(v);
2864 }
2865 }
2866 return res;
2867 }
2868
2869 SWIGINTERN PyObject *wxPen_GetDashes(wxPen *self){
2870 wxDash* dashes;
2871 int count = self->GetDashes(&dashes);
2872 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2873 PyObject* retval = PyList_New(0);
2874 for (int x=0; x<count; x++) {
2875 PyObject* pyint = PyInt_FromLong(dashes[x]);
2876 PyList_Append(retval, pyint);
2877 Py_DECREF(pyint);
2878 }
2879 wxPyEndBlockThreads(blocked);
2880 return retval;
2881 }
2882 SWIGINTERN void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
2883 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2884 int size = PyList_Size(pyDashes);
2885 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
2886
2887 // black magic warning! The array of wxDashes needs to exist as
2888 // long as the pen does because wxPen does not copy the array. So
2889 // stick a copy in a Python string object and attach it to _self,
2890 // and then call SetDashes with a pointer to that array. Then
2891 // when the Python pen object is destroyed the array will be
2892 // cleaned up too.
2893 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
2894 PyObject_SetAttrString(_self, "_dashes", strDashes);
2895
2896 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
2897 delete [] dashes;
2898 Py_DECREF(strDashes);
2899 wxPyEndBlockThreads(blocked);
2900 }
2901 SWIGINTERN bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
2902 SWIGINTERN bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
2903
2904 #include <wx/rawbmp.h>
2905
2906
2907 #include <wx/image.h>
2908
2909 static char** ConvertListOfStrings(PyObject* listOfStrings) {
2910 char** cArray = NULL;
2911 int count;
2912
2913 if (!PyList_Check(listOfStrings)) {
2914 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
2915 return NULL;
2916 }
2917 count = PyList_Size(listOfStrings);
2918 cArray = new char*[count];
2919
2920 for(int x=0; x<count; x++) {
2921 // TODO: Need some validation and error checking here
2922 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
2923 }
2924 return cArray;
2925 }
2926
2927
2928 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *listOfStrings){
2929 char** cArray = NULL;
2930 wxBitmap* bmp;
2931
2932 cArray = ConvertListOfStrings(listOfStrings);
2933 if (! cArray)
2934 return NULL;
2935 bmp = new wxBitmap(cArray);
2936 delete [] cArray;
2937 return bmp;
2938 }
2939 SWIGINTERN wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
2940 char* buf;
2941 Py_ssize_t length;
2942 PyString_AsStringAndSize(bits, &buf, &length);
2943 return new wxBitmap(buf, width, height, depth);
2944 }
2945 SWIGINTERN wxSize wxBitmap_GetSize(wxBitmap *self){
2946 wxSize size(self->GetWidth(), self->GetHeight());
2947 return size;
2948 }
2949 SWIGINTERN void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
2950 wxMask *mask = new wxMask(*self, colour);
2951 self->SetMask(mask);
2952 }
2953 SWIGINTERN void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
2954 self->SetWidth(size.x);
2955 self->SetHeight(size.y);
2956 }
2957 SWIGINTERN bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
2958 SWIGINTERN bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
2959
2960 // See http://tinyurl.com/e5adr for what premultiplying alpha means. It
2961 // appears to me that the other platforms are already doing it, so I'll just
2962 // automatically do it for wxMSW here.
2963 #ifdef __WXMSW__
2964 #define wxPy_premultiply(p, a) ((p) * (a) / 256)
2965 #define wxPy_unpremultiply(p, a) ((a) ? ((p) * 256 / (a)) : (p))
2966 #else
2967 #define wxPy_premultiply(p, a) (p)
2968 #define wxPy_unpremultiply(p, a) (p)
2969 #endif
2970
2971
2972 wxBitmap* _BitmapFromBufferAlpha(int width, int height,
2973 buffer data, int DATASIZE,
2974 buffer alpha, int ALPHASIZE)
2975 {
2976 if (DATASIZE != width*height*3) {
2977 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2978 return NULL;
2979 }
2980
2981 if (ALPHASIZE != width*height) {
2982 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2983 return NULL;
2984 }
2985
2986 wxBitmap* bmp = new wxBitmap(width, height, 32);
2987 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
2988 if (! pixData) {
2989 // raise an exception...
2990 wxPyErr_SetString(PyExc_RuntimeError,
2991 "Failed to gain raw access to bitmap data.");
2992 return NULL;
2993 }
2994
2995 pixData.UseAlpha();
2996 wxAlphaPixelData::Iterator p(pixData);
2997 for (int y=0; y<height; y++) {
2998 wxAlphaPixelData::Iterator rowStart = p;
2999 for (int x=0; x<width; x++) {
3000 byte a = *(alpha++);
3001 p.Red() = wxPy_premultiply(*(data++), a);
3002 p.Green() = wxPy_premultiply(*(data++), a);
3003 p.Blue() = wxPy_premultiply(*(data++), a);
3004 p.Alpha() = a;
3005 ++p;
3006 }
3007 p = rowStart;
3008 p.OffsetY(pixData, 1);
3009 }
3010 return bmp;
3011 }
3012
3013 wxBitmap* _BitmapFromBuffer(int width, int height, buffer data, int DATASIZE)
3014 {
3015 if (DATASIZE != width*height*3) {
3016 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3017 return NULL;
3018 }
3019
3020 wxBitmap* bmp = new wxBitmap(width, height, 24);
3021 wxNativePixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3022 if (! pixData) {
3023 // raise an exception...
3024 wxPyErr_SetString(PyExc_RuntimeError,
3025 "Failed to gain raw access to bitmap data.");
3026 return NULL;
3027 }
3028
3029 wxNativePixelData::Iterator p(pixData);
3030 for (int y=0; y<height; y++) {
3031 wxNativePixelData::Iterator rowStart = p;
3032 for (int x=0; x<width; x++) {
3033 p.Red() = *(data++);
3034 p.Green() = *(data++);
3035 p.Blue() = *(data++);
3036 ++p;
3037 }
3038 p = rowStart;
3039 p.OffsetY(pixData, 1);
3040 }
3041 return bmp;
3042 }
3043
3044
3045 wxBitmap* _BitmapFromBufferRGBA(int width, int height, buffer data, int DATASIZE)
3046 {
3047 if (DATASIZE != width*height*4) {
3048 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3049 return NULL;
3050 }
3051
3052 wxBitmap* bmp = new wxBitmap(width, height, 32);
3053 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3054 if (! pixData) {
3055 // raise an exception...
3056 wxPyErr_SetString(PyExc_RuntimeError,
3057 "Failed to gain raw access to bitmap data.");
3058 return NULL;
3059 }
3060
3061 pixData.UseAlpha();
3062 wxAlphaPixelData::Iterator p(pixData);
3063 for (int y=0; y<height; y++) {
3064 wxAlphaPixelData::Iterator rowStart = p;
3065 for (int x=0; x<width; x++) {
3066 byte a = data[3];
3067 p.Red() = wxPy_premultiply(*(data++), a);
3068 p.Green() = wxPy_premultiply(*(data++), a);
3069 p.Blue() = wxPy_premultiply(*(data++), a);
3070 p.Alpha() = a; data++;
3071 ++p;
3072 }
3073 p = rowStart;
3074 p.OffsetY(pixData, 1);
3075 }
3076 return bmp;
3077 }
3078
3079
3080 typedef wxNativePixelData::Iterator wxNativePixelData_Accessor;
3081
3082 SWIGINTERN bool wxNativePixelData___nonzero__(wxNativePixelData *self){ return self->operator bool(); }
3083 SWIGINTERN void wxNativePixelData_Accessor_nextPixel(wxNativePixelData_Accessor *self){ ++(*self); }
3084 SWIGINTERN void wxNativePixelData_Accessor_Set(wxNativePixelData_Accessor *self,byte red,byte green,byte blue){
3085 self->Red() = red;
3086 self->Green() = green;
3087 self->Blue() = blue;
3088 }
3089 SWIGINTERN PyObject *wxNativePixelData_Accessor_Get(wxNativePixelData_Accessor *self){
3090 PyObject* rv = PyTuple_New(3);
3091 PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
3092 PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
3093 PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
3094 return rv;
3095 }
3096
3097 typedef wxAlphaPixelData::Iterator wxAlphaPixelData_Accessor;
3098
3099 SWIGINTERN bool wxAlphaPixelData___nonzero__(wxAlphaPixelData *self){ return self->operator bool(); }
3100 SWIGINTERN void wxAlphaPixelData_Accessor_nextPixel(wxAlphaPixelData_Accessor *self){ ++(*self); }
3101 SWIGINTERN void wxAlphaPixelData_Accessor_Set(wxAlphaPixelData_Accessor *self,byte red,byte green,byte blue,byte alpha){
3102 self->Red() = wxPy_premultiply(red, alpha);
3103 self->Green() = wxPy_premultiply(green, alpha);
3104 self->Blue() = wxPy_premultiply(blue, alpha);
3105 self->Alpha() = alpha;
3106 }
3107 SWIGINTERN PyObject *wxAlphaPixelData_Accessor_Get(wxAlphaPixelData_Accessor *self){
3108 PyObject* rv = PyTuple_New(4);
3109 int red = self->Red();
3110 int green = self->Green();
3111 int blue = self->Blue();
3112 int alpha = self->Alpha();
3113
3114 PyTuple_SetItem(rv, 0, PyInt_FromLong( wxPy_unpremultiply(red, alpha) ));
3115 PyTuple_SetItem(rv, 1, PyInt_FromLong( wxPy_unpremultiply(green, alpha) ));
3116 PyTuple_SetItem(rv, 2, PyInt_FromLong( wxPy_unpremultiply(blue, alpha) ));
3117 PyTuple_SetItem(rv, 3, PyInt_FromLong( alpha ));
3118 return rv;
3119 }
3120 SWIGINTERN wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
3121 if ( !colour.Ok() )
3122 return new wxMask(bitmap, *wxBLACK);
3123 else
3124 return new wxMask(bitmap, colour);
3125 }
3126
3127 #include <wx/iconbndl.h>
3128
3129 SWIGINTERN wxIcon *new_wxIcon(wxBitmap const &bmp){
3130 wxIcon* icon = new wxIcon();
3131 icon->CopyFromBitmap(bmp);
3132 return icon;
3133 }
3134 SWIGINTERN wxIcon *new_wxIcon(PyObject *listOfStrings){
3135 char** cArray = NULL;
3136 wxIcon* icon;
3137
3138 cArray = ConvertListOfStrings(listOfStrings);
3139 if (! cArray)
3140 return NULL;
3141 icon = new wxIcon(cArray);
3142 delete [] cArray;
3143 return icon;
3144 }
3145 SWIGINTERN wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
3146
3147
3148
3149 return new wxIconLocation(*filename);
3150
3151 }
3152 SWIGINTERN void wxIconLocation_SetIndex(wxIconLocation *self,int num){
3153
3154
3155
3156 // do nothing
3157
3158 }
3159 SWIGINTERN int wxIconLocation_GetIndex(wxIconLocation *self){
3160
3161
3162
3163 return -1;
3164
3165 }
3166 SWIGINTERN wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
3167 #ifdef __WXGTK__
3168 wxImage img(cursorName, type);
3169 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
3170 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
3171 return new wxCursor(img);
3172 #else
3173 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
3174 #endif
3175 }
3176
3177
3178 SWIGINTERN void wxRegionIterator_Next(wxRegionIterator *self){
3179 (*self) ++;
3180 }
3181 SWIGINTERN bool wxRegionIterator___nonzero__(wxRegionIterator *self){
3182 return self->operator bool();
3183 }
3184
3185 #include <wx/fontutil.h>
3186 #include <wx/fontmap.h>
3187 #include <wx/fontenum.h>
3188
3189 SWIGINTERN wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
3190 return self->ToString();
3191 }
3192
3193 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
3194 static wxNativeEncodingInfo info;
3195 if ( wxGetNativeFontEncoding(encoding, &info) )
3196 return &info;
3197 else
3198 return NULL;
3199 }
3200
3201
3202 SWIGINTERNINLINE PyObject *
3203 SWIG_From_size_t (size_t value)
3204 {
3205 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3206 }
3207
3208
3209 SWIGINTERNINLINE int
3210 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3211 {
3212 unsigned long v;
3213 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3214 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3215 return res;
3216 }
3217
3218 SWIGINTERN PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
3219 wxFontEncoding alt_enc;
3220 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
3221 return PyInt_FromLong(alt_enc);
3222 else {
3223 Py_INCREF(Py_None);
3224 return Py_None;
3225 }
3226 }
3227 SWIGINTERN wxFont *new_wxFont(wxString const &info){
3228 wxNativeFontInfo nfi;
3229 nfi.FromString(info);
3230 return new wxFont(nfi);
3231 }
3232 SWIGINTERN wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3233 return wxFont::New(pointSize, family, flags, face, encoding);
3234 }
3235 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3236 return wxFontBase::New(pixelSize, family,
3237 style, weight, underlined,
3238 face, encoding);
3239 }
3240 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3241 return wxFontBase::New(pixelSize, family, flags, face, encoding);
3242 }
3243 SWIGINTERN bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
3244 SWIGINTERN bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
3245
3246 class wxPyFontEnumerator : public wxFontEnumerator {
3247 public:
3248 wxPyFontEnumerator() {}
3249 ~wxPyFontEnumerator() {}
3250
3251 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
3252 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
3253
3254 PYPRIVATE;
3255 };
3256
3257 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
3258 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
3259
3260
3261 SWIGINTERN PyObject *wxPyFontEnumerator_GetEncodings(){
3262 PyObject* ret;
3263 wxArrayString arr = wxFontEnumerator::GetEncodings();
3264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3265 ret = wxArrayString2PyList_helper(arr);
3266 wxPyEndBlockThreads(blocked);
3267 return ret;
3268 }
3269 SWIGINTERN PyObject *wxPyFontEnumerator_GetFacenames(){
3270 PyObject* ret;
3271 wxArrayString arr = wxFontEnumerator::GetFacenames();
3272 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3273 ret = wxArrayString2PyList_helper(arr);
3274 wxPyEndBlockThreads(blocked);
3275 return ret;
3276 }
3277
3278 #include <locale.h>
3279
3280 SWIGINTERN wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3281 wxLocale* loc;
3282 if (language == -1)
3283 loc = new wxLocale();
3284 else
3285 loc = new wxLocale(language, flags);
3286 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3287 // for the floating point conversions and such to work right.
3288 #if PY_VERSION_HEX < 0x02040000
3289 setlocale(LC_NUMERIC, "C");
3290 #endif
3291 return loc;
3292 }
3293 SWIGINTERN bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
3294 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
3295 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3296 // for the floating point conversions and such to work right.
3297 #if PY_VERSION_HEX < 0x02040000
3298 setlocale(LC_NUMERIC, "C");
3299 #endif
3300 return rc;
3301 }
3302 SWIGINTERN bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3303 bool rc = self->Init(language, flags);
3304 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3305 // for the floating point conversions and such to work right.
3306 #if PY_VERSION_HEX < 0x02040000
3307 setlocale(LC_NUMERIC, "C");
3308 #endif
3309 return rc;
3310 }
3311
3312 class wxPyLocale : public wxLocale
3313 {
3314 public:
3315 wxPyLocale();
3316
3317 wxPyLocale(const wxChar *szName, // name (for messages)
3318 const wxChar *szShort = (const wxChar *) NULL, // dir prefix (for msg files)
3319 const wxChar *szLocale = (const wxChar *) NULL, // locale (for setlocale)
3320 bool bLoadDefault = true, // preload wxstd.mo?
3321 bool bConvertEncoding = false); // convert Win<->Unix if necessary?
3322
3323 wxPyLocale(int language, // wxLanguage id or custom language
3324 int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
3325
3326 ~wxPyLocale();
3327
3328 virtual const wxChar *GetString(const wxChar *szOrigString,
3329 const wxChar *szDomain = NULL) const;
3330 virtual const wxChar *GetString(const wxChar *szOrigString,
3331 const wxChar *szOrigString2, size_t n,
3332 const wxChar *szDomain = NULL) const;
3333
3334 virtual wxChar *GetSingularString(const wxChar *szOrigString,
3335 const wxChar *szDomain = NULL) const;
3336 virtual wxChar *GetPluralString(const wxChar *szOrigString,
3337 const wxChar *szOrigString2, size_t n,
3338 const wxChar *szDomain = NULL) const;
3339
3340 PYPRIVATE;
3341 private:
3342 DECLARE_NO_COPY_CLASS(wxPyLocale)
3343 };
3344
3345 wxPyLocale::wxPyLocale() : wxLocale()
3346 {
3347 }
3348
3349 wxPyLocale::wxPyLocale(const wxChar *szName, // name (for messages)
3350 const wxChar *szShort, // dir prefix (for msg files)
3351 const wxChar *szLocale, // locale (for setlocale)
3352 bool bLoadDefault, // preload wxstd.mo?
3353 bool bConvertEncoding) // convert Win<->Unix if necessary?
3354 : wxLocale(szName, szShort, szLocale, bLoadDefault, bConvertEncoding)
3355 {
3356 }
3357
3358 wxPyLocale::wxPyLocale(int language, // wxLanguage id or custom language
3359 int flags) : wxLocale(language, flags)
3360 {
3361 }
3362
3363 wxPyLocale::~wxPyLocale()
3364 {
3365 }
3366
3367 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3368 const wxChar *szDomain) const
3369 {
3370 wxChar *str = GetSingularString(szOrigString, szDomain);
3371 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szDomain);
3372 }
3373
3374 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3375 const wxChar *szOrigString2, size_t n,
3376 const wxChar *szDomain) const
3377 {
3378 wxChar *str = GetPluralString(szOrigString, szOrigString2, n, szDomain);
3379 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szOrigString2, n, szDomain);
3380 }
3381
3382 wxChar *wxPyLocale::GetSingularString(const wxChar *szOrigString,
3383 const wxChar *szDomain) const
3384 {
3385 bool found;
3386 static wxString str;
3387 str = _T("error in translation"); // when the first if condition is true but the second if condition is not we do not want to return the previously queried string.
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 if((found=wxPyCBH_findCallback(m_myInst, "GetSingularString"))) {
3390 PyObject* param1 = wx2PyString(szOrigString);
3391 PyObject* param2 = wx2PyString(szDomain);
3392 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", param1, param2));
3393 Py_DECREF(param1);
3394 Py_DECREF(param2);
3395 if (ret) {
3396 str = Py2wxString(ret);
3397 Py_DECREF(ret);
3398 }
3399 }
3400 wxPyEndBlockThreads(blocked);
3401 return (found ? (wxChar*)str.c_str() : NULL);
3402 }
3403
3404 wxChar *wxPyLocale::GetPluralString(const wxChar *szOrigString,
3405 const wxChar *szOrigString2, size_t n,
3406 const wxChar *szDomain) const
3407 {
3408 bool found;
3409 static wxString str;
3410 str = _T("error in translation"); // when the first if condition is true but the second if condition is not we do not want to return the previously queried string.
3411 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3412 if((found=wxPyCBH_findCallback(m_myInst, "GetPluralString"))) {
3413 PyObject* param1 = wx2PyString(szOrigString);
3414 PyObject* param2 = wx2PyString(szOrigString2);
3415 PyObject* param4 = wx2PyString(szDomain);
3416 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOiO)", param1, param2, (int)n, param4));
3417 Py_DECREF(param1);
3418 Py_DECREF(param2);
3419 Py_DECREF(param4);
3420 if( ret) {
3421 str = Py2wxString(ret);
3422 Py_DECREF(ret);
3423 }
3424 }
3425 wxPyEndBlockThreads(blocked);
3426 return (found ? (wxChar*)str.c_str() : NULL);
3427 }
3428
3429 SWIGINTERN wxPyLocale *new_wxPyLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3430 wxPyLocale* loc;
3431 if (language == -1)
3432 loc = new wxPyLocale();
3433 else
3434 loc = new wxPyLocale(language, flags);
3435 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3436 // for the floating point conversions and such to work right.
3437 #if PY_VERSION_HEX < 0x02040000
3438 setlocale(LC_NUMERIC, "C");
3439 #endif
3440 return loc;
3441 }
3442
3443 #include "wx/wxPython/pydrawxxx.h"
3444
3445 SWIGINTERN wxColour wxDC_GetPixel(wxDC *self,int x,int y){
3446 wxColour col;
3447 self->GetPixel(x, y, &col);
3448 return col;
3449 }
3450 SWIGINTERN wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
3451 wxColour col;
3452 self->GetPixel(pt, &col);
3453 return col;
3454 }
3455
3456 SWIGINTERN int
3457 SWIG_AsVal_double (PyObject *obj, double* val)
3458 {
3459 if (PyNumber_Check(obj)) {
3460 if (val) *val = PyFloat_AsDouble(obj);
3461 return SWIG_OK;
3462 }
3463 return SWIG_TypeError;
3464 }
3465
3466 SWIGINTERN wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
3467 wxRect rv;
3468 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
3469 return rv;
3470 }
3471 SWIGINTERN wxRect wxDC_GetClippingRect(wxDC *self){
3472 wxRect rect;
3473 self->GetClippingBox(rect);
3474 return rect;
3475 }
3476 SWIGINTERN wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
3477 wxArrayInt widths;
3478 self->GetPartialTextExtents(text, widths);
3479 return widths;
3480 }
3481
3482 #define SWIG_From_double PyFloat_FromDouble
3483
3484 SWIGINTERN void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
3485 self->SetLogicalOrigin(point.x, point.y);
3486 }
3487 SWIGINTERN void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
3488 self->SetDeviceOrigin(point.x, point.y);
3489 }
3490 SWIGINTERN void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
3491 self->CalcBoundingBox(point.x, point.y);
3492 }
3493 SWIGINTERN PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3494 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
3495 }
3496 SWIGINTERN PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3497 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
3498 }
3499 SWIGINTERN PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3500 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
3501 }
3502 SWIGINTERN PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3503 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
3504 }
3505 SWIGINTERN PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3506 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
3507 }
3508 SWIGINTERN PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
3509 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
3510 }
3511
3512 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
3513 *x1 = dc->MinX();
3514 *y1 = dc->MinY();
3515 *x2 = dc->MaxX();
3516 *y2 = dc->MaxY();
3517 }
3518
3519
3520 #include <wx/dcbuffer.h>
3521
3522
3523 #include <wx/dcps.h>
3524
3525
3526 class wxMetaFile : public wxObject {
3527 public:
3528 wxMetaFile(const wxString&)
3529 { wxPyRaiseNotImplemented(); }
3530 };
3531
3532 class wxMetaFileDC : public wxClientDC {
3533 public:
3534 wxMetaFileDC(const wxString&, int, int, const wxString&)
3535 { wxPyRaiseNotImplemented(); }
3536 };
3537
3538
3539
3540 class wxPrinterDC : public wxClientDC {
3541 public:
3542 wxPrinterDC(const wxPrintData&)
3543 { wxPyRaiseNotImplemented(); }
3544
3545 };
3546
3547
3548
3549 SWIGINTERN void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
3550 self->AddColour(name, wxColour(red, green, blue));
3551 }
3552
3553 wxFontList* _wxPyInitTheFontList() { return wxTheFontList; }
3554 wxPenList* _wxPyInitThePenList() { return wxThePenList; }
3555 wxBrushList* _wxPyInitTheBrushList() { return wxTheBrushList; }
3556 wxColourDatabase* _wxPyInitTheColourDatabase() { return wxTheColourDatabase; }
3557
3558
3559 #include <wx/effects.h>
3560
3561
3562 #include "wx/renderer.h"
3563
3564
3565 SWIGINTERNINLINE PyObject*
3566 SWIG_From_bool (bool value)
3567 {
3568 return PyBool_FromLong(value ? 1 : 0);
3569 }
3570
3571
3572 #include "wx/wxPython/pseudodc.h"
3573
3574 SWIGINTERN wxRect wxPseudoDC_GetIdBounds(wxPseudoDC *self,int id){
3575 wxRect rect;
3576 self->GetIdBounds(id, rect);
3577 return rect;
3578 }
3579 #ifdef __cplusplus
3580 extern "C" {
3581 #endif
3582 SWIGINTERN PyObject *_wrap_new_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3583 PyObject *resultobj = 0;
3584 wxGDIObject *result = 0 ;
3585
3586 if (!SWIG_Python_UnpackTuple(args,"new_GDIObject",0,0,0)) SWIG_fail;
3587 {
3588 if (!wxPyCheckForApp()) SWIG_fail;
3589 PyThreadState* __tstate = wxPyBeginAllowThreads();
3590 result = (wxGDIObject *)new wxGDIObject();
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObject, SWIG_POINTER_NEW | 0 );
3595 return resultobj;
3596 fail:
3597 return NULL;
3598 }
3599
3600
3601 SWIGINTERN PyObject *_wrap_delete_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3602 PyObject *resultobj = 0;
3603 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3604 void *argp1 = 0 ;
3605 int res1 = 0 ;
3606 PyObject *swig_obj[1] ;
3607
3608 if (!args) SWIG_fail;
3609 swig_obj[0] = args;
3610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, SWIG_POINTER_DISOWN | 0 );
3611 if (!SWIG_IsOK(res1)) {
3612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObject" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3613 }
3614 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 delete arg1;
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 resultobj = SWIG_Py_Void();
3623 return resultobj;
3624 fail:
3625 return NULL;
3626 }
3627
3628
3629 SWIGINTERN PyObject *_wrap_GDIObject_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3630 PyObject *resultobj = 0;
3631 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3632 bool result;
3633 void *argp1 = 0 ;
3634 int res1 = 0 ;
3635 PyObject *swig_obj[1] ;
3636
3637 if (!args) SWIG_fail;
3638 swig_obj[0] = args;
3639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3640 if (!SWIG_IsOK(res1)) {
3641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_IsNull" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3642 }
3643 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3644 {
3645 PyThreadState* __tstate = wxPyBeginAllowThreads();
3646 result = (bool)(arg1)->IsNull();
3647 wxPyEndAllowThreads(__tstate);
3648 if (PyErr_Occurred()) SWIG_fail;
3649 }
3650 {
3651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3652 }
3653 return resultobj;
3654 fail:
3655 return NULL;
3656 }
3657
3658
3659 SWIGINTERN PyObject *GDIObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3660 PyObject *obj;
3661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3662 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObject, SWIG_NewClientData(obj));
3663 return SWIG_Py_Void();
3664 }
3665
3666 SWIGINTERN PyObject *GDIObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3667 return SWIG_Python_InitShadowInstance(args);
3668 }
3669
3670 SWIGINTERN PyObject *_wrap_new_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj = 0;
3672 byte arg1 = (byte) 0 ;
3673 byte arg2 = (byte) 0 ;
3674 byte arg3 = (byte) 0 ;
3675 byte arg4 = (byte) wxALPHA_OPAQUE ;
3676 wxColour *result = 0 ;
3677 unsigned char val1 ;
3678 int ecode1 = 0 ;
3679 unsigned char val2 ;
3680 int ecode2 = 0 ;
3681 unsigned char val3 ;
3682 int ecode3 = 0 ;
3683 unsigned char val4 ;
3684 int ecode4 = 0 ;
3685 PyObject * obj0 = 0 ;
3686 PyObject * obj1 = 0 ;
3687 PyObject * obj2 = 0 ;
3688 PyObject * obj3 = 0 ;
3689 char * kwnames[] = {
3690 (char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
3691 };
3692
3693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Colour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3694 if (obj0) {
3695 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
3696 if (!SWIG_IsOK(ecode1)) {
3697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Colour" "', expected argument " "1"" of type '" "byte""'");
3698 }
3699 arg1 = static_cast< byte >(val1);
3700 }
3701 if (obj1) {
3702 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3703 if (!SWIG_IsOK(ecode2)) {
3704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Colour" "', expected argument " "2"" of type '" "byte""'");
3705 }
3706 arg2 = static_cast< byte >(val2);
3707 }
3708 if (obj2) {
3709 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3710 if (!SWIG_IsOK(ecode3)) {
3711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Colour" "', expected argument " "3"" of type '" "byte""'");
3712 }
3713 arg3 = static_cast< byte >(val3);
3714 }
3715 if (obj3) {
3716 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3717 if (!SWIG_IsOK(ecode4)) {
3718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Colour" "', expected argument " "4"" of type '" "byte""'");
3719 }
3720 arg4 = static_cast< byte >(val4);
3721 }
3722 {
3723 PyThreadState* __tstate = wxPyBeginAllowThreads();
3724 result = (wxColour *)new wxColour(arg1,arg2,arg3,arg4);
3725 wxPyEndAllowThreads(__tstate);
3726 if (PyErr_Occurred()) SWIG_fail;
3727 }
3728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_NEW | 0 );
3729 return resultobj;
3730 fail:
3731 return NULL;
3732 }
3733
3734
3735 SWIGINTERN PyObject *_wrap_new_NamedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3736 PyObject *resultobj = 0;
3737 wxString *arg1 = 0 ;
3738 wxColour *result = 0 ;
3739 bool temp1 = false ;
3740 PyObject * obj0 = 0 ;
3741 char * kwnames[] = {
3742 (char *) "colorName", NULL
3743 };
3744
3745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) SWIG_fail;
3746 {
3747 arg1 = wxString_in_helper(obj0);
3748 if (arg1 == NULL) SWIG_fail;
3749 temp1 = true;
3750 }
3751 {
3752 if (!wxPyCheckForApp()) SWIG_fail;
3753 PyThreadState* __tstate = wxPyBeginAllowThreads();
3754 result = (wxColour *)new wxColour((wxString const &)*arg1);
3755 wxPyEndAllowThreads(__tstate);
3756 if (PyErr_Occurred()) SWIG_fail;
3757 }
3758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3759 {
3760 if (temp1)
3761 delete arg1;
3762 }
3763 return resultobj;
3764 fail:
3765 {
3766 if (temp1)
3767 delete arg1;
3768 }
3769 return NULL;
3770 }
3771
3772
3773 SWIGINTERN PyObject *_wrap_new_ColourRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3774 PyObject *resultobj = 0;
3775 unsigned long arg1 ;
3776 wxColour *result = 0 ;
3777 unsigned long val1 ;
3778 int ecode1 = 0 ;
3779 PyObject * obj0 = 0 ;
3780 char * kwnames[] = {
3781 (char *) "colRGB", NULL
3782 };
3783
3784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) SWIG_fail;
3785 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
3786 if (!SWIG_IsOK(ecode1)) {
3787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourRGB" "', expected argument " "1"" of type '" "unsigned long""'");
3788 }
3789 arg1 = static_cast< unsigned long >(val1);
3790 {
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 result = (wxColour *)new wxColour(arg1);
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 SWIGINTERN PyObject *_wrap_delete_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3804 PyObject *resultobj = 0;
3805 wxColour *arg1 = (wxColour *) 0 ;
3806 void *argp1 = 0 ;
3807 int res1 = 0 ;
3808 PyObject *swig_obj[1] ;
3809
3810 if (!args) SWIG_fail;
3811 swig_obj[0] = args;
3812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, SWIG_POINTER_DISOWN | 0 );
3813 if (!SWIG_IsOK(res1)) {
3814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Colour" "', expected argument " "1"" of type '" "wxColour *""'");
3815 }
3816 arg1 = reinterpret_cast< wxColour * >(argp1);
3817 {
3818 PyThreadState* __tstate = wxPyBeginAllowThreads();
3819 delete arg1;
3820
3821 wxPyEndAllowThreads(__tstate);
3822 if (PyErr_Occurred()) SWIG_fail;
3823 }
3824 resultobj = SWIG_Py_Void();
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 SWIGINTERN PyObject *_wrap_Colour_Red(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3832 PyObject *resultobj = 0;
3833 wxColour *arg1 = (wxColour *) 0 ;
3834 byte result;
3835 void *argp1 = 0 ;
3836 int res1 = 0 ;
3837 PyObject *swig_obj[1] ;
3838
3839 if (!args) SWIG_fail;
3840 swig_obj[0] = args;
3841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3842 if (!SWIG_IsOK(res1)) {
3843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Red" "', expected argument " "1"" of type '" "wxColour *""'");
3844 }
3845 arg1 = reinterpret_cast< wxColour * >(argp1);
3846 {
3847 PyThreadState* __tstate = wxPyBeginAllowThreads();
3848 result = (byte)(arg1)->Red();
3849 wxPyEndAllowThreads(__tstate);
3850 if (PyErr_Occurred()) SWIG_fail;
3851 }
3852 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 SWIGINTERN PyObject *_wrap_Colour_Green(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3860 PyObject *resultobj = 0;
3861 wxColour *arg1 = (wxColour *) 0 ;
3862 byte result;
3863 void *argp1 = 0 ;
3864 int res1 = 0 ;
3865 PyObject *swig_obj[1] ;
3866
3867 if (!args) SWIG_fail;
3868 swig_obj[0] = args;
3869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3870 if (!SWIG_IsOK(res1)) {
3871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Green" "', expected argument " "1"" of type '" "wxColour *""'");
3872 }
3873 arg1 = reinterpret_cast< wxColour * >(argp1);
3874 {
3875 PyThreadState* __tstate = wxPyBeginAllowThreads();
3876 result = (byte)(arg1)->Green();
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 SWIGINTERN PyObject *_wrap_Colour_Blue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3888 PyObject *resultobj = 0;
3889 wxColour *arg1 = (wxColour *) 0 ;
3890 byte result;
3891 void *argp1 = 0 ;
3892 int res1 = 0 ;
3893 PyObject *swig_obj[1] ;
3894
3895 if (!args) SWIG_fail;
3896 swig_obj[0] = args;
3897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3898 if (!SWIG_IsOK(res1)) {
3899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Blue" "', expected argument " "1"" of type '" "wxColour *""'");
3900 }
3901 arg1 = reinterpret_cast< wxColour * >(argp1);
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 result = (byte)(arg1)->Blue();
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 SWIGINTERN PyObject *_wrap_Colour_Alpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3916 PyObject *resultobj = 0;
3917 wxColour *arg1 = (wxColour *) 0 ;
3918 byte result;
3919 void *argp1 = 0 ;
3920 int res1 = 0 ;
3921 PyObject *swig_obj[1] ;
3922
3923 if (!args) SWIG_fail;
3924 swig_obj[0] = args;
3925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3926 if (!SWIG_IsOK(res1)) {
3927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Alpha" "', expected argument " "1"" of type '" "wxColour *""'");
3928 }
3929 arg1 = reinterpret_cast< wxColour * >(argp1);
3930 {
3931 PyThreadState* __tstate = wxPyBeginAllowThreads();
3932 result = (byte)(arg1)->Alpha();
3933 wxPyEndAllowThreads(__tstate);
3934 if (PyErr_Occurred()) SWIG_fail;
3935 }
3936 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 SWIGINTERN PyObject *_wrap_Colour_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3944 PyObject *resultobj = 0;
3945 wxColour *arg1 = (wxColour *) 0 ;
3946 bool result;
3947 void *argp1 = 0 ;
3948 int res1 = 0 ;
3949 PyObject *swig_obj[1] ;
3950
3951 if (!args) SWIG_fail;
3952 swig_obj[0] = args;
3953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3954 if (!SWIG_IsOK(res1)) {
3955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Ok" "', expected argument " "1"" of type '" "wxColour *""'");
3956 }
3957 arg1 = reinterpret_cast< wxColour * >(argp1);
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 result = (bool)(arg1)->Ok();
3961 wxPyEndAllowThreads(__tstate);
3962 if (PyErr_Occurred()) SWIG_fail;
3963 }
3964 {
3965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3966 }
3967 return resultobj;
3968 fail:
3969 return NULL;
3970 }
3971
3972
3973 SWIGINTERN PyObject *_wrap_Colour_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3974 PyObject *resultobj = 0;
3975 wxColour *arg1 = (wxColour *) 0 ;
3976 byte arg2 ;
3977 byte arg3 ;
3978 byte arg4 ;
3979 byte arg5 = (byte) wxALPHA_OPAQUE ;
3980 void *argp1 = 0 ;
3981 int res1 = 0 ;
3982 unsigned char val2 ;
3983 int ecode2 = 0 ;
3984 unsigned char val3 ;
3985 int ecode3 = 0 ;
3986 unsigned char val4 ;
3987 int ecode4 = 0 ;
3988 unsigned char val5 ;
3989 int ecode5 = 0 ;
3990 PyObject * obj0 = 0 ;
3991 PyObject * obj1 = 0 ;
3992 PyObject * obj2 = 0 ;
3993 PyObject * obj3 = 0 ;
3994 PyObject * obj4 = 0 ;
3995 char * kwnames[] = {
3996 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
3997 };
3998
3999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4001 if (!SWIG_IsOK(res1)) {
4002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Set" "', expected argument " "1"" of type '" "wxColour *""'");
4003 }
4004 arg1 = reinterpret_cast< wxColour * >(argp1);
4005 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4006 if (!SWIG_IsOK(ecode2)) {
4007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Set" "', expected argument " "2"" of type '" "byte""'");
4008 }
4009 arg2 = static_cast< byte >(val2);
4010 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4011 if (!SWIG_IsOK(ecode3)) {
4012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Colour_Set" "', expected argument " "3"" of type '" "byte""'");
4013 }
4014 arg3 = static_cast< byte >(val3);
4015 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4016 if (!SWIG_IsOK(ecode4)) {
4017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Colour_Set" "', expected argument " "4"" of type '" "byte""'");
4018 }
4019 arg4 = static_cast< byte >(val4);
4020 if (obj4) {
4021 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
4022 if (!SWIG_IsOK(ecode5)) {
4023 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Colour_Set" "', expected argument " "5"" of type '" "byte""'");
4024 }
4025 arg5 = static_cast< byte >(val5);
4026 }
4027 {
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 (arg1)->Set(arg2,arg3,arg4,arg5);
4030 wxPyEndAllowThreads(__tstate);
4031 if (PyErr_Occurred()) SWIG_fail;
4032 }
4033 resultobj = SWIG_Py_Void();
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 SWIGINTERN PyObject *_wrap_Colour_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4041 PyObject *resultobj = 0;
4042 wxColour *arg1 = (wxColour *) 0 ;
4043 unsigned long arg2 ;
4044 void *argp1 = 0 ;
4045 int res1 = 0 ;
4046 unsigned long val2 ;
4047 int ecode2 = 0 ;
4048 PyObject * obj0 = 0 ;
4049 PyObject * obj1 = 0 ;
4050 char * kwnames[] = {
4051 (char *) "self",(char *) "colRGB", NULL
4052 };
4053
4054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4056 if (!SWIG_IsOK(res1)) {
4057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4058 }
4059 arg1 = reinterpret_cast< wxColour * >(argp1);
4060 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
4061 if (!SWIG_IsOK(ecode2)) {
4062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_SetRGB" "', expected argument " "2"" of type '" "unsigned long""'");
4063 }
4064 arg2 = static_cast< unsigned long >(val2);
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 (arg1)->Set(arg2);
4068 wxPyEndAllowThreads(__tstate);
4069 if (PyErr_Occurred()) SWIG_fail;
4070 }
4071 resultobj = SWIG_Py_Void();
4072 return resultobj;
4073 fail:
4074 return NULL;
4075 }
4076
4077
4078 SWIGINTERN PyObject *_wrap_Colour_SetFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4079 PyObject *resultobj = 0;
4080 wxColour *arg1 = (wxColour *) 0 ;
4081 wxString *arg2 = 0 ;
4082 void *argp1 = 0 ;
4083 int res1 = 0 ;
4084 bool temp2 = false ;
4085 PyObject * obj0 = 0 ;
4086 PyObject * obj1 = 0 ;
4087 char * kwnames[] = {
4088 (char *) "self",(char *) "colourName", NULL
4089 };
4090
4091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) SWIG_fail;
4092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4093 if (!SWIG_IsOK(res1)) {
4094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetFromName" "', expected argument " "1"" of type '" "wxColour *""'");
4095 }
4096 arg1 = reinterpret_cast< wxColour * >(argp1);
4097 {
4098 arg2 = wxString_in_helper(obj1);
4099 if (arg2 == NULL) SWIG_fail;
4100 temp2 = true;
4101 }
4102 {
4103 PyThreadState* __tstate = wxPyBeginAllowThreads();
4104 (arg1)->InitFromName((wxString const &)*arg2);
4105 wxPyEndAllowThreads(__tstate);
4106 if (PyErr_Occurred()) SWIG_fail;
4107 }
4108 resultobj = SWIG_Py_Void();
4109 {
4110 if (temp2)
4111 delete arg2;
4112 }
4113 return resultobj;
4114 fail:
4115 {
4116 if (temp2)
4117 delete arg2;
4118 }
4119 return NULL;
4120 }
4121
4122
4123 SWIGINTERN PyObject *_wrap_Colour_GetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj = 0;
4125 wxColour *arg1 = (wxColour *) 0 ;
4126 long arg2 = (long) wxC2S_NAME|wxC2S_CSS_SYNTAX ;
4127 wxString result;
4128 void *argp1 = 0 ;
4129 int res1 = 0 ;
4130 long val2 ;
4131 int ecode2 = 0 ;
4132 PyObject * obj0 = 0 ;
4133 PyObject * obj1 = 0 ;
4134 char * kwnames[] = {
4135 (char *) "self",(char *) "flags", NULL
4136 };
4137
4138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_GetAsString",kwnames,&obj0,&obj1)) SWIG_fail;
4139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4140 if (!SWIG_IsOK(res1)) {
4141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetAsString" "', expected argument " "1"" of type '" "wxColour const *""'");
4142 }
4143 arg1 = reinterpret_cast< wxColour * >(argp1);
4144 if (obj1) {
4145 ecode2 = SWIG_AsVal_long(obj1, &val2);
4146 if (!SWIG_IsOK(ecode2)) {
4147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_GetAsString" "', expected argument " "2"" of type '" "long""'");
4148 }
4149 arg2 = static_cast< long >(val2);
4150 }
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = ((wxColour const *)arg1)->GetAsString(arg2);
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 {
4158 #if wxUSE_UNICODE
4159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4160 #else
4161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4162 #endif
4163 }
4164 return resultobj;
4165 fail:
4166 return NULL;
4167 }
4168
4169
4170 SWIGINTERN PyObject *_wrap_Colour_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4171 PyObject *resultobj = 0;
4172 wxColour *arg1 = (wxColour *) 0 ;
4173 long result;
4174 void *argp1 = 0 ;
4175 int res1 = 0 ;
4176 PyObject *swig_obj[1] ;
4177
4178 if (!args) SWIG_fail;
4179 swig_obj[0] = args;
4180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4181 if (!SWIG_IsOK(res1)) {
4182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetPixel" "', expected argument " "1"" of type '" "wxColour const *""'");
4183 }
4184 arg1 = reinterpret_cast< wxColour * >(argp1);
4185 {
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (long)((wxColour const *)arg1)->GetPixel();
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 resultobj = SWIG_From_long(static_cast< long >(result));
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 SWIGINTERN PyObject *_wrap_Colour___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = 0;
4200 wxColour *arg1 = (wxColour *) 0 ;
4201 PyObject *arg2 = (PyObject *) 0 ;
4202 bool result;
4203 void *argp1 = 0 ;
4204 int res1 = 0 ;
4205 PyObject * obj0 = 0 ;
4206 PyObject * obj1 = 0 ;
4207 char * kwnames[] = {
4208 (char *) "self",(char *) "other", NULL
4209 };
4210
4211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4213 if (!SWIG_IsOK(res1)) {
4214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___eq__" "', expected argument " "1"" of type '" "wxColour *""'");
4215 }
4216 arg1 = reinterpret_cast< wxColour * >(argp1);
4217 arg2 = obj1;
4218 {
4219 result = (bool)wxColour___eq__(arg1,arg2);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 {
4223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4224 }
4225 return resultobj;
4226 fail:
4227 return NULL;
4228 }
4229
4230
4231 SWIGINTERN PyObject *_wrap_Colour___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4232 PyObject *resultobj = 0;
4233 wxColour *arg1 = (wxColour *) 0 ;
4234 PyObject *arg2 = (PyObject *) 0 ;
4235 bool result;
4236 void *argp1 = 0 ;
4237 int res1 = 0 ;
4238 PyObject * obj0 = 0 ;
4239 PyObject * obj1 = 0 ;
4240 char * kwnames[] = {
4241 (char *) "self",(char *) "other", NULL
4242 };
4243
4244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4246 if (!SWIG_IsOK(res1)) {
4247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___ne__" "', expected argument " "1"" of type '" "wxColour *""'");
4248 }
4249 arg1 = reinterpret_cast< wxColour * >(argp1);
4250 arg2 = obj1;
4251 {
4252 result = (bool)wxColour___ne__(arg1,arg2);
4253 if (PyErr_Occurred()) SWIG_fail;
4254 }
4255 {
4256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4257 }
4258 return resultobj;
4259 fail:
4260 return NULL;
4261 }
4262
4263
4264 SWIGINTERN PyObject *_wrap_Colour_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4265 PyObject *resultobj = 0;
4266 wxColour *arg1 = (wxColour *) 0 ;
4267 bool arg2 = (bool) false ;
4268 PyObject *result = 0 ;
4269 void *argp1 = 0 ;
4270 int res1 = 0 ;
4271 bool val2 ;
4272 int ecode2 = 0 ;
4273 PyObject * obj0 = 0 ;
4274 PyObject * obj1 = 0 ;
4275 char * kwnames[] = {
4276 (char *) "self",(char *) "includeAlpha", NULL
4277 };
4278
4279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_Get",kwnames,&obj0,&obj1)) SWIG_fail;
4280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4281 if (!SWIG_IsOK(res1)) {
4282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Get" "', expected argument " "1"" of type '" "wxColour *""'");
4283 }
4284 arg1 = reinterpret_cast< wxColour * >(argp1);
4285 if (obj1) {
4286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4287 if (!SWIG_IsOK(ecode2)) {
4288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Get" "', expected argument " "2"" of type '" "bool""'");
4289 }
4290 arg2 = static_cast< bool >(val2);
4291 }
4292 {
4293 result = (PyObject *)wxColour_Get(arg1,arg2);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 resultobj = result;
4297 return resultobj;
4298 fail:
4299 return NULL;
4300 }
4301
4302
4303 SWIGINTERN PyObject *_wrap_Colour_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4304 PyObject *resultobj = 0;
4305 wxColour *arg1 = (wxColour *) 0 ;
4306 unsigned long result;
4307 void *argp1 = 0 ;
4308 int res1 = 0 ;
4309 PyObject *swig_obj[1] ;
4310
4311 if (!args) SWIG_fail;
4312 swig_obj[0] = args;
4313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4314 if (!SWIG_IsOK(res1)) {
4315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4316 }
4317 arg1 = reinterpret_cast< wxColour * >(argp1);
4318 {
4319 result = (unsigned long)wxColour_GetRGB(arg1);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 SWIGINTERN PyObject *Colour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330 PyObject *obj;
4331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4332 SWIG_TypeNewClientData(SWIGTYPE_p_wxColour, SWIG_NewClientData(obj));
4333 return SWIG_Py_Void();
4334 }
4335
4336 SWIGINTERN PyObject *Colour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 return SWIG_Python_InitShadowInstance(args);
4338 }
4339
4340 SWIGINTERN PyObject *_wrap_new_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj = 0;
4342 int arg1 ;
4343 unsigned char *arg2 = (unsigned char *) 0 ;
4344 unsigned char *arg3 = (unsigned char *) 0 ;
4345 unsigned char *arg4 = (unsigned char *) 0 ;
4346 wxPalette *result = 0 ;
4347 int val1 ;
4348 int ecode1 = 0 ;
4349 void *argp2 = 0 ;
4350 int res2 = 0 ;
4351 void *argp3 = 0 ;
4352 int res3 = 0 ;
4353 void *argp4 = 0 ;
4354 int res4 = 0 ;
4355 PyObject * obj0 = 0 ;
4356 PyObject * obj1 = 0 ;
4357 PyObject * obj2 = 0 ;
4358 PyObject * obj3 = 0 ;
4359 char * kwnames[] = {
4360 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
4361 };
4362
4363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4364 ecode1 = SWIG_AsVal_int(obj0, &val1);
4365 if (!SWIG_IsOK(ecode1)) {
4366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Palette" "', expected argument " "1"" of type '" "int""'");
4367 }
4368 arg1 = static_cast< int >(val1);
4369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4370 if (!SWIG_IsOK(res2)) {
4371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Palette" "', expected argument " "2"" of type '" "unsigned char const *""'");
4372 }
4373 arg2 = reinterpret_cast< unsigned char * >(argp2);
4374 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
4375 if (!SWIG_IsOK(res3)) {
4376 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Palette" "', expected argument " "3"" of type '" "unsigned char const *""'");
4377 }
4378 arg3 = reinterpret_cast< unsigned char * >(argp3);
4379 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
4380 if (!SWIG_IsOK(res4)) {
4381 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Palette" "', expected argument " "4"" of type '" "unsigned char const *""'");
4382 }
4383 arg4 = reinterpret_cast< unsigned char * >(argp4);
4384 {
4385 if (!wxPyCheckForApp()) SWIG_fail;
4386 PyThreadState* __tstate = wxPyBeginAllowThreads();
4387 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, SWIG_POINTER_NEW | 0 );
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_delete_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxPalette *arg1 = (wxPalette *) 0 ;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, SWIG_POINTER_DISOWN | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Palette" "', expected argument " "1"" of type '" "wxPalette *""'");
4410 }
4411 arg1 = reinterpret_cast< wxPalette * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 delete arg1;
4415
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 resultobj = SWIG_Py_Void();
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 SWIGINTERN PyObject *_wrap_Palette_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj = 0;
4428 wxPalette *arg1 = (wxPalette *) 0 ;
4429 byte arg2 ;
4430 byte arg3 ;
4431 byte arg4 ;
4432 int result;
4433 void *argp1 = 0 ;
4434 int res1 = 0 ;
4435 unsigned char val2 ;
4436 int ecode2 = 0 ;
4437 unsigned char val3 ;
4438 int ecode3 = 0 ;
4439 unsigned char val4 ;
4440 int ecode4 = 0 ;
4441 PyObject * obj0 = 0 ;
4442 PyObject * obj1 = 0 ;
4443 PyObject * obj2 = 0 ;
4444 PyObject * obj3 = 0 ;
4445 char * kwnames[] = {
4446 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
4447 };
4448
4449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4451 if (!SWIG_IsOK(res1)) {
4452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetPixel" "', expected argument " "1"" of type '" "wxPalette *""'");
4453 }
4454 arg1 = reinterpret_cast< wxPalette * >(argp1);
4455 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4456 if (!SWIG_IsOK(ecode2)) {
4457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetPixel" "', expected argument " "2"" of type '" "byte""'");
4458 }
4459 arg2 = static_cast< byte >(val2);
4460 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4461 if (!SWIG_IsOK(ecode3)) {
4462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Palette_GetPixel" "', expected argument " "3"" of type '" "byte""'");
4463 }
4464 arg3 = static_cast< byte >(val3);
4465 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4466 if (!SWIG_IsOK(ecode4)) {
4467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Palette_GetPixel" "', expected argument " "4"" of type '" "byte""'");
4468 }
4469 arg4 = static_cast< byte >(val4);
4470 {
4471 PyThreadState* __tstate = wxPyBeginAllowThreads();
4472 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
4473 wxPyEndAllowThreads(__tstate);
4474 if (PyErr_Occurred()) SWIG_fail;
4475 }
4476 resultobj = SWIG_From_int(static_cast< int >(result));
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 SWIGINTERN PyObject *_wrap_Palette_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj = 0;
4485 wxPalette *arg1 = (wxPalette *) 0 ;
4486 int arg2 ;
4487 byte *arg3 = (byte *) 0 ;
4488 byte *arg4 = (byte *) 0 ;
4489 byte *arg5 = (byte *) 0 ;
4490 bool result;
4491 void *argp1 = 0 ;
4492 int res1 = 0 ;
4493 int val2 ;
4494 int ecode2 = 0 ;
4495 byte temp3 ;
4496 int res3 = SWIG_TMPOBJ ;
4497 byte temp4 ;
4498 int res4 = SWIG_TMPOBJ ;
4499 byte temp5 ;
4500 int res5 = SWIG_TMPOBJ ;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4503 char * kwnames[] = {
4504 (char *) "self",(char *) "pixel", NULL
4505 };
4506
4507 arg3 = &temp3;
4508 arg4 = &temp4;
4509 arg5 = &temp5;
4510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4512 if (!SWIG_IsOK(res1)) {
4513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetRGB" "', expected argument " "1"" of type '" "wxPalette *""'");
4514 }
4515 arg1 = reinterpret_cast< wxPalette * >(argp1);
4516 ecode2 = SWIG_AsVal_int(obj1, &val2);
4517 if (!SWIG_IsOK(ecode2)) {
4518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetRGB" "', expected argument " "2"" of type '" "int""'");
4519 }
4520 arg2 = static_cast< int >(val2);
4521 {
4522 PyThreadState* __tstate = wxPyBeginAllowThreads();
4523 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
4524 wxPyEndAllowThreads(__tstate);
4525 if (PyErr_Occurred()) SWIG_fail;
4526 }
4527 {
4528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4529 }
4530 if (SWIG_IsTmpObj(res3)) {
4531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
4532 } else {
4533 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
4535 }
4536 if (SWIG_IsTmpObj(res4)) {
4537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
4538 } else {
4539 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
4541 }
4542 if (SWIG_IsTmpObj(res5)) {
4543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)));
4544 } else {
4545 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags));
4547 }
4548 return resultobj;
4549 fail:
4550 return NULL;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_Palette_GetColoursCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *resultobj = 0;
4556 wxPalette *arg1 = (wxPalette *) 0 ;
4557 int result;
4558 void *argp1 = 0 ;
4559 int res1 = 0 ;
4560 PyObject *swig_obj[1] ;
4561
4562 if (!args) SWIG_fail;
4563 swig_obj[0] = args;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetColoursCount" "', expected argument " "1"" of type '" "wxPalette const *""'");
4567 }
4568 arg1 = reinterpret_cast< wxPalette * >(argp1);
4569 {
4570 PyThreadState* __tstate = wxPyBeginAllowThreads();
4571 result = (int)((wxPalette const *)arg1)->GetColoursCount();
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 resultobj = SWIG_From_int(static_cast< int >(result));
4576 return resultobj;
4577 fail:
4578 return NULL;
4579 }
4580
4581
4582 SWIGINTERN PyObject *_wrap_Palette_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4583 PyObject *resultobj = 0;
4584 wxPalette *arg1 = (wxPalette *) 0 ;
4585 bool result;
4586 void *argp1 = 0 ;
4587 int res1 = 0 ;
4588 PyObject *swig_obj[1] ;
4589
4590 if (!args) SWIG_fail;
4591 swig_obj[0] = args;
4592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4593 if (!SWIG_IsOK(res1)) {
4594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_Ok" "', expected argument " "1"" of type '" "wxPalette *""'");
4595 }
4596 arg1 = reinterpret_cast< wxPalette * >(argp1);
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (bool)(arg1)->Ok();
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 {
4604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4605 }
4606 return resultobj;
4607 fail:
4608 return NULL;
4609 }
4610
4611
4612 SWIGINTERN PyObject *Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4613 PyObject *obj;
4614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4615 SWIG_TypeNewClientData(SWIGTYPE_p_wxPalette, SWIG_NewClientData(obj));
4616 return SWIG_Py_Void();
4617 }
4618
4619 SWIGINTERN PyObject *Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4620 return SWIG_Python_InitShadowInstance(args);
4621 }
4622
4623 SWIGINTERN PyObject *_wrap_new_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj = 0;
4625 wxColour *arg1 = 0 ;
4626 int arg2 = (int) 1 ;
4627 int arg3 = (int) wxSOLID ;
4628 wxPen *result = 0 ;
4629 wxColour temp1 ;
4630 int val2 ;
4631 int ecode2 = 0 ;
4632 int val3 ;
4633 int ecode3 = 0 ;
4634 PyObject * obj0 = 0 ;
4635 PyObject * obj1 = 0 ;
4636 PyObject * obj2 = 0 ;
4637 char * kwnames[] = {
4638 (char *) "colour",(char *) "width",(char *) "style", NULL
4639 };
4640
4641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4642 {
4643 arg1 = &temp1;
4644 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4645 }
4646 if (obj1) {
4647 ecode2 = SWIG_AsVal_int(obj1, &val2);
4648 if (!SWIG_IsOK(ecode2)) {
4649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pen" "', expected argument " "2"" of type '" "int""'");
4650 }
4651 arg2 = static_cast< int >(val2);
4652 }
4653 if (obj2) {
4654 ecode3 = SWIG_AsVal_int(obj2, &val3);
4655 if (!SWIG_IsOK(ecode3)) {
4656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pen" "', expected argument " "3"" of type '" "int""'");
4657 }
4658 arg3 = static_cast< int >(val3);
4659 }
4660 {
4661 if (!wxPyCheckForApp()) SWIG_fail;
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, SWIG_POINTER_NEW | 0 );
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_delete_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4675 PyObject *resultobj = 0;
4676 wxPen *arg1 = (wxPen *) 0 ;
4677 void *argp1 = 0 ;
4678 int res1 = 0 ;
4679 PyObject *swig_obj[1] ;
4680
4681 if (!args) SWIG_fail;
4682 swig_obj[0] = args;
4683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, SWIG_POINTER_DISOWN | 0 );
4684 if (!SWIG_IsOK(res1)) {
4685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pen" "', expected argument " "1"" of type '" "wxPen *""'");
4686 }
4687 arg1 = reinterpret_cast< wxPen * >(argp1);
4688 {
4689 PyThreadState* __tstate = wxPyBeginAllowThreads();
4690 delete arg1;
4691
4692 wxPyEndAllowThreads(__tstate);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 resultobj = SWIG_Py_Void();
4696 return resultobj;
4697 fail:
4698 return NULL;
4699 }
4700
4701
4702 SWIGINTERN PyObject *_wrap_Pen_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4703 PyObject *resultobj = 0;
4704 wxPen *arg1 = (wxPen *) 0 ;
4705 int result;
4706 void *argp1 = 0 ;
4707 int res1 = 0 ;
4708 PyObject *swig_obj[1] ;
4709
4710 if (!args) SWIG_fail;
4711 swig_obj[0] = args;
4712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4713 if (!SWIG_IsOK(res1)) {
4714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4715 }
4716 arg1 = reinterpret_cast< wxPen * >(argp1);
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (int)(arg1)->GetCap();
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_From_int(static_cast< int >(result));
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 SWIGINTERN PyObject *_wrap_Pen_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4731 PyObject *resultobj = 0;
4732 wxPen *arg1 = (wxPen *) 0 ;
4733 wxColour result;
4734 void *argp1 = 0 ;
4735 int res1 = 0 ;
4736 PyObject *swig_obj[1] ;
4737
4738 if (!args) SWIG_fail;
4739 swig_obj[0] = args;
4740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4743 }
4744 arg1 = reinterpret_cast< wxPen * >(argp1);
4745 {
4746 PyThreadState* __tstate = wxPyBeginAllowThreads();
4747 result = (arg1)->GetColour();
4748 wxPyEndAllowThreads(__tstate);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4752 return resultobj;
4753 fail:
4754 return NULL;
4755 }
4756
4757
4758 SWIGINTERN PyObject *_wrap_Pen_GetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4759 PyObject *resultobj = 0;
4760 wxPen *arg1 = (wxPen *) 0 ;
4761 int result;
4762 void *argp1 = 0 ;
4763 int res1 = 0 ;
4764 PyObject *swig_obj[1] ;
4765
4766 if (!args) SWIG_fail;
4767 swig_obj[0] = args;
4768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4769 if (!SWIG_IsOK(res1)) {
4770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4771 }
4772 arg1 = reinterpret_cast< wxPen * >(argp1);
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (int)(arg1)->GetJoin();
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 resultobj = SWIG_From_int(static_cast< int >(result));
4780 return resultobj;
4781 fail:
4782 return NULL;
4783 }
4784
4785
4786 SWIGINTERN PyObject *_wrap_Pen_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4787 PyObject *resultobj = 0;
4788 wxPen *arg1 = (wxPen *) 0 ;
4789 int result;
4790 void *argp1 = 0 ;
4791 int res1 = 0 ;
4792 PyObject *swig_obj[1] ;
4793
4794 if (!args) SWIG_fail;
4795 swig_obj[0] = args;
4796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4799 }
4800 arg1 = reinterpret_cast< wxPen * >(argp1);
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 result = (int)(arg1)->GetStyle();
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_From_int(static_cast< int >(result));
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Pen_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4815 PyObject *resultobj = 0;
4816 wxPen *arg1 = (wxPen *) 0 ;
4817 int result;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 PyObject *swig_obj[1] ;
4821
4822 if (!args) SWIG_fail;
4823 swig_obj[0] = args;
4824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4827 }
4828 arg1 = reinterpret_cast< wxPen * >(argp1);
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = (int)(arg1)->GetWidth();
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 resultobj = SWIG_From_int(static_cast< int >(result));
4836 return resultobj;
4837 fail:
4838 return NULL;
4839 }
4840
4841
4842 SWIGINTERN PyObject *_wrap_Pen_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4843 PyObject *resultobj = 0;
4844 wxPen *arg1 = (wxPen *) 0 ;
4845 bool result;
4846 void *argp1 = 0 ;
4847 int res1 = 0 ;
4848 PyObject *swig_obj[1] ;
4849
4850 if (!args) SWIG_fail;
4851 swig_obj[0] = args;
4852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4853 if (!SWIG_IsOK(res1)) {
4854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_Ok" "', expected argument " "1"" of type '" "wxPen *""'");
4855 }
4856 arg1 = reinterpret_cast< wxPen * >(argp1);
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 result = (bool)(arg1)->Ok();
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 {
4864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4865 }
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Pen_SetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxPen *arg1 = (wxPen *) 0 ;
4875 int arg2 ;
4876 void *argp1 = 0 ;
4877 int res1 = 0 ;
4878 int val2 ;
4879 int ecode2 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 char * kwnames[] = {
4883 (char *) "self",(char *) "cap_style", NULL
4884 };
4885
4886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) SWIG_fail;
4887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4888 if (!SWIG_IsOK(res1)) {
4889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4890 }
4891 arg1 = reinterpret_cast< wxPen * >(argp1);
4892 ecode2 = SWIG_AsVal_int(obj1, &val2);
4893 if (!SWIG_IsOK(ecode2)) {
4894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetCap" "', expected argument " "2"" of type '" "int""'");
4895 }
4896 arg2 = static_cast< int >(val2);
4897 {
4898 PyThreadState* __tstate = wxPyBeginAllowThreads();
4899 (arg1)->SetCap(arg2);
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_Py_Void();
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 SWIGINTERN PyObject *_wrap_Pen_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj = 0;
4912 wxPen *arg1 = (wxPen *) 0 ;
4913 wxColour *arg2 = 0 ;
4914 void *argp1 = 0 ;
4915 int res1 = 0 ;
4916 wxColour temp2 ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 char * kwnames[] = {
4920 (char *) "self",(char *) "colour", NULL
4921 };
4922
4923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
4924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4925 if (!SWIG_IsOK(res1)) {
4926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4927 }
4928 arg1 = reinterpret_cast< wxPen * >(argp1);
4929 {
4930 arg2 = &temp2;
4931 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4932 }
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 (arg1)->SetColour(*arg2);
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Pen_SetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj = 0;
4948 wxPen *arg1 = (wxPen *) 0 ;
4949 int arg2 ;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 int val2 ;
4953 int ecode2 = 0 ;
4954 PyObject * obj0 = 0 ;
4955 PyObject * obj1 = 0 ;
4956 char * kwnames[] = {
4957 (char *) "self",(char *) "join_style", NULL
4958 };
4959
4960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) SWIG_fail;
4961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4962 if (!SWIG_IsOK(res1)) {
4963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4964 }
4965 arg1 = reinterpret_cast< wxPen * >(argp1);
4966 ecode2 = SWIG_AsVal_int(obj1, &val2);
4967 if (!SWIG_IsOK(ecode2)) {
4968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetJoin" "', expected argument " "2"" of type '" "int""'");
4969 }
4970 arg2 = static_cast< int >(val2);
4971 {
4972 PyThreadState* __tstate = wxPyBeginAllowThreads();
4973 (arg1)->SetJoin(arg2);
4974 wxPyEndAllowThreads(__tstate);
4975 if (PyErr_Occurred()) SWIG_fail;
4976 }
4977 resultobj = SWIG_Py_Void();
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 SWIGINTERN PyObject *_wrap_Pen_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4985 PyObject *resultobj = 0;
4986 wxPen *arg1 = (wxPen *) 0 ;
4987 int arg2 ;
4988 void *argp1 = 0 ;
4989 int res1 = 0 ;
4990 int val2 ;
4991 int ecode2 = 0 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char * kwnames[] = {
4995 (char *) "self",(char *) "style", NULL
4996 };
4997
4998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
4999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
5002 }
5003 arg1 = reinterpret_cast< wxPen * >(argp1);
5004 ecode2 = SWIG_AsVal_int(obj1, &val2);
5005 if (!SWIG_IsOK(ecode2)) {
5006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetStyle" "', expected argument " "2"" of type '" "int""'");
5007 }
5008 arg2 = static_cast< int >(val2);
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 (arg1)->SetStyle(arg2);
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_Pen_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5023 PyObject *resultobj = 0;
5024 wxPen *arg1 = (wxPen *) 0 ;
5025 int arg2 ;
5026 void *argp1 = 0 ;
5027 int res1 = 0 ;
5028 int val2 ;
5029 int ecode2 = 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 char * kwnames[] = {
5033 (char *) "self",(char *) "width", NULL
5034 };
5035
5036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5038 if (!SWIG_IsOK(res1)) {
5039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
5040 }
5041 arg1 = reinterpret_cast< wxPen * >(argp1);
5042 ecode2 = SWIG_AsVal_int(obj1, &val2);
5043 if (!SWIG_IsOK(ecode2)) {
5044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetWidth" "', expected argument " "2"" of type '" "int""'");
5045 }
5046 arg2 = static_cast< int >(val2);
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 (arg1)->SetWidth(arg2);
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_Py_Void();
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Pen_SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5061 PyObject *resultobj = 0;
5062 wxPen *arg1 = (wxPen *) 0 ;
5063 int arg2 ;
5064 wxDash *arg3 = (wxDash *) 0 ;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 char * kwnames[] = {
5070 (char *) "self",(char *) "dashes", NULL
5071 };
5072
5073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) SWIG_fail;
5074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5077 }
5078 arg1 = reinterpret_cast< wxPen * >(argp1);
5079 {
5080 arg2 = PyList_Size(obj1);
5081 arg3 = (wxDash*)byte_LIST_helper(obj1);
5082 if (arg3 == NULL) SWIG_fail;
5083 }
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 (arg1)->SetDashes(arg2,arg3);
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 resultobj = SWIG_Py_Void();
5091 {
5092 if (arg3) delete [] arg3;
5093 }
5094 return resultobj;
5095 fail:
5096 {
5097 if (arg3) delete [] arg3;
5098 }
5099 return NULL;
5100 }
5101
5102
5103 SWIGINTERN PyObject *_wrap_Pen_GetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5104 PyObject *resultobj = 0;
5105 wxPen *arg1 = (wxPen *) 0 ;
5106 PyObject *result = 0 ;
5107 void *argp1 = 0 ;
5108 int res1 = 0 ;
5109 PyObject *swig_obj[1] ;
5110
5111 if (!args) SWIG_fail;
5112 swig_obj[0] = args;
5113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5116 }
5117 arg1 = reinterpret_cast< wxPen * >(argp1);
5118 {
5119 PyThreadState* __tstate = wxPyBeginAllowThreads();
5120 result = (PyObject *)wxPen_GetDashes(arg1);
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 resultobj = result;
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 SWIGINTERN PyObject *_wrap_Pen__SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj = 0;
5133 wxPen *arg1 = (wxPen *) 0 ;
5134 PyObject *arg2 = (PyObject *) 0 ;
5135 PyObject *arg3 = (PyObject *) 0 ;
5136 void *argp1 = 0 ;
5137 int res1 = 0 ;
5138 PyObject * obj0 = 0 ;
5139 PyObject * obj1 = 0 ;
5140 PyObject * obj2 = 0 ;
5141 char * kwnames[] = {
5142 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
5143 };
5144
5145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen__SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5149 }
5150 arg1 = reinterpret_cast< wxPen * >(argp1);
5151 arg2 = obj1;
5152 arg3 = obj2;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 wxPen__SetDashes(arg1,arg2,arg3);
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 resultobj = SWIG_Py_Void();
5160 return resultobj;
5161 fail:
5162 return NULL;
5163 }
5164
5165
5166 SWIGINTERN PyObject *_wrap_Pen_GetDashCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5167 PyObject *resultobj = 0;
5168 wxPen *arg1 = (wxPen *) 0 ;
5169 int result;
5170 void *argp1 = 0 ;
5171 int res1 = 0 ;
5172 PyObject *swig_obj[1] ;
5173
5174 if (!args) SWIG_fail;
5175 swig_obj[0] = args;
5176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashCount" "', expected argument " "1"" of type '" "wxPen const *""'");
5179 }
5180 arg1 = reinterpret_cast< wxPen * >(argp1);
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (int)((wxPen const *)arg1)->GetDashCount();
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_From_int(static_cast< int >(result));
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *_wrap_Pen___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj = 0;
5196 wxPen *arg1 = (wxPen *) 0 ;
5197 wxPen *arg2 = (wxPen *) 0 ;
5198 bool result;
5199 void *argp1 = 0 ;
5200 int res1 = 0 ;
5201 void *argp2 = 0 ;
5202 int res2 = 0 ;
5203 PyObject * obj0 = 0 ;
5204 PyObject * obj1 = 0 ;
5205 char * kwnames[] = {
5206 (char *) "self",(char *) "other", NULL
5207 };
5208
5209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5211 if (!SWIG_IsOK(res1)) {
5212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___eq__" "', expected argument " "1"" of type '" "wxPen *""'");
5213 }
5214 arg1 = reinterpret_cast< wxPen * >(argp1);
5215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5216 if (!SWIG_IsOK(res2)) {
5217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___eq__" "', expected argument " "2"" of type '" "wxPen const *""'");
5218 }
5219 arg2 = reinterpret_cast< wxPen * >(argp2);
5220 {
5221 PyThreadState* __tstate = wxPyBeginAllowThreads();
5222 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
5223 wxPyEndAllowThreads(__tstate);
5224 if (PyErr_Occurred()) SWIG_fail;
5225 }
5226 {
5227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5228 }
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_Pen___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 wxPen *arg1 = (wxPen *) 0 ;
5238 wxPen *arg2 = (wxPen *) 0 ;
5239 bool result;
5240 void *argp1 = 0 ;
5241 int res1 = 0 ;
5242 void *argp2 = 0 ;
5243 int res2 = 0 ;
5244 PyObject * obj0 = 0 ;
5245 PyObject * obj1 = 0 ;
5246 char * kwnames[] = {
5247 (char *) "self",(char *) "other", NULL
5248 };
5249
5250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5252 if (!SWIG_IsOK(res1)) {
5253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___ne__" "', expected argument " "1"" of type '" "wxPen *""'");
5254 }
5255 arg1 = reinterpret_cast< wxPen * >(argp1);
5256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5257 if (!SWIG_IsOK(res2)) {
5258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___ne__" "', expected argument " "2"" of type '" "wxPen const *""'");
5259 }
5260 arg2 = reinterpret_cast< wxPen * >(argp2);
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5269 }
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 SWIGINTERN PyObject *Pen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5277 PyObject *obj;
5278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5279 SWIG_TypeNewClientData(SWIGTYPE_p_wxPen, SWIG_NewClientData(obj));
5280 return SWIG_Py_Void();
5281 }
5282
5283 SWIGINTERN PyObject *Pen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 return SWIG_Python_InitShadowInstance(args);
5285 }
5286
5287 SWIGINTERN PyObject *_wrap_new_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = 0;
5289 wxColour *arg1 = 0 ;
5290 int arg2 = (int) wxSOLID ;
5291 wxBrush *result = 0 ;
5292 wxColour temp1 ;
5293 int val2 ;
5294 int ecode2 = 0 ;
5295 PyObject * obj0 = 0 ;
5296 PyObject * obj1 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "colour",(char *) "style", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) SWIG_fail;
5302 {
5303 arg1 = &temp1;
5304 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
5305 }
5306 if (obj1) {
5307 ecode2 = SWIG_AsVal_int(obj1, &val2);
5308 if (!SWIG_IsOK(ecode2)) {
5309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Brush" "', expected argument " "2"" of type '" "int""'");
5310 }
5311 arg2 = static_cast< int >(val2);
5312 }
5313 {
5314 if (!wxPyCheckForApp()) SWIG_fail;
5315 PyThreadState* __tstate = wxPyBeginAllowThreads();
5316 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
5317 wxPyEndAllowThreads(__tstate);
5318 if (PyErr_Occurred()) SWIG_fail;
5319 }
5320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_NEW | 0 );
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_new_BrushFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5328 PyObject *resultobj = 0;
5329 wxBitmap *arg1 = 0 ;
5330 wxBrush *result = 0 ;
5331 void *argp1 = 0 ;
5332 int res1 = 0 ;
5333 PyObject * obj0 = 0 ;
5334 char * kwnames[] = {
5335 (char *) "stippleBitmap", NULL
5336 };
5337
5338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) SWIG_fail;
5339 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5342 }
5343 if (!argp1) {
5344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5345 }
5346 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5347 {
5348 if (!wxPyCheckForApp()) SWIG_fail;
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_OWN | 0 );
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 SWIGINTERN PyObject *_wrap_delete_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5362 PyObject *resultobj = 0;
5363 wxBrush *arg1 = (wxBrush *) 0 ;
5364 void *argp1 = 0 ;
5365 int res1 = 0 ;
5366 PyObject *swig_obj[1] ;
5367
5368 if (!args) SWIG_fail;
5369 swig_obj[0] = args;
5370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, SWIG_POINTER_DISOWN | 0 );
5371 if (!SWIG_IsOK(res1)) {
5372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brush" "', expected argument " "1"" of type '" "wxBrush *""'");
5373 }
5374 arg1 = reinterpret_cast< wxBrush * >(argp1);
5375 {
5376 PyThreadState* __tstate = wxPyBeginAllowThreads();
5377 delete arg1;
5378
5379 wxPyEndAllowThreads(__tstate);
5380 if (PyErr_Occurred()) SWIG_fail;
5381 }
5382 resultobj = SWIG_Py_Void();
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 SWIGINTERN PyObject *_wrap_Brush_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5390 PyObject *resultobj = 0;
5391 wxBrush *arg1 = (wxBrush *) 0 ;
5392 wxColour *arg2 = 0 ;
5393 void *argp1 = 0 ;
5394 int res1 = 0 ;
5395 wxColour temp2 ;
5396 PyObject * obj0 = 0 ;
5397 PyObject * obj1 = 0 ;
5398 char * kwnames[] = {
5399 (char *) "self",(char *) "col", NULL
5400 };
5401
5402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
5403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5404 if (!SWIG_IsOK(res1)) {
5405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetColour" "', expected argument " "1"" of type '" "wxBrush *""'");
5406 }
5407 arg1 = reinterpret_cast< wxBrush * >(argp1);
5408 {
5409 arg2 = &temp2;
5410 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5411 }
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 (arg1)->SetColour((wxColour const &)*arg2);
5415 wxPyEndAllowThreads(__tstate);
5416 if (PyErr_Occurred()) SWIG_fail;
5417 }
5418 resultobj = SWIG_Py_Void();
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 SWIGINTERN PyObject *_wrap_Brush_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj = 0;
5427 wxBrush *arg1 = (wxBrush *) 0 ;
5428 int arg2 ;
5429 void *argp1 = 0 ;
5430 int res1 = 0 ;
5431 int val2 ;
5432 int ecode2 = 0 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 char * kwnames[] = {
5436 (char *) "self",(char *) "style", NULL
5437 };
5438
5439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5441 if (!SWIG_IsOK(res1)) {
5442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStyle" "', expected argument " "1"" of type '" "wxBrush *""'");
5443 }
5444 arg1 = reinterpret_cast< wxBrush * >(argp1);
5445 ecode2 = SWIG_AsVal_int(obj1, &val2);
5446 if (!SWIG_IsOK(ecode2)) {
5447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_SetStyle" "', expected argument " "2"" of type '" "int""'");
5448 }
5449 arg2 = static_cast< int >(val2);
5450 {
5451 PyThreadState* __tstate = wxPyBeginAllowThreads();
5452 (arg1)->SetStyle(arg2);
5453 wxPyEndAllowThreads(__tstate);
5454 if (PyErr_Occurred()) SWIG_fail;
5455 }
5456 resultobj = SWIG_Py_Void();
5457 return resultobj;
5458 fail:
5459 return NULL;
5460 }
5461
5462
5463 SWIGINTERN PyObject *_wrap_Brush_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5464 PyObject *resultobj = 0;
5465 wxBrush *arg1 = (wxBrush *) 0 ;
5466 wxBitmap *arg2 = 0 ;
5467 void *argp1 = 0 ;
5468 int res1 = 0 ;
5469 void *argp2 = 0 ;
5470 int res2 = 0 ;
5471 PyObject * obj0 = 0 ;
5472 PyObject * obj1 = 0 ;
5473 char * kwnames[] = {
5474 (char *) "self",(char *) "stipple", NULL
5475 };
5476
5477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5479 if (!SWIG_IsOK(res1)) {
5480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStipple" "', expected argument " "1"" of type '" "wxBrush *""'");
5481 }
5482 arg1 = reinterpret_cast< wxBrush * >(argp1);
5483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
5484 if (!SWIG_IsOK(res2)) {
5485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5486 }
5487 if (!argp2) {
5488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5489 }
5490 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 (arg1)->SetStipple((wxBitmap const &)*arg2);
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 resultobj = SWIG_Py_Void();
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Brush_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxBrush *arg1 = (wxBrush *) 0 ;
5507 wxColour result;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 PyObject *swig_obj[1] ;
5511
5512 if (!args) SWIG_fail;
5513 swig_obj[0] = args;
5514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5515 if (!SWIG_IsOK(res1)) {
5516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetColour" "', expected argument " "1"" of type '" "wxBrush const *""'");
5517 }
5518 arg1 = reinterpret_cast< wxBrush * >(argp1);
5519 {
5520 PyThreadState* __tstate = wxPyBeginAllowThreads();
5521 result = ((wxBrush const *)arg1)->GetColour();
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 SWIGINTERN PyObject *_wrap_Brush_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 PyObject *resultobj = 0;
5534 wxBrush *arg1 = (wxBrush *) 0 ;
5535 int result;
5536 void *argp1 = 0 ;
5537 int res1 = 0 ;
5538 PyObject *swig_obj[1] ;
5539
5540 if (!args) SWIG_fail;
5541 swig_obj[0] = args;
5542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5543 if (!SWIG_IsOK(res1)) {
5544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStyle" "', expected argument " "1"" of type '" "wxBrush const *""'");
5545 }
5546 arg1 = reinterpret_cast< wxBrush * >(argp1);
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = (int)((wxBrush const *)arg1)->GetStyle();
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 resultobj = SWIG_From_int(static_cast< int >(result));
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 SWIGINTERN PyObject *_wrap_Brush_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5561 PyObject *resultobj = 0;
5562 wxBrush *arg1 = (wxBrush *) 0 ;
5563 wxBitmap *result = 0 ;
5564 void *argp1 = 0 ;
5565 int res1 = 0 ;
5566 PyObject *swig_obj[1] ;
5567
5568 if (!args) SWIG_fail;
5569 swig_obj[0] = args;
5570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5571 if (!SWIG_IsOK(res1)) {
5572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStipple" "', expected argument " "1"" of type '" "wxBrush const *""'");
5573 }
5574 arg1 = reinterpret_cast< wxBrush * >(argp1);
5575 {
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_Brush_IsHatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590 wxBrush *arg1 = (wxBrush *) 0 ;
5591 bool result;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 PyObject *swig_obj[1] ;
5595
5596 if (!args) SWIG_fail;
5597 swig_obj[0] = args;
5598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5599 if (!SWIG_IsOK(res1)) {
5600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_IsHatch" "', expected argument " "1"" of type '" "wxBrush const *""'");
5601 }
5602 arg1 = reinterpret_cast< wxBrush * >(argp1);
5603 {
5604 PyThreadState* __tstate = wxPyBeginAllowThreads();
5605 result = (bool)((wxBrush const *)arg1)->IsHatch();
5606 wxPyEndAllowThreads(__tstate);
5607 if (PyErr_Occurred()) SWIG_fail;
5608 }
5609 {
5610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5611 }
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Brush_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619 PyObject *resultobj = 0;
5620 wxBrush *arg1 = (wxBrush *) 0 ;
5621 bool result;
5622 void *argp1 = 0 ;
5623 int res1 = 0 ;
5624 PyObject *swig_obj[1] ;
5625
5626 if (!args) SWIG_fail;
5627 swig_obj[0] = args;
5628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5629 if (!SWIG_IsOK(res1)) {
5630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_Ok" "', expected argument " "1"" of type '" "wxBrush *""'");
5631 }
5632 arg1 = reinterpret_cast< wxBrush * >(argp1);
5633 {
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = (bool)(arg1)->Ok();
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 {
5640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5641 }
5642 return resultobj;
5643 fail:
5644 return NULL;
5645 }
5646
5647
5648 SWIGINTERN PyObject *Brush_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5649 PyObject *obj;
5650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5651 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrush, SWIG_NewClientData(obj));
5652 return SWIG_Py_Void();
5653 }
5654
5655 SWIGINTERN PyObject *Brush_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5656 return SWIG_Python_InitShadowInstance(args);
5657 }
5658
5659 SWIGINTERN PyObject *_wrap_new_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj = 0;
5661 wxString *arg1 = 0 ;
5662 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
5663 wxBitmap *result = 0 ;
5664 bool temp1 = false ;
5665 int val2 ;
5666 int ecode2 = 0 ;
5667 PyObject * obj0 = 0 ;
5668 PyObject * obj1 = 0 ;
5669 char * kwnames[] = {
5670 (char *) "name",(char *) "type", NULL
5671 };
5672
5673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5674 {
5675 arg1 = wxString_in_helper(obj0);
5676 if (arg1 == NULL) SWIG_fail;
5677 temp1 = true;
5678 }
5679 if (obj1) {
5680 ecode2 = SWIG_AsVal_int(obj1, &val2);
5681 if (!SWIG_IsOK(ecode2)) {
5682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Bitmap" "', expected argument " "2"" of type '" "wxBitmapType""'");
5683 }
5684 arg2 = static_cast< wxBitmapType >(val2);
5685 }
5686 {
5687 if (!wxPyCheckForApp()) SWIG_fail;
5688 PyThreadState* __tstate = wxPyBeginAllowThreads();
5689 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,arg2);
5690 wxPyEndAllowThreads(__tstate);
5691 if (PyErr_Occurred()) SWIG_fail;
5692 }
5693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_NEW | 0 );
5694 {
5695 if (temp1)
5696 delete arg1;
5697 }
5698 return resultobj;
5699 fail:
5700 {
5701 if (temp1)
5702 delete arg1;
5703 }
5704 return NULL;
5705 }
5706
5707
5708 SWIGINTERN PyObject *_wrap_delete_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5709 PyObject *resultobj = 0;
5710 wxBitmap *arg1 = (wxBitmap *) 0 ;
5711 void *argp1 = 0 ;
5712 int res1 = 0 ;
5713 PyObject *swig_obj[1] ;
5714
5715 if (!args) SWIG_fail;
5716 swig_obj[0] = args;
5717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, SWIG_POINTER_DISOWN | 0 );
5718 if (!SWIG_IsOK(res1)) {
5719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bitmap" "', expected argument " "1"" of type '" "wxBitmap *""'");
5720 }
5721 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5722 {
5723 delete arg1;
5724
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 resultobj = SWIG_Py_Void();
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 SWIGINTERN PyObject *_wrap_new_EmptyBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5735 PyObject *resultobj = 0;
5736 int arg1 ;
5737 int arg2 ;
5738 int arg3 = (int) -1 ;
5739 wxBitmap *result = 0 ;
5740 int val1 ;
5741 int ecode1 = 0 ;
5742 int val2 ;
5743 int ecode2 = 0 ;
5744 int val3 ;
5745 int ecode3 = 0 ;
5746 PyObject * obj0 = 0 ;
5747 PyObject * obj1 = 0 ;
5748 PyObject * obj2 = 0 ;
5749 char * kwnames[] = {
5750 (char *) "width",(char *) "height",(char *) "depth", NULL
5751 };
5752
5753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5754 ecode1 = SWIG_AsVal_int(obj0, &val1);
5755 if (!SWIG_IsOK(ecode1)) {
5756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyBitmap" "', expected argument " "1"" of type '" "int""'");
5757 }
5758 arg1 = static_cast< int >(val1);
5759 ecode2 = SWIG_AsVal_int(obj1, &val2);
5760 if (!SWIG_IsOK(ecode2)) {
5761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyBitmap" "', expected argument " "2"" of type '" "int""'");
5762 }
5763 arg2 = static_cast< int >(val2);
5764 if (obj2) {
5765 ecode3 = SWIG_AsVal_int(obj2, &val3);
5766 if (!SWIG_IsOK(ecode3)) {
5767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyBitmap" "', expected argument " "3"" of type '" "int""'");
5768 }
5769 arg3 = static_cast< int >(val3);
5770 }
5771 {
5772 if (!wxPyCheckForApp()) SWIG_fail;
5773 PyThreadState* __tstate = wxPyBeginAllowThreads();
5774 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
5775 wxPyEndAllowThreads(__tstate);
5776 if (PyErr_Occurred()) SWIG_fail;
5777 }
5778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 SWIGINTERN PyObject *_wrap_new_BitmapFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = 0;
5787 wxIcon *arg1 = 0 ;
5788 wxBitmap *result = 0 ;
5789 void *argp1 = 0 ;
5790 int res1 = 0 ;
5791 PyObject * obj0 = 0 ;
5792 char * kwnames[] = {
5793 (char *) "icon", NULL
5794 };
5795
5796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) SWIG_fail;
5797 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
5798 if (!SWIG_IsOK(res1)) {
5799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5800 }
5801 if (!argp1) {
5802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5803 }
5804 arg1 = reinterpret_cast< wxIcon * >(argp1);
5805 {
5806 if (!wxPyCheckForApp()) SWIG_fail;
5807 PyThreadState* __tstate = wxPyBeginAllowThreads();
5808 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 SWIGINTERN PyObject *_wrap_new_BitmapFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5820 PyObject *resultobj = 0;
5821 wxImage *arg1 = 0 ;
5822 int arg2 = (int) -1 ;
5823 wxBitmap *result = 0 ;
5824 void *argp1 = 0 ;
5825 int res1 = 0 ;
5826 int val2 ;
5827 int ecode2 = 0 ;
5828 PyObject * obj0 = 0 ;
5829 PyObject * obj1 = 0 ;
5830 char * kwnames[] = {
5831 (char *) "image",(char *) "depth", NULL
5832 };
5833
5834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) SWIG_fail;
5835 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
5836 if (!SWIG_IsOK(res1)) {
5837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5838 }
5839 if (!argp1) {
5840 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5841 }
5842 arg1 = reinterpret_cast< wxImage * >(argp1);
5843 if (obj1) {
5844 ecode2 = SWIG_AsVal_int(obj1, &val2);
5845 if (!SWIG_IsOK(ecode2)) {
5846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromImage" "', expected argument " "2"" of type '" "int""'");
5847 }
5848 arg2 = static_cast< int >(val2);
5849 }
5850 {
5851 if (!wxPyCheckForApp()) SWIG_fail;
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 SWIGINTERN PyObject *_wrap_new_BitmapFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj = 0;
5866 PyObject *arg1 = (PyObject *) 0 ;
5867 wxBitmap *result = 0 ;
5868 PyObject * obj0 = 0 ;
5869 char * kwnames[] = {
5870 (char *) "listOfStrings", NULL
5871 };
5872
5873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) SWIG_fail;
5874 arg1 = obj0;
5875 {
5876 if (!wxPyCheckForApp()) SWIG_fail;
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 result = (wxBitmap *)new_wxBitmap(arg1);
5879 wxPyEndAllowThreads(__tstate);
5880 if (PyErr_Occurred()) SWIG_fail;
5881 }
5882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5883 return resultobj;
5884 fail:
5885 return NULL;
5886 }
5887
5888
5889 SWIGINTERN PyObject *_wrap_new_BitmapFromBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5890 PyObject *resultobj = 0;
5891 PyObject *arg1 = (PyObject *) 0 ;
5892 int arg2 ;
5893 int arg3 ;
5894 int arg4 = (int) 1 ;
5895 wxBitmap *result = 0 ;
5896 int val2 ;
5897 int ecode2 = 0 ;
5898 int val3 ;
5899 int ecode3 = 0 ;
5900 int val4 ;
5901 int ecode4 = 0 ;
5902 PyObject * obj0 = 0 ;
5903 PyObject * obj1 = 0 ;
5904 PyObject * obj2 = 0 ;
5905 PyObject * obj3 = 0 ;
5906 char * kwnames[] = {
5907 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
5908 };
5909
5910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5911 arg1 = obj0;
5912 ecode2 = SWIG_AsVal_int(obj1, &val2);
5913 if (!SWIG_IsOK(ecode2)) {
5914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromBits" "', expected argument " "2"" of type '" "int""'");
5915 }
5916 arg2 = static_cast< int >(val2);
5917 ecode3 = SWIG_AsVal_int(obj2, &val3);
5918 if (!SWIG_IsOK(ecode3)) {
5919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BitmapFromBits" "', expected argument " "3"" of type '" "int""'");
5920 }
5921 arg3 = static_cast< int >(val3);
5922 if (obj3) {
5923 ecode4 = SWIG_AsVal_int(obj3, &val4);
5924 if (!SWIG_IsOK(ecode4)) {
5925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BitmapFromBits" "', expected argument " "4"" of type '" "int""'");
5926 }
5927 arg4 = static_cast< int >(val4);
5928 }
5929 {
5930 if (!wxPyCheckForApp()) SWIG_fail;
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_Bitmap_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5944 PyObject *resultobj = 0;
5945 wxBitmap *arg1 = (wxBitmap *) 0 ;
5946 bool result;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 PyObject *swig_obj[1] ;
5950
5951 if (!args) SWIG_fail;
5952 swig_obj[0] = args;
5953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5954 if (!SWIG_IsOK(res1)) {
5955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_Ok" "', expected argument " "1"" of type '" "wxBitmap *""'");
5956 }
5957 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5958 {
5959 result = (bool)(arg1)->Ok();
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 {
5963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5964 }
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_Bitmap_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5972 PyObject *resultobj = 0;
5973 wxBitmap *arg1 = (wxBitmap *) 0 ;
5974 int result;
5975 void *argp1 = 0 ;
5976 int res1 = 0 ;
5977 PyObject *swig_obj[1] ;
5978
5979 if (!args) SWIG_fail;
5980 swig_obj[0] = args;
5981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
5982 if (!SWIG_IsOK(res1)) {
5983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
5984 }
5985 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5986 {
5987 result = (int)(arg1)->GetWidth();
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 resultobj = SWIG_From_int(static_cast< int >(result));
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 SWIGINTERN PyObject *_wrap_Bitmap_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5998 PyObject *resultobj = 0;
5999 wxBitmap *arg1 = (wxBitmap *) 0 ;
6000 int result;
6001 void *argp1 = 0 ;
6002 int res1 = 0 ;
6003 PyObject *swig_obj[1] ;
6004
6005 if (!args) SWIG_fail;
6006 swig_obj[0] = args;
6007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6008 if (!SWIG_IsOK(res1)) {
6009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6010 }
6011 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6012 {
6013 result = (int)(arg1)->GetHeight();
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 resultobj = SWIG_From_int(static_cast< int >(result));
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 SWIGINTERN PyObject *_wrap_Bitmap_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6024 PyObject *resultobj = 0;
6025 wxBitmap *arg1 = (wxBitmap *) 0 ;
6026 int result;
6027 void *argp1 = 0 ;
6028 int res1 = 0 ;
6029 PyObject *swig_obj[1] ;
6030
6031 if (!args) SWIG_fail;
6032 swig_obj[0] = args;
6033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6034 if (!SWIG_IsOK(res1)) {
6035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6036 }
6037 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6038 {
6039 result = (int)(arg1)->GetDepth();
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_From_int(static_cast< int >(result));
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Bitmap_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6050 PyObject *resultobj = 0;
6051 wxBitmap *arg1 = (wxBitmap *) 0 ;
6052 wxSize result;
6053 void *argp1 = 0 ;
6054 int res1 = 0 ;
6055 PyObject *swig_obj[1] ;
6056
6057 if (!args) SWIG_fail;
6058 swig_obj[0] = args;
6059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6060 if (!SWIG_IsOK(res1)) {
6061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6062 }
6063 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6064 {
6065 result = wxBitmap_GetSize(arg1);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_Bitmap_ConvertToImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6076 PyObject *resultobj = 0;
6077 wxBitmap *arg1 = (wxBitmap *) 0 ;
6078 SwigValueWrapper<wxImage > result;
6079 void *argp1 = 0 ;
6080 int res1 = 0 ;
6081 PyObject *swig_obj[1] ;
6082
6083 if (!args) SWIG_fail;
6084 swig_obj[0] = args;
6085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6086 if (!SWIG_IsOK(res1)) {
6087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_ConvertToImage" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6088 }
6089 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6090 {
6091 result = ((wxBitmap const *)arg1)->ConvertToImage();
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
6095 return resultobj;
6096 fail:
6097 return NULL;
6098 }
6099
6100
6101 SWIGINTERN PyObject *_wrap_Bitmap_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6102 PyObject *resultobj = 0;
6103 wxBitmap *arg1 = (wxBitmap *) 0 ;
6104 wxMask *result = 0 ;
6105 void *argp1 = 0 ;
6106 int res1 = 0 ;
6107 PyObject *swig_obj[1] ;
6108
6109 if (!args) SWIG_fail;
6110 swig_obj[0] = args;
6111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6112 if (!SWIG_IsOK(res1)) {
6113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetMask" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6114 }
6115 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6116 {
6117 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, 0 | 0 );
6121 return resultobj;
6122 fail:
6123 return NULL;
6124 }
6125
6126
6127 SWIGINTERN PyObject *_wrap_Bitmap_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6128 PyObject *resultobj = 0;
6129 wxBitmap *arg1 = (wxBitmap *) 0 ;
6130 wxMask *arg2 = (wxMask *) 0 ;
6131 void *argp1 = 0 ;
6132 int res1 = 0 ;
6133 int res2 = 0 ;
6134 PyObject * obj0 = 0 ;
6135 PyObject * obj1 = 0 ;
6136 char * kwnames[] = {
6137 (char *) "self",(char *) "mask", NULL
6138 };
6139
6140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
6141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6142 if (!SWIG_IsOK(res1)) {
6143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMask" "', expected argument " "1"" of type '" "wxBitmap *""'");
6144 }
6145 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6146 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
6147 if (!SWIG_IsOK(res2)) {
6148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetMask" "', expected argument " "2"" of type '" "wxMask *""'");
6149 }
6150 {
6151 (arg1)->SetMask(arg2);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 resultobj = SWIG_Py_Void();
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 SWIGINTERN PyObject *_wrap_Bitmap_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj = 0;
6163 wxBitmap *arg1 = (wxBitmap *) 0 ;
6164 wxColour *arg2 = 0 ;
6165 void *argp1 = 0 ;
6166 int res1 = 0 ;
6167 wxColour temp2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char * kwnames[] = {
6171 (char *) "self",(char *) "colour", NULL
6172 };
6173
6174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) SWIG_fail;
6175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6176 if (!SWIG_IsOK(res1)) {
6177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMaskColour" "', expected argument " "1"" of type '" "wxBitmap *""'");
6178 }
6179 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6180 {
6181 arg2 = &temp2;
6182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6183 }
6184 {
6185 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 resultobj = SWIG_Py_Void();
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj = 0;
6197 wxBitmap *arg1 = (wxBitmap *) 0 ;
6198 wxRect *arg2 = 0 ;
6199 SwigValueWrapper<wxBitmap > result;
6200 void *argp1 = 0 ;
6201 int res1 = 0 ;
6202 wxRect temp2 ;
6203 PyObject * obj0 = 0 ;
6204 PyObject * obj1 = 0 ;
6205 char * kwnames[] = {
6206 (char *) "self",(char *) "rect", NULL
6207 };
6208
6209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",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_GetSubBitmap" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6213 }
6214 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6215 {
6216 arg2 = &temp2;
6217 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6218 }
6219 {
6220 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_Bitmap_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj = 0;
6232 wxBitmap *arg1 = (wxBitmap *) 0 ;
6233 wxString *arg2 = 0 ;
6234 wxBitmapType arg3 ;
6235 wxPalette *arg4 = (wxPalette *) NULL ;
6236 bool result;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 bool temp2 = false ;
6240 int val3 ;
6241 int ecode3 = 0 ;
6242 void *argp4 = 0 ;
6243 int res4 = 0 ;
6244 PyObject * obj0 = 0 ;
6245 PyObject * obj1 = 0 ;
6246 PyObject * obj2 = 0 ;
6247 PyObject * obj3 = 0 ;
6248 char * kwnames[] = {
6249 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
6250 };
6251
6252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SaveFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6256 }
6257 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6258 {
6259 arg2 = wxString_in_helper(obj1);
6260 if (arg2 == NULL) SWIG_fail;
6261 temp2 = true;
6262 }
6263 ecode3 = SWIG_AsVal_int(obj2, &val3);
6264 if (!SWIG_IsOK(ecode3)) {
6265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_SaveFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6266 }
6267 arg3 = static_cast< wxBitmapType >(val3);
6268 if (obj3) {
6269 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxPalette, 0 | 0 );
6270 if (!SWIG_IsOK(res4)) {
6271 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Bitmap_SaveFile" "', expected argument " "4"" of type '" "wxPalette *""'");
6272 }
6273 arg4 = reinterpret_cast< wxPalette * >(argp4);
6274 }
6275 {
6276 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3,arg4);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 {
6280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6281 }
6282 {
6283 if (temp2)
6284 delete arg2;
6285 }
6286 return resultobj;
6287 fail:
6288 {
6289 if (temp2)
6290 delete arg2;
6291 }
6292 return NULL;
6293 }
6294
6295
6296 SWIGINTERN PyObject *_wrap_Bitmap_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6297 PyObject *resultobj = 0;
6298 wxBitmap *arg1 = (wxBitmap *) 0 ;
6299 wxString *arg2 = 0 ;
6300 wxBitmapType arg3 ;
6301 bool result;
6302 void *argp1 = 0 ;
6303 int res1 = 0 ;
6304 bool temp2 = false ;
6305 int val3 ;
6306 int ecode3 = 0 ;
6307 PyObject * obj0 = 0 ;
6308 PyObject * obj1 = 0 ;
6309 PyObject * obj2 = 0 ;
6310 char * kwnames[] = {
6311 (char *) "self",(char *) "name",(char *) "type", NULL
6312 };
6313
6314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_LoadFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6318 }
6319 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6320 {
6321 arg2 = wxString_in_helper(obj1);
6322 if (arg2 == NULL) SWIG_fail;
6323 temp2 = true;
6324 }
6325 ecode3 = SWIG_AsVal_int(obj2, &val3);
6326 if (!SWIG_IsOK(ecode3)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6328 }
6329 arg3 = static_cast< wxBitmapType >(val3);
6330 {
6331 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
6332 if (PyErr_Occurred()) SWIG_fail;
6333 }
6334 {
6335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6336 }
6337 {
6338 if (temp2)
6339 delete arg2;
6340 }
6341 return resultobj;
6342 fail:
6343 {
6344 if (temp2)
6345 delete arg2;
6346 }
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_Bitmap_GetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6352 PyObject *resultobj = 0;
6353 wxBitmap *arg1 = (wxBitmap *) 0 ;
6354 wxPalette *result = 0 ;
6355 void *argp1 = 0 ;
6356 int res1 = 0 ;
6357 PyObject *swig_obj[1] ;
6358
6359 if (!args) SWIG_fail;
6360 swig_obj[0] = args;
6361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6362 if (!SWIG_IsOK(res1)) {
6363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetPalette" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6364 }
6365 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6366 {
6367 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, 0 | 0 );
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj = 0;
6379 wxBitmap *arg1 = (wxBitmap *) 0 ;
6380 wxIcon *arg2 = 0 ;
6381 bool result;
6382 void *argp1 = 0 ;
6383 int res1 = 0 ;
6384 void *argp2 = 0 ;
6385 int res2 = 0 ;
6386 PyObject * obj0 = 0 ;
6387 PyObject * obj1 = 0 ;
6388 char * kwnames[] = {
6389 (char *) "self",(char *) "icon", NULL
6390 };
6391
6392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) SWIG_fail;
6393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6394 if (!SWIG_IsOK(res1)) {
6395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "1"" of type '" "wxBitmap *""'");
6396 }
6397 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6398 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
6399 if (!SWIG_IsOK(res2)) {
6400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6401 }
6402 if (!argp2) {
6403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6404 }
6405 arg2 = reinterpret_cast< wxIcon * >(argp2);
6406 {
6407 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 {
6411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6412 }
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 SWIGINTERN PyObject *_wrap_Bitmap_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj = 0;
6421 wxBitmap *arg1 = (wxBitmap *) 0 ;
6422 int arg2 ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 int val2 ;
6426 int ecode2 = 0 ;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char * kwnames[] = {
6430 (char *) "self",(char *) "height", NULL
6431 };
6432
6433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6437 }
6438 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6439 ecode2 = SWIG_AsVal_int(obj1, &val2);
6440 if (!SWIG_IsOK(ecode2)) {
6441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHeight" "', expected argument " "2"" of type '" "int""'");
6442 }
6443 arg2 = static_cast< int >(val2);
6444 {
6445 (arg1)->SetHeight(arg2);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_Py_Void();
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_Bitmap_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj = 0;
6457 wxBitmap *arg1 = (wxBitmap *) 0 ;
6458 int arg2 ;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 int val2 ;
6462 int ecode2 = 0 ;
6463 PyObject * obj0 = 0 ;
6464 PyObject * obj1 = 0 ;
6465 char * kwnames[] = {
6466 (char *) "self",(char *) "width", NULL
6467 };
6468
6469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6473 }
6474 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6475 ecode2 = SWIG_AsVal_int(obj1, &val2);
6476 if (!SWIG_IsOK(ecode2)) {
6477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetWidth" "', expected argument " "2"" of type '" "int""'");
6478 }
6479 arg2 = static_cast< int >(val2);
6480 {
6481 (arg1)->SetWidth(arg2);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 resultobj = SWIG_Py_Void();
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 SWIGINTERN PyObject *_wrap_Bitmap_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6492 PyObject *resultobj = 0;
6493 wxBitmap *arg1 = (wxBitmap *) 0 ;
6494 int arg2 ;
6495 void *argp1 = 0 ;
6496 int res1 = 0 ;
6497 int val2 ;
6498 int ecode2 = 0 ;
6499 PyObject * obj0 = 0 ;
6500 PyObject * obj1 = 0 ;
6501 char * kwnames[] = {
6502 (char *) "self",(char *) "depth", NULL
6503 };
6504
6505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6509 }
6510 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6511 ecode2 = SWIG_AsVal_int(obj1, &val2);
6512 if (!SWIG_IsOK(ecode2)) {
6513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetDepth" "', expected argument " "2"" of type '" "int""'");
6514 }
6515 arg2 = static_cast< int >(val2);
6516 {
6517 (arg1)->SetDepth(arg2);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_Py_Void();
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_Bitmap_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6528 PyObject *resultobj = 0;
6529 wxBitmap *arg1 = (wxBitmap *) 0 ;
6530 wxSize *arg2 = 0 ;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 wxSize temp2 ;
6534 PyObject * obj0 = 0 ;
6535 PyObject * obj1 = 0 ;
6536 char * kwnames[] = {
6537 (char *) "self",(char *) "size", NULL
6538 };
6539
6540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6544 }
6545 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6546 {
6547 arg2 = &temp2;
6548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6549 }
6550 {
6551 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
6552 if (PyErr_Occurred()) SWIG_fail;
6553 }
6554 resultobj = SWIG_Py_Void();
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 SWIGINTERN PyObject *_wrap_Bitmap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6562 PyObject *resultobj = 0;
6563 wxBitmap *arg1 = (wxBitmap *) 0 ;
6564 wxBitmap *arg2 = (wxBitmap *) 0 ;
6565 bool result;
6566 void *argp1 = 0 ;
6567 int res1 = 0 ;
6568 void *argp2 = 0 ;
6569 int res2 = 0 ;
6570 PyObject * obj0 = 0 ;
6571 PyObject * obj1 = 0 ;
6572 char * kwnames[] = {
6573 (char *) "self",(char *) "other", NULL
6574 };
6575
6576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6578 if (!SWIG_IsOK(res1)) {
6579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___eq__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6580 }
6581 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6583 if (!SWIG_IsOK(res2)) {
6584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___eq__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6585 }
6586 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6587 {
6588 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 {
6592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6593 }
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Bitmap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxBitmap *arg1 = (wxBitmap *) 0 ;
6603 wxBitmap *arg2 = (wxBitmap *) 0 ;
6604 bool result;
6605 void *argp1 = 0 ;
6606 int res1 = 0 ;
6607 void *argp2 = 0 ;
6608 int res2 = 0 ;
6609 PyObject * obj0 = 0 ;
6610 PyObject * obj1 = 0 ;
6611 char * kwnames[] = {
6612 (char *) "self",(char *) "other", NULL
6613 };
6614
6615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___ne__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6619 }
6620 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6622 if (!SWIG_IsOK(res2)) {
6623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___ne__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6624 }
6625 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6626 {
6627 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 {
6631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6632 }
6633 return resultobj;
6634 fail:
6635 return NULL;
6636 }
6637
6638
6639 SWIGINTERN PyObject *Bitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6640 PyObject *obj;
6641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6642 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmap, SWIG_NewClientData(obj));
6643 return SWIG_Py_Void();
6644 }
6645
6646 SWIGINTERN PyObject *Bitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6647 return SWIG_Python_InitShadowInstance(args);
6648 }
6649
6650 SWIGINTERN PyObject *_wrap__BitmapFromBufferAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 int arg1 ;
6653 int arg2 ;
6654 buffer arg3 ;
6655 int arg4 ;
6656 buffer arg5 ;
6657 int arg6 ;
6658 wxBitmap *result = 0 ;
6659 int val1 ;
6660 int ecode1 = 0 ;
6661 int val2 ;
6662 int ecode2 = 0 ;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 PyObject * obj2 = 0 ;
6666 PyObject * obj3 = 0 ;
6667 char * kwnames[] = {
6668 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
6669 };
6670
6671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:_BitmapFromBufferAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6672 ecode1 = SWIG_AsVal_int(obj0, &val1);
6673 if (!SWIG_IsOK(ecode1)) {
6674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "1"" of type '" "int""'");
6675 }
6676 arg1 = static_cast< int >(val1);
6677 ecode2 = SWIG_AsVal_int(obj1, &val2);
6678 if (!SWIG_IsOK(ecode2)) {
6679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "2"" of type '" "int""'");
6680 }
6681 arg2 = static_cast< int >(val2);
6682 {
6683 if (obj2 != Py_None) {
6684 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6685 }
6686 }
6687 {
6688 if (obj3 != Py_None) {
6689 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
6690 }
6691 }
6692 {
6693 result = (wxBitmap *)_BitmapFromBufferAlpha(arg1,arg2,arg3,arg4,arg5,arg6);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 SWIGINTERN PyObject *_wrap__BitmapFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6704 PyObject *resultobj = 0;
6705 int arg1 ;
6706 int arg2 ;
6707 buffer arg3 ;
6708 int arg4 ;
6709 wxBitmap *result = 0 ;
6710 int val1 ;
6711 int ecode1 = 0 ;
6712 int val2 ;
6713 int ecode2 = 0 ;
6714 PyObject * obj0 = 0 ;
6715 PyObject * obj1 = 0 ;
6716 PyObject * obj2 = 0 ;
6717 char * kwnames[] = {
6718 (char *) "width",(char *) "height",(char *) "data", NULL
6719 };
6720
6721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBuffer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6722 ecode1 = SWIG_AsVal_int(obj0, &val1);
6723 if (!SWIG_IsOK(ecode1)) {
6724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBuffer" "', expected argument " "1"" of type '" "int""'");
6725 }
6726 arg1 = static_cast< int >(val1);
6727 ecode2 = SWIG_AsVal_int(obj1, &val2);
6728 if (!SWIG_IsOK(ecode2)) {
6729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBuffer" "', expected argument " "2"" of type '" "int""'");
6730 }
6731 arg2 = static_cast< int >(val2);
6732 {
6733 if (obj2 != Py_None) {
6734 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6735 }
6736 }
6737 {
6738 result = (wxBitmap *)_BitmapFromBuffer(arg1,arg2,arg3,arg4);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap__BitmapFromBufferRGBA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6749 PyObject *resultobj = 0;
6750 int arg1 ;
6751 int arg2 ;
6752 buffer arg3 ;
6753 int arg4 ;
6754 wxBitmap *result = 0 ;
6755 int val1 ;
6756 int ecode1 = 0 ;
6757 int val2 ;
6758 int ecode2 = 0 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 PyObject * obj2 = 0 ;
6762 char * kwnames[] = {
6763 (char *) "width",(char *) "height",(char *) "data", NULL
6764 };
6765
6766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBufferRGBA",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6767 ecode1 = SWIG_AsVal_int(obj0, &val1);
6768 if (!SWIG_IsOK(ecode1)) {
6769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "1"" of type '" "int""'");
6770 }
6771 arg1 = static_cast< int >(val1);
6772 ecode2 = SWIG_AsVal_int(obj1, &val2);
6773 if (!SWIG_IsOK(ecode2)) {
6774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "2"" of type '" "int""'");
6775 }
6776 arg2 = static_cast< int >(val2);
6777 {
6778 if (obj2 != Py_None) {
6779 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6780 }
6781 }
6782 {
6783 result = (wxBitmap *)_BitmapFromBufferRGBA(arg1,arg2,arg3,arg4);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_PixelDataBase_GetOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6796 wxPoint result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetOrigin" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6808 {
6809 result = ((wxPixelDataBase const *)arg1)->GetOrigin();
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_PixelDataBase_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6822 int result;
6823 void *argp1 = 0 ;
6824 int res1 = 0 ;
6825 PyObject *swig_obj[1] ;
6826
6827 if (!args) SWIG_fail;
6828 swig_obj[0] = args;
6829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6830 if (!SWIG_IsOK(res1)) {
6831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetWidth" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6832 }
6833 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6834 {
6835 result = (int)((wxPixelDataBase const *)arg1)->GetWidth();
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_From_int(static_cast< int >(result));
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_PixelDataBase_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6846 PyObject *resultobj = 0;
6847 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6848 int result;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 PyObject *swig_obj[1] ;
6852
6853 if (!args) SWIG_fail;
6854 swig_obj[0] = args;
6855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6856 if (!SWIG_IsOK(res1)) {
6857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetHeight" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6858 }
6859 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6860 {
6861 result = (int)((wxPixelDataBase const *)arg1)->GetHeight();
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 resultobj = SWIG_From_int(static_cast< int >(result));
6865 return resultobj;
6866 fail:
6867 return NULL;
6868 }
6869
6870
6871 SWIGINTERN PyObject *_wrap_PixelDataBase_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6872 PyObject *resultobj = 0;
6873 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6874 wxSize result;
6875 void *argp1 = 0 ;
6876 int res1 = 0 ;
6877 PyObject *swig_obj[1] ;
6878
6879 if (!args) SWIG_fail;
6880 swig_obj[0] = args;
6881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6882 if (!SWIG_IsOK(res1)) {
6883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetSize" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6884 }
6885 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6886 {
6887 result = ((wxPixelDataBase const *)arg1)->GetSize();
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap_PixelDataBase_GetRowStride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6898 PyObject *resultobj = 0;
6899 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6900 int result;
6901 void *argp1 = 0 ;
6902 int res1 = 0 ;
6903 PyObject *swig_obj[1] ;
6904
6905 if (!args) SWIG_fail;
6906 swig_obj[0] = args;
6907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6908 if (!SWIG_IsOK(res1)) {
6909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetRowStride" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
6910 }
6911 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
6912 {
6913 result = (int)((wxPixelDataBase const *)arg1)->GetRowStride();
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_From_int(static_cast< int >(result));
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *PixelDataBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924 PyObject *obj;
6925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6926 SWIG_TypeNewClientData(SWIGTYPE_p_wxPixelDataBase, SWIG_NewClientData(obj));
6927 return SWIG_Py_Void();
6928 }
6929
6930 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
6931 PyObject *resultobj = 0;
6932 wxBitmap *arg1 = 0 ;
6933 wxNativePixelData *result = 0 ;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936
6937 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
6938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
6939 if (!SWIG_IsOK(res1)) {
6940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6941 }
6942 if (!argp1) {
6943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6944 }
6945 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6946 {
6947 result = (wxNativePixelData *)new wxNativePixelData(*arg1);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
6958 PyObject *resultobj = 0;
6959 wxBitmap *arg1 = 0 ;
6960 wxRect *arg2 = 0 ;
6961 wxNativePixelData *result = 0 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 wxRect temp2 ;
6965
6966 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
6967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
6968 if (!SWIG_IsOK(res1)) {
6969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6970 }
6971 if (!argp1) {
6972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
6973 }
6974 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6975 {
6976 arg2 = &temp2;
6977 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
6978 }
6979 {
6980 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxRect const &)*arg2);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
6991 PyObject *resultobj = 0;
6992 wxBitmap *arg1 = 0 ;
6993 wxPoint *arg2 = 0 ;
6994 wxSize *arg3 = 0 ;
6995 wxNativePixelData *result = 0 ;
6996 void *argp1 = 0 ;
6997 int res1 = 0 ;
6998 wxPoint temp2 ;
6999 wxSize temp3 ;
7000
7001 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7003 if (!SWIG_IsOK(res1)) {
7004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7005 }
7006 if (!argp1) {
7007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7008 }
7009 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7010 {
7011 arg2 = &temp2;
7012 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7013 }
7014 {
7015 arg3 = &temp3;
7016 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7017 }
7018 {
7019 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 SWIGINTERN PyObject *_wrap_new_NativePixelData(PyObject *self, PyObject *args) {
7030 int argc;
7031 PyObject *argv[4];
7032
7033 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData",0,3,argv))) SWIG_fail;
7034 --argc;
7035 if (argc == 1) {
7036 return _wrap_new_NativePixelData__SWIG_0(self, argc, argv);
7037 }
7038 if (argc == 2) {
7039 return _wrap_new_NativePixelData__SWIG_1(self, argc, argv);
7040 }
7041 if (argc == 3) {
7042 return _wrap_new_NativePixelData__SWIG_2(self, argc, argv);
7043 }
7044
7045 fail:
7046 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData'");
7047 return NULL;
7048 }
7049
7050
7051 SWIGINTERN PyObject *_wrap_delete_NativePixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7052 PyObject *resultobj = 0;
7053 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_DISOWN | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7063 }
7064 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7065 {
7066 delete arg1;
7067
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_Py_Void();
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_NativePixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7078 PyObject *resultobj = 0;
7079 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7080 wxNativePixelData_Accessor result;
7081 void *argp1 = 0 ;
7082 int res1 = 0 ;
7083 PyObject *swig_obj[1] ;
7084
7085 if (!args) SWIG_fail;
7086 swig_obj[0] = args;
7087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7088 if (!SWIG_IsOK(res1)) {
7089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_GetPixels" "', expected argument " "1"" of type '" "wxNativePixelData const *""'");
7090 }
7091 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7092 {
7093 result = ((wxNativePixelData const *)arg1)->GetPixels();
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_NewPointerObj((new wxNativePixelData_Accessor(static_cast< const wxNativePixelData_Accessor& >(result))), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_OWN | 0 );
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 SWIGINTERN PyObject *_wrap_NativePixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7104 PyObject *resultobj = 0;
7105 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 PyObject *swig_obj[1] ;
7109
7110 if (!args) SWIG_fail;
7111 swig_obj[0] = args;
7112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_UseAlpha" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7115 }
7116 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7117 {
7118 (arg1)->UseAlpha();
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_Py_Void();
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_NativePixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7129 PyObject *resultobj = 0;
7130 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7131 bool result;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 PyObject *swig_obj[1] ;
7135
7136 if (!args) SWIG_fail;
7137 swig_obj[0] = args;
7138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7139 if (!SWIG_IsOK(res1)) {
7140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData___nonzero__" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7141 }
7142 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7143 {
7144 result = (bool)wxNativePixelData___nonzero__(arg1);
7145 if (PyErr_Occurred()) SWIG_fail;
7146 }
7147 {
7148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 SWIGINTERN PyObject *NativePixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7157 PyObject *obj;
7158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7159 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData, SWIG_NewClientData(obj));
7160 return SWIG_Py_Void();
7161 }
7162
7163 SWIGINTERN PyObject *NativePixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7164 return SWIG_Python_InitShadowInstance(args);
7165 }
7166
7167 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7168 PyObject *resultobj = 0;
7169 wxNativePixelData *arg1 = 0 ;
7170 wxNativePixelData_Accessor *result = 0 ;
7171 void *argp1 = 0 ;
7172 int res1 = 0 ;
7173
7174 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxNativePixelData, 0 );
7176 if (!SWIG_IsOK(res1)) {
7177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7178 }
7179 if (!argp1) {
7180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7181 }
7182 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7183 {
7184 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7195 PyObject *resultobj = 0;
7196 wxBitmap *arg1 = 0 ;
7197 wxNativePixelData *arg2 = 0 ;
7198 wxNativePixelData_Accessor *result = 0 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 void *argp2 = 0 ;
7202 int res2 = 0 ;
7203
7204 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7206 if (!SWIG_IsOK(res1)) {
7207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7208 }
7209 if (!argp1) {
7210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7211 }
7212 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7213 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxNativePixelData, 0 );
7214 if (!SWIG_IsOK(res2)) {
7215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7216 }
7217 if (!argp2) {
7218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7219 }
7220 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7221 {
7222 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1,*arg2);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7226 return resultobj;
7227 fail:
7228 return NULL;
7229 }
7230
7231
7232 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
7233 PyObject *resultobj = 0;
7234 wxNativePixelData_Accessor *result = 0 ;
7235
7236 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
7237 {
7238 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor();
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor(PyObject *self, PyObject *args) {
7249 int argc;
7250 PyObject *argv[3];
7251
7252 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData_Accessor",0,2,argv))) SWIG_fail;
7253 --argc;
7254 if (argc == 0) {
7255 return _wrap_new_NativePixelData_Accessor__SWIG_2(self, argc, argv);
7256 }
7257 if (argc == 1) {
7258 return _wrap_new_NativePixelData_Accessor__SWIG_0(self, argc, argv);
7259 }
7260 if (argc == 2) {
7261 return _wrap_new_NativePixelData_Accessor__SWIG_1(self, argc, argv);
7262 }
7263
7264 fail:
7265 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData_Accessor'");
7266 return NULL;
7267 }
7268
7269
7270 SWIGINTERN PyObject *_wrap_delete_NativePixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7271 PyObject *resultobj = 0;
7272 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7273 void *argp1 = 0 ;
7274 int res1 = 0 ;
7275 PyObject *swig_obj[1] ;
7276
7277 if (!args) SWIG_fail;
7278 swig_obj[0] = args;
7279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
7280 if (!SWIG_IsOK(res1)) {
7281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7282 }
7283 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7284 {
7285 delete arg1;
7286
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 resultobj = SWIG_Py_Void();
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7297 PyObject *resultobj = 0;
7298 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7299 wxNativePixelData *arg2 = 0 ;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 void *argp2 = 0 ;
7303 int res2 = 0 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "self",(char *) "data", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativePixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
7311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7314 }
7315 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7316 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7317 if (!SWIG_IsOK(res2)) {
7318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7319 }
7320 if (!argp2) {
7321 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7322 }
7323 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7324 {
7325 (arg1)->Reset((wxNativePixelData const &)*arg2);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_Py_Void();
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7336 PyObject *resultobj = 0;
7337 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7338 bool result;
7339 void *argp1 = 0 ;
7340 int res1 = 0 ;
7341 PyObject *swig_obj[1] ;
7342
7343 if (!args) SWIG_fail;
7344 swig_obj[0] = args;
7345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7346 if (!SWIG_IsOK(res1)) {
7347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor const *""'");
7348 }
7349 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7350 {
7351 result = (bool)((wxNativePixelData_Accessor const *)arg1)->IsOk();
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 {
7355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7364 PyObject *resultobj = 0;
7365 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7366 void *argp1 = 0 ;
7367 int res1 = 0 ;
7368 PyObject *swig_obj[1] ;
7369
7370 if (!args) SWIG_fail;
7371 swig_obj[0] = args;
7372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7373 if (!SWIG_IsOK(res1)) {
7374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7375 }
7376 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7377 {
7378 wxNativePixelData_Accessor_nextPixel(arg1);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_Py_Void();
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7391 wxNativePixelData *arg2 = 0 ;
7392 int arg3 ;
7393 int arg4 ;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 void *argp2 = 0 ;
7397 int res2 = 0 ;
7398 int val3 ;
7399 int ecode3 = 0 ;
7400 int val4 ;
7401 int ecode4 = 0 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 PyObject * obj2 = 0 ;
7405 PyObject * obj3 = 0 ;
7406 char * kwnames[] = {
7407 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7408 };
7409
7410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7414 }
7415 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7416 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7417 if (!SWIG_IsOK(res2)) {
7418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7419 }
7420 if (!argp2) {
7421 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7422 }
7423 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7424 ecode3 = SWIG_AsVal_int(obj2, &val3);
7425 if (!SWIG_IsOK(ecode3)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
7427 }
7428 arg3 = static_cast< int >(val3);
7429 ecode4 = SWIG_AsVal_int(obj3, &val4);
7430 if (!SWIG_IsOK(ecode4)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
7432 }
7433 arg4 = static_cast< int >(val4);
7434 {
7435 (arg1)->Offset((wxNativePixelData const &)*arg2,arg3,arg4);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 resultobj = SWIG_Py_Void();
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = 0;
7447 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7448 wxNativePixelData *arg2 = 0 ;
7449 int arg3 ;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 void *argp2 = 0 ;
7453 int res2 = 0 ;
7454 int val3 ;
7455 int ecode3 = 0 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 PyObject * obj2 = 0 ;
7459 char * kwnames[] = {
7460 (char *) "self",(char *) "data",(char *) "x", NULL
7461 };
7462
7463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7467 }
7468 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7470 if (!SWIG_IsOK(res2)) {
7471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7472 }
7473 if (!argp2) {
7474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7475 }
7476 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 {
7483 (arg1)->OffsetX((wxNativePixelData const &)*arg2,arg3);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = SWIG_Py_Void();
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7496 wxNativePixelData *arg2 = 0 ;
7497 int arg3 ;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 void *argp2 = 0 ;
7501 int res2 = 0 ;
7502 int val3 ;
7503 int ecode3 = 0 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 PyObject * obj2 = 0 ;
7507 char * kwnames[] = {
7508 (char *) "self",(char *) "data",(char *) "y", NULL
7509 };
7510
7511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7515 }
7516 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7518 if (!SWIG_IsOK(res2)) {
7519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7520 }
7521 if (!argp2) {
7522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7523 }
7524 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7525 ecode3 = SWIG_AsVal_int(obj2, &val3);
7526 if (!SWIG_IsOK(ecode3)) {
7527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
7528 }
7529 arg3 = static_cast< int >(val3);
7530 {
7531 (arg1)->OffsetY((wxNativePixelData const &)*arg2,arg3);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj = 0;
7543 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7544 wxNativePixelData *arg2 = 0 ;
7545 int arg3 ;
7546 int arg4 ;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 void *argp2 = 0 ;
7550 int res2 = 0 ;
7551 int val3 ;
7552 int ecode3 = 0 ;
7553 int val4 ;
7554 int ecode4 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 PyObject * obj2 = 0 ;
7558 PyObject * obj3 = 0 ;
7559 char * kwnames[] = {
7560 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7561 };
7562
7563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7567 }
7568 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7569 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7570 if (!SWIG_IsOK(res2)) {
7571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7572 }
7573 if (!argp2) {
7574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7575 }
7576 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7577 ecode3 = SWIG_AsVal_int(obj2, &val3);
7578 if (!SWIG_IsOK(ecode3)) {
7579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
7580 }
7581 arg3 = static_cast< int >(val3);
7582 ecode4 = SWIG_AsVal_int(obj3, &val4);
7583 if (!SWIG_IsOK(ecode4)) {
7584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
7585 }
7586 arg4 = static_cast< int >(val4);
7587 {
7588 (arg1)->MoveTo((wxNativePixelData const &)*arg2,arg3,arg4);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 resultobj = SWIG_Py_Void();
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj = 0;
7600 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7601 byte arg2 ;
7602 byte arg3 ;
7603 byte arg4 ;
7604 void *argp1 = 0 ;
7605 int res1 = 0 ;
7606 unsigned char val2 ;
7607 int ecode2 = 0 ;
7608 unsigned char val3 ;
7609 int ecode3 = 0 ;
7610 unsigned char val4 ;
7611 int ecode4 = 0 ;
7612 PyObject * obj0 = 0 ;
7613 PyObject * obj1 = 0 ;
7614 PyObject * obj2 = 0 ;
7615 PyObject * obj3 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7624 }
7625 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7626 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
7627 if (!SWIG_IsOK(ecode2)) {
7628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
7629 }
7630 arg2 = static_cast< byte >(val2);
7631 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7632 if (!SWIG_IsOK(ecode3)) {
7633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
7634 }
7635 arg3 = static_cast< byte >(val3);
7636 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
7637 if (!SWIG_IsOK(ecode4)) {
7638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
7639 }
7640 arg4 = static_cast< byte >(val4);
7641 {
7642 wxNativePixelData_Accessor_Set(arg1,arg2,arg3,arg4);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 resultobj = SWIG_Py_Void();
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7655 PyObject *result = 0 ;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject *swig_obj[1] ;
7659
7660 if (!args) SWIG_fail;
7661 swig_obj[0] = args;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7665 }
7666 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7667 {
7668 result = (PyObject *)wxNativePixelData_Accessor_Get(arg1);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 resultobj = result;
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 SWIGINTERN PyObject *NativePixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7679 PyObject *obj;
7680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7681 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_NewClientData(obj));
7682 return SWIG_Py_Void();
7683 }
7684
7685 SWIGINTERN PyObject *NativePixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 return SWIG_Python_InitShadowInstance(args);
7687 }
7688
7689 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7690 PyObject *resultobj = 0;
7691 wxBitmap *arg1 = 0 ;
7692 wxAlphaPixelData *result = 0 ;
7693 void *argp1 = 0 ;
7694 int res1 = 0 ;
7695
7696 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7698 if (!SWIG_IsOK(res1)) {
7699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7700 }
7701 if (!argp1) {
7702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7703 }
7704 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7705 {
7706 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7717 PyObject *resultobj = 0;
7718 wxBitmap *arg1 = 0 ;
7719 wxRect *arg2 = 0 ;
7720 wxAlphaPixelData *result = 0 ;
7721 void *argp1 = 0 ;
7722 int res1 = 0 ;
7723 wxRect temp2 ;
7724
7725 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7727 if (!SWIG_IsOK(res1)) {
7728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7729 }
7730 if (!argp1) {
7731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7732 }
7733 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7734 {
7735 arg2 = &temp2;
7736 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
7737 }
7738 {
7739 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxRect const &)*arg2);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7750 PyObject *resultobj = 0;
7751 wxBitmap *arg1 = 0 ;
7752 wxPoint *arg2 = 0 ;
7753 wxSize *arg3 = 0 ;
7754 wxAlphaPixelData *result = 0 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 wxPoint temp2 ;
7758 wxSize temp3 ;
7759
7760 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7764 }
7765 if (!argp1) {
7766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7767 }
7768 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7769 {
7770 arg2 = &temp2;
7771 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7772 }
7773 {
7774 arg3 = &temp3;
7775 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7776 }
7777 {
7778 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_new_AlphaPixelData(PyObject *self, PyObject *args) {
7789 int argc;
7790 PyObject *argv[4];
7791
7792 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData",0,3,argv))) SWIG_fail;
7793 --argc;
7794 if (argc == 1) {
7795 return _wrap_new_AlphaPixelData__SWIG_0(self, argc, argv);
7796 }
7797 if (argc == 2) {
7798 return _wrap_new_AlphaPixelData__SWIG_1(self, argc, argv);
7799 }
7800 if (argc == 3) {
7801 return _wrap_new_AlphaPixelData__SWIG_2(self, argc, argv);
7802 }
7803
7804 fail:
7805 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData'");
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7811 PyObject *resultobj = 0;
7812 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7813 void *argp1 = 0 ;
7814 int res1 = 0 ;
7815 PyObject *swig_obj[1] ;
7816
7817 if (!args) SWIG_fail;
7818 swig_obj[0] = args;
7819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_DISOWN | 0 );
7820 if (!SWIG_IsOK(res1)) {
7821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7822 }
7823 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7824 {
7825 delete arg1;
7826
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 resultobj = SWIG_Py_Void();
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 SWIGINTERN PyObject *_wrap_AlphaPixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7837 PyObject *resultobj = 0;
7838 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7839 wxAlphaPixelData_Accessor result;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 PyObject *swig_obj[1] ;
7843
7844 if (!args) SWIG_fail;
7845 swig_obj[0] = args;
7846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7847 if (!SWIG_IsOK(res1)) {
7848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_GetPixels" "', expected argument " "1"" of type '" "wxAlphaPixelData const *""'");
7849 }
7850 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7851 {
7852 result = ((wxAlphaPixelData const *)arg1)->GetPixels();
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_NewPointerObj((new wxAlphaPixelData_Accessor(static_cast< const wxAlphaPixelData_Accessor& >(result))), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_OWN | 0 );
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_AlphaPixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7863 PyObject *resultobj = 0;
7864 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7865 void *argp1 = 0 ;
7866 int res1 = 0 ;
7867 PyObject *swig_obj[1] ;
7868
7869 if (!args) SWIG_fail;
7870 swig_obj[0] = args;
7871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_UseAlpha" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7874 }
7875 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7876 {
7877 (arg1)->UseAlpha();
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_Py_Void();
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_AlphaPixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7888 PyObject *resultobj = 0;
7889 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
7890 bool result;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 PyObject *swig_obj[1] ;
7894
7895 if (!args) SWIG_fail;
7896 swig_obj[0] = args;
7897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData___nonzero__" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
7900 }
7901 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7902 {
7903 result = (bool)wxAlphaPixelData___nonzero__(arg1);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7908 }
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *AlphaPixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *obj;
7917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7918 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData, SWIG_NewClientData(obj));
7919 return SWIG_Py_Void();
7920 }
7921
7922 SWIGINTERN PyObject *AlphaPixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923 return SWIG_Python_InitShadowInstance(args);
7924 }
7925
7926 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7927 PyObject *resultobj = 0;
7928 wxAlphaPixelData *arg1 = 0 ;
7929 wxAlphaPixelData_Accessor *result = 0 ;
7930 void *argp1 = 0 ;
7931 int res1 = 0 ;
7932
7933 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxAlphaPixelData, 0 );
7935 if (!SWIG_IsOK(res1)) {
7936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
7937 }
7938 if (!argp1) {
7939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
7940 }
7941 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
7942 {
7943 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7954 PyObject *resultobj = 0;
7955 wxBitmap *arg1 = 0 ;
7956 wxAlphaPixelData *arg2 = 0 ;
7957 wxAlphaPixelData_Accessor *result = 0 ;
7958 void *argp1 = 0 ;
7959 int res1 = 0 ;
7960 void *argp2 = 0 ;
7961 int res2 = 0 ;
7962
7963 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7967 }
7968 if (!argp1) {
7969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7970 }
7971 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7972 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 );
7973 if (!SWIG_IsOK(res2)) {
7974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
7975 }
7976 if (!argp2) {
7977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
7978 }
7979 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
7980 {
7981 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1,*arg2);
7982 if (PyErr_Occurred()) SWIG_fail;
7983 }
7984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
7985 return resultobj;
7986 fail:
7987 return NULL;
7988 }
7989
7990
7991 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
7992 PyObject *resultobj = 0;
7993 wxAlphaPixelData_Accessor *result = 0 ;
7994
7995 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
7996 {
7997 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor();
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor(PyObject *self, PyObject *args) {
8008 int argc;
8009 PyObject *argv[3];
8010
8011 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData_Accessor",0,2,argv))) SWIG_fail;
8012 --argc;
8013 if (argc == 0) {
8014 return _wrap_new_AlphaPixelData_Accessor__SWIG_2(self, argc, argv);
8015 }
8016 if (argc == 1) {
8017 return _wrap_new_AlphaPixelData_Accessor__SWIG_0(self, argc, argv);
8018 }
8019 if (argc == 2) {
8020 return _wrap_new_AlphaPixelData_Accessor__SWIG_1(self, argc, argv);
8021 }
8022
8023 fail:
8024 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData_Accessor'");
8025 return NULL;
8026 }
8027
8028
8029 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 PyObject *resultobj = 0;
8031 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8032 void *argp1 = 0 ;
8033 int res1 = 0 ;
8034 PyObject *swig_obj[1] ;
8035
8036 if (!args) SWIG_fail;
8037 swig_obj[0] = args;
8038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
8039 if (!SWIG_IsOK(res1)) {
8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8041 }
8042 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8043 {
8044 delete arg1;
8045
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8056 PyObject *resultobj = 0;
8057 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8058 wxAlphaPixelData *arg2 = 0 ;
8059 void *argp1 = 0 ;
8060 int res1 = 0 ;
8061 void *argp2 = 0 ;
8062 int res2 = 0 ;
8063 PyObject * obj0 = 0 ;
8064 PyObject * obj1 = 0 ;
8065 char * kwnames[] = {
8066 (char *) "self",(char *) "data", NULL
8067 };
8068
8069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AlphaPixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
8070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8071 if (!SWIG_IsOK(res1)) {
8072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8073 }
8074 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8075 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8076 if (!SWIG_IsOK(res2)) {
8077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8078 }
8079 if (!argp2) {
8080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8081 }
8082 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8083 {
8084 (arg1)->Reset((wxAlphaPixelData const &)*arg2);
8085 if (PyErr_Occurred()) SWIG_fail;
8086 }
8087 resultobj = SWIG_Py_Void();
8088 return resultobj;
8089 fail:
8090 return NULL;
8091 }
8092
8093
8094 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8095 PyObject *resultobj = 0;
8096 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8097 bool result;
8098 void *argp1 = 0 ;
8099 int res1 = 0 ;
8100 PyObject *swig_obj[1] ;
8101
8102 if (!args) SWIG_fail;
8103 swig_obj[0] = args;
8104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8105 if (!SWIG_IsOK(res1)) {
8106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor const *""'");
8107 }
8108 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8109 {
8110 result = (bool)((wxAlphaPixelData_Accessor const *)arg1)->IsOk();
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 {
8114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8115 }
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8125 void *argp1 = 0 ;
8126 int res1 = 0 ;
8127 PyObject *swig_obj[1] ;
8128
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8134 }
8135 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8136 {
8137 wxAlphaPixelData_Accessor_nextPixel(arg1);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = 0;
8149 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8150 wxAlphaPixelData *arg2 = 0 ;
8151 int arg3 ;
8152 int arg4 ;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 void *argp2 = 0 ;
8156 int res2 = 0 ;
8157 int val3 ;
8158 int ecode3 = 0 ;
8159 int val4 ;
8160 int ecode4 = 0 ;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 PyObject * obj2 = 0 ;
8164 PyObject * obj3 = 0 ;
8165 char * kwnames[] = {
8166 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8167 };
8168
8169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8171 if (!SWIG_IsOK(res1)) {
8172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8173 }
8174 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8176 if (!SWIG_IsOK(res2)) {
8177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8178 }
8179 if (!argp2) {
8180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8181 }
8182 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8183 ecode3 = SWIG_AsVal_int(obj2, &val3);
8184 if (!SWIG_IsOK(ecode3)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
8186 }
8187 arg3 = static_cast< int >(val3);
8188 ecode4 = SWIG_AsVal_int(obj3, &val4);
8189 if (!SWIG_IsOK(ecode4)) {
8190 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
8191 }
8192 arg4 = static_cast< int >(val4);
8193 {
8194 (arg1)->Offset((wxAlphaPixelData const &)*arg2,arg3,arg4);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 resultobj = SWIG_Py_Void();
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj = 0;
8206 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8207 wxAlphaPixelData *arg2 = 0 ;
8208 int arg3 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 void *argp2 = 0 ;
8212 int res2 = 0 ;
8213 int val3 ;
8214 int ecode3 = 0 ;
8215 PyObject * obj0 = 0 ;
8216 PyObject * obj1 = 0 ;
8217 PyObject * obj2 = 0 ;
8218 char * kwnames[] = {
8219 (char *) "self",(char *) "data",(char *) "x", NULL
8220 };
8221
8222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8224 if (!SWIG_IsOK(res1)) {
8225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8226 }
8227 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8229 if (!SWIG_IsOK(res2)) {
8230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8231 }
8232 if (!argp2) {
8233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8234 }
8235 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8236 ecode3 = SWIG_AsVal_int(obj2, &val3);
8237 if (!SWIG_IsOK(ecode3)) {
8238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
8239 }
8240 arg3 = static_cast< int >(val3);
8241 {
8242 (arg1)->OffsetX((wxAlphaPixelData const &)*arg2,arg3);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 resultobj = SWIG_Py_Void();
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = 0;
8254 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8255 wxAlphaPixelData *arg2 = 0 ;
8256 int arg3 ;
8257 void *argp1 = 0 ;
8258 int res1 = 0 ;
8259 void *argp2 = 0 ;
8260 int res2 = 0 ;
8261 int val3 ;
8262 int ecode3 = 0 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 PyObject * obj2 = 0 ;
8266 char * kwnames[] = {
8267 (char *) "self",(char *) "data",(char *) "y", NULL
8268 };
8269
8270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8272 if (!SWIG_IsOK(res1)) {
8273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8274 }
8275 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8276 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8277 if (!SWIG_IsOK(res2)) {
8278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8279 }
8280 if (!argp2) {
8281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8282 }
8283 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8284 ecode3 = SWIG_AsVal_int(obj2, &val3);
8285 if (!SWIG_IsOK(ecode3)) {
8286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
8287 }
8288 arg3 = static_cast< int >(val3);
8289 {
8290 (arg1)->OffsetY((wxAlphaPixelData const &)*arg2,arg3);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_Py_Void();
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8303 wxAlphaPixelData *arg2 = 0 ;
8304 int arg3 ;
8305 int arg4 ;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 void *argp2 = 0 ;
8309 int res2 = 0 ;
8310 int val3 ;
8311 int ecode3 = 0 ;
8312 int val4 ;
8313 int ecode4 = 0 ;
8314 PyObject * obj0 = 0 ;
8315 PyObject * obj1 = 0 ;
8316 PyObject * obj2 = 0 ;
8317 PyObject * obj3 = 0 ;
8318 char * kwnames[] = {
8319 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8320 };
8321
8322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8324 if (!SWIG_IsOK(res1)) {
8325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8326 }
8327 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8329 if (!SWIG_IsOK(res2)) {
8330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8331 }
8332 if (!argp2) {
8333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8334 }
8335 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8336 ecode3 = SWIG_AsVal_int(obj2, &val3);
8337 if (!SWIG_IsOK(ecode3)) {
8338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
8339 }
8340 arg3 = static_cast< int >(val3);
8341 ecode4 = SWIG_AsVal_int(obj3, &val4);
8342 if (!SWIG_IsOK(ecode4)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
8344 }
8345 arg4 = static_cast< int >(val4);
8346 {
8347 (arg1)->MoveTo((wxAlphaPixelData const &)*arg2,arg3,arg4);
8348 if (PyErr_Occurred()) SWIG_fail;
8349 }
8350 resultobj = SWIG_Py_Void();
8351 return resultobj;
8352 fail:
8353 return NULL;
8354 }
8355
8356
8357 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj = 0;
8359 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8360 byte arg2 ;
8361 byte arg3 ;
8362 byte arg4 ;
8363 byte arg5 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 unsigned char val2 ;
8367 int ecode2 = 0 ;
8368 unsigned char val3 ;
8369 int ecode3 = 0 ;
8370 unsigned char val4 ;
8371 int ecode4 = 0 ;
8372 unsigned char val5 ;
8373 int ecode5 = 0 ;
8374 PyObject * obj0 = 0 ;
8375 PyObject * obj1 = 0 ;
8376 PyObject * obj2 = 0 ;
8377 PyObject * obj3 = 0 ;
8378 PyObject * obj4 = 0 ;
8379 char * kwnames[] = {
8380 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
8381 };
8382
8383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:AlphaPixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8385 if (!SWIG_IsOK(res1)) {
8386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8387 }
8388 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8389 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8390 if (!SWIG_IsOK(ecode2)) {
8391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
8392 }
8393 arg2 = static_cast< byte >(val2);
8394 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
8395 if (!SWIG_IsOK(ecode3)) {
8396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
8397 }
8398 arg3 = static_cast< byte >(val3);
8399 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
8400 if (!SWIG_IsOK(ecode4)) {
8401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
8402 }
8403 arg4 = static_cast< byte >(val4);
8404 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
8405 if (!SWIG_IsOK(ecode5)) {
8406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "5"" of type '" "byte""'");
8407 }
8408 arg5 = static_cast< byte >(val5);
8409 {
8410 wxAlphaPixelData_Accessor_Set(arg1,arg2,arg3,arg4,arg5);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8423 PyObject *result = 0 ;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 PyObject *swig_obj[1] ;
8427
8428 if (!args) SWIG_fail;
8429 swig_obj[0] = args;
8430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8433 }
8434 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8435 {
8436 result = (PyObject *)wxAlphaPixelData_Accessor_Get(arg1);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 resultobj = result;
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 SWIGINTERN PyObject *AlphaPixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8447 PyObject *obj;
8448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8449 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_NewClientData(obj));
8450 return SWIG_Py_Void();
8451 }
8452
8453 SWIGINTERN PyObject *AlphaPixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454 return SWIG_Python_InitShadowInstance(args);
8455 }
8456
8457 SWIGINTERN PyObject *_wrap_new_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxBitmap *arg1 = 0 ;
8460 wxColour const &arg2_defvalue = wxNullColour ;
8461 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
8462 wxMask *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxColour temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "bitmap",(char *) "colour", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8476 }
8477 if (!argp1) {
8478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8479 }
8480 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8481 if (obj1) {
8482 {
8483 arg2 = &temp2;
8484 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8485 }
8486 }
8487 {
8488 if (!wxPyCheckForApp()) SWIG_fail;
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, SWIG_POINTER_NEW | 0 );
8495 return resultobj;
8496 fail:
8497 return NULL;
8498 }
8499
8500
8501 SWIGINTERN PyObject *_wrap_delete_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8502 PyObject *resultobj = 0;
8503 wxMask *arg1 = (wxMask *) 0 ;
8504 void *argp1 = 0 ;
8505 int res1 = 0 ;
8506 PyObject *swig_obj[1] ;
8507
8508 if (!args) SWIG_fail;
8509 swig_obj[0] = args;
8510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
8511 if (!SWIG_IsOK(res1)) {
8512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mask" "', expected argument " "1"" of type '" "wxMask *""'");
8513 }
8514 arg1 = reinterpret_cast< wxMask * >(argp1);
8515 {
8516 delete arg1;
8517
8518 if (PyErr_Occurred()) SWIG_fail;
8519 }
8520 resultobj = SWIG_Py_Void();
8521 return resultobj;
8522 fail:
8523 return NULL;
8524 }
8525
8526
8527 SWIGINTERN PyObject *Mask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8528 PyObject *obj;
8529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8530 SWIG_TypeNewClientData(SWIGTYPE_p_wxMask, SWIG_NewClientData(obj));
8531 return SWIG_Py_Void();
8532 }
8533
8534 SWIGINTERN PyObject *Mask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8535 return SWIG_Python_InitShadowInstance(args);
8536 }
8537
8538 SWIGINTERN PyObject *_wrap_new_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxString *arg1 = 0 ;
8541 wxBitmapType arg2 ;
8542 int arg3 = (int) -1 ;
8543 int arg4 = (int) -1 ;
8544 wxIcon *result = 0 ;
8545 bool temp1 = false ;
8546 int val2 ;
8547 int ecode2 = 0 ;
8548 int val3 ;
8549 int ecode3 = 0 ;
8550 int val4 ;
8551 int ecode4 = 0 ;
8552 PyObject * obj0 = 0 ;
8553 PyObject * obj1 = 0 ;
8554 PyObject * obj2 = 0 ;
8555 PyObject * obj3 = 0 ;
8556 char * kwnames[] = {
8557 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
8558 };
8559
8560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8561 {
8562 arg1 = wxString_in_helper(obj0);
8563 if (arg1 == NULL) SWIG_fail;
8564 temp1 = true;
8565 }
8566 ecode2 = SWIG_AsVal_int(obj1, &val2);
8567 if (!SWIG_IsOK(ecode2)) {
8568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Icon" "', expected argument " "2"" of type '" "wxBitmapType""'");
8569 }
8570 arg2 = static_cast< wxBitmapType >(val2);
8571 if (obj2) {
8572 ecode3 = SWIG_AsVal_int(obj2, &val3);
8573 if (!SWIG_IsOK(ecode3)) {
8574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Icon" "', expected argument " "3"" of type '" "int""'");
8575 }
8576 arg3 = static_cast< int >(val3);
8577 }
8578 if (obj3) {
8579 ecode4 = SWIG_AsVal_int(obj3, &val4);
8580 if (!SWIG_IsOK(ecode4)) {
8581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Icon" "', expected argument " "4"" of type '" "int""'");
8582 }
8583 arg4 = static_cast< int >(val4);
8584 }
8585 {
8586 if (!wxPyCheckForApp()) SWIG_fail;
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 result = (wxIcon *)new wxIcon((wxString const &)*arg1,arg2,arg3,arg4);
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_NEW | 0 );
8593 {
8594 if (temp1)
8595 delete arg1;
8596 }
8597 return resultobj;
8598 fail:
8599 {
8600 if (temp1)
8601 delete arg1;
8602 }
8603 return NULL;
8604 }
8605
8606
8607 SWIGINTERN PyObject *_wrap_delete_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8608 PyObject *resultobj = 0;
8609 wxIcon *arg1 = (wxIcon *) 0 ;
8610 void *argp1 = 0 ;
8611 int res1 = 0 ;
8612 PyObject *swig_obj[1] ;
8613
8614 if (!args) SWIG_fail;
8615 swig_obj[0] = args;
8616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, SWIG_POINTER_DISOWN | 0 );
8617 if (!SWIG_IsOK(res1)) {
8618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Icon" "', expected argument " "1"" of type '" "wxIcon *""'");
8619 }
8620 arg1 = reinterpret_cast< wxIcon * >(argp1);
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 delete arg1;
8624
8625 wxPyEndAllowThreads(__tstate);
8626 if (PyErr_Occurred()) SWIG_fail;
8627 }
8628 resultobj = SWIG_Py_Void();
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_new_EmptyIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8636 PyObject *resultobj = 0;
8637 wxIcon *result = 0 ;
8638
8639 if (!SWIG_Python_UnpackTuple(args,"new_EmptyIcon",0,0,0)) SWIG_fail;
8640 {
8641 if (!wxPyCheckForApp()) SWIG_fail;
8642 PyThreadState* __tstate = wxPyBeginAllowThreads();
8643 result = (wxIcon *)new wxIcon();
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_new_IconFromLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxIconLocation *arg1 = 0 ;
8657 wxIcon *result = 0 ;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 PyObject * obj0 = 0 ;
8661 char * kwnames[] = {
8662 (char *) "loc", NULL
8663 };
8664
8665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) SWIG_fail;
8666 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIconLocation, 0 | 0);
8667 if (!SWIG_IsOK(res1)) {
8668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8669 }
8670 if (!argp1) {
8671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8672 }
8673 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
8674 {
8675 if (!wxPyCheckForApp()) SWIG_fail;
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8682 return resultobj;
8683 fail:
8684 return NULL;
8685 }
8686
8687
8688 SWIGINTERN PyObject *_wrap_new_IconFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8689 PyObject *resultobj = 0;
8690 wxBitmap *arg1 = 0 ;
8691 wxIcon *result = 0 ;
8692 void *argp1 = 0 ;
8693 int res1 = 0 ;
8694 PyObject * obj0 = 0 ;
8695 char * kwnames[] = {
8696 (char *) "bmp", NULL
8697 };
8698
8699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8703 }
8704 if (!argp1) {
8705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8706 }
8707 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8708 {
8709 if (!wxPyCheckForApp()) SWIG_fail;
8710 PyThreadState* __tstate = wxPyBeginAllowThreads();
8711 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
8712 wxPyEndAllowThreads(__tstate);
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_new_IconFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 PyObject *arg1 = (PyObject *) 0 ;
8725 wxIcon *result = 0 ;
8726 PyObject * obj0 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "listOfStrings", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) SWIG_fail;
8732 arg1 = obj0;
8733 {
8734 if (!wxPyCheckForApp()) SWIG_fail;
8735 PyThreadState* __tstate = wxPyBeginAllowThreads();
8736 result = (wxIcon *)new_wxIcon(arg1);
8737 wxPyEndAllowThreads(__tstate);
8738 if (PyErr_Occurred()) SWIG_fail;
8739 }
8740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8741 return resultobj;
8742 fail:
8743 return NULL;
8744 }
8745
8746
8747 SWIGINTERN PyObject *_wrap_Icon_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8748 PyObject *resultobj = 0;
8749 wxIcon *arg1 = (wxIcon *) 0 ;
8750 wxString *arg2 = 0 ;
8751 wxBitmapType arg3 ;
8752 bool result;
8753 void *argp1 = 0 ;
8754 int res1 = 0 ;
8755 bool temp2 = false ;
8756 int val3 ;
8757 int ecode3 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 PyObject * obj2 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "name",(char *) "type", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_LoadFile" "', expected argument " "1"" of type '" "wxIcon *""'");
8769 }
8770 arg1 = reinterpret_cast< wxIcon * >(argp1);
8771 {
8772 arg2 = wxString_in_helper(obj1);
8773 if (arg2 == NULL) SWIG_fail;
8774 temp2 = true;
8775 }
8776 ecode3 = SWIG_AsVal_int(obj2, &val3);
8777 if (!SWIG_IsOK(ecode3)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Icon_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
8779 }
8780 arg3 = static_cast< wxBitmapType >(val3);
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 {
8788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8789 }
8790 {
8791 if (temp2)
8792 delete arg2;
8793 }
8794 return resultobj;
8795 fail:
8796 {
8797 if (temp2)
8798 delete arg2;
8799 }
8800 return NULL;
8801 }
8802
8803
8804 SWIGINTERN PyObject *_wrap_Icon_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8805 PyObject *resultobj = 0;
8806 wxIcon *arg1 = (wxIcon *) 0 ;
8807 bool result;
8808 void *argp1 = 0 ;
8809 int res1 = 0 ;
8810 PyObject *swig_obj[1] ;
8811
8812 if (!args) SWIG_fail;
8813 swig_obj[0] = args;
8814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_Ok" "', expected argument " "1"" of type '" "wxIcon *""'");
8817 }
8818 arg1 = reinterpret_cast< wxIcon * >(argp1);
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 result = (bool)(arg1)->Ok();
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8827 }
8828 return resultobj;
8829 fail:
8830 return NULL;
8831 }
8832
8833
8834 SWIGINTERN PyObject *_wrap_Icon_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8835 PyObject *resultobj = 0;
8836 wxIcon *arg1 = (wxIcon *) 0 ;
8837 int result;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 PyObject *swig_obj[1] ;
8841
8842 if (!args) SWIG_fail;
8843 swig_obj[0] = args;
8844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
8847 }
8848 arg1 = reinterpret_cast< wxIcon * >(argp1);
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 result = (int)(arg1)->GetWidth();
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_From_int(static_cast< int >(result));
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_Icon_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8863 PyObject *resultobj = 0;
8864 wxIcon *arg1 = (wxIcon *) 0 ;
8865 int result;
8866 void *argp1 = 0 ;
8867 int res1 = 0 ;
8868 PyObject *swig_obj[1] ;
8869
8870 if (!args) SWIG_fail;
8871 swig_obj[0] = args;
8872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8873 if (!SWIG_IsOK(res1)) {
8874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
8875 }
8876 arg1 = reinterpret_cast< wxIcon * >(argp1);
8877 {
8878 PyThreadState* __tstate = wxPyBeginAllowThreads();
8879 result = (int)(arg1)->GetHeight();
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_From_int(static_cast< int >(result));
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Icon_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891 PyObject *resultobj = 0;
8892 wxIcon *arg1 = (wxIcon *) 0 ;
8893 int result;
8894 void *argp1 = 0 ;
8895 int res1 = 0 ;
8896 PyObject *swig_obj[1] ;
8897
8898 if (!args) SWIG_fail;
8899 swig_obj[0] = args;
8900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8901 if (!SWIG_IsOK(res1)) {
8902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
8903 }
8904 arg1 = reinterpret_cast< wxIcon * >(argp1);
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (int)(arg1)->GetDepth();
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 resultobj = SWIG_From_int(static_cast< int >(result));
8912 return resultobj;
8913 fail:
8914 return NULL;
8915 }
8916
8917
8918 SWIGINTERN PyObject *_wrap_Icon_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj = 0;
8920 wxIcon *arg1 = (wxIcon *) 0 ;
8921 int arg2 ;
8922 void *argp1 = 0 ;
8923 int res1 = 0 ;
8924 int val2 ;
8925 int ecode2 = 0 ;
8926 PyObject * obj0 = 0 ;
8927 PyObject * obj1 = 0 ;
8928 char * kwnames[] = {
8929 (char *) "self",(char *) "w", NULL
8930 };
8931
8932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
8933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8934 if (!SWIG_IsOK(res1)) {
8935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
8936 }
8937 arg1 = reinterpret_cast< wxIcon * >(argp1);
8938 ecode2 = SWIG_AsVal_int(obj1, &val2);
8939 if (!SWIG_IsOK(ecode2)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetWidth" "', expected argument " "2"" of type '" "int""'");
8941 }
8942 arg2 = static_cast< int >(val2);
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->SetWidth(arg2);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Icon_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj = 0;
8958 wxIcon *arg1 = (wxIcon *) 0 ;
8959 int arg2 ;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 int val2 ;
8963 int ecode2 = 0 ;
8964 PyObject * obj0 = 0 ;
8965 PyObject * obj1 = 0 ;
8966 char * kwnames[] = {
8967 (char *) "self",(char *) "h", NULL
8968 };
8969
8970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
8971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8972 if (!SWIG_IsOK(res1)) {
8973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
8974 }
8975 arg1 = reinterpret_cast< wxIcon * >(argp1);
8976 ecode2 = SWIG_AsVal_int(obj1, &val2);
8977 if (!SWIG_IsOK(ecode2)) {
8978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHeight" "', expected argument " "2"" of type '" "int""'");
8979 }
8980 arg2 = static_cast< int >(val2);
8981 {
8982 PyThreadState* __tstate = wxPyBeginAllowThreads();
8983 (arg1)->SetHeight(arg2);
8984 wxPyEndAllowThreads(__tstate);
8985 if (PyErr_Occurred()) SWIG_fail;
8986 }
8987 resultobj = SWIG_Py_Void();
8988 return resultobj;
8989 fail:
8990 return NULL;
8991 }
8992
8993
8994 SWIGINTERN PyObject *_wrap_Icon_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8995 PyObject *resultobj = 0;
8996 wxIcon *arg1 = (wxIcon *) 0 ;
8997 int arg2 ;
8998 void *argp1 = 0 ;
8999 int res1 = 0 ;
9000 int val2 ;
9001 int ecode2 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 PyObject * obj1 = 0 ;
9004 char * kwnames[] = {
9005 (char *) "self",(char *) "d", NULL
9006 };
9007
9008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
9009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9010 if (!SWIG_IsOK(res1)) {
9011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
9012 }
9013 arg1 = reinterpret_cast< wxIcon * >(argp1);
9014 ecode2 = SWIG_AsVal_int(obj1, &val2);
9015 if (!SWIG_IsOK(ecode2)) {
9016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetDepth" "', expected argument " "2"" of type '" "int""'");
9017 }
9018 arg2 = static_cast< int >(val2);
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 (arg1)->SetDepth(arg2);
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 resultobj = SWIG_Py_Void();
9026 return resultobj;
9027 fail:
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_Icon_CopyFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9033 PyObject *resultobj = 0;
9034 wxIcon *arg1 = (wxIcon *) 0 ;
9035 wxBitmap *arg2 = 0 ;
9036 void *argp1 = 0 ;
9037 int res1 = 0 ;
9038 void *argp2 = 0 ;
9039 int res2 = 0 ;
9040 PyObject * obj0 = 0 ;
9041 PyObject * obj1 = 0 ;
9042 char * kwnames[] = {
9043 (char *) "self",(char *) "bmp", NULL
9044 };
9045
9046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
9047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_CopyFromBitmap" "', expected argument " "1"" of type '" "wxIcon *""'");
9050 }
9051 arg1 = reinterpret_cast< wxIcon * >(argp1);
9052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
9053 if (!SWIG_IsOK(res2)) {
9054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9055 }
9056 if (!argp2) {
9057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9058 }
9059 arg2 = reinterpret_cast< wxBitmap * >(argp2);
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 resultobj = SWIG_Py_Void();
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 SWIGINTERN PyObject *Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9074 PyObject *obj;
9075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9076 SWIG_TypeNewClientData(SWIGTYPE_p_wxIcon, SWIG_NewClientData(obj));
9077 return SWIG_Py_Void();
9078 }
9079
9080 SWIGINTERN PyObject *Icon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9081 return SWIG_Python_InitShadowInstance(args);
9082 }
9083
9084 SWIGINTERN PyObject *_wrap_new_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj = 0;
9086 wxString *arg1 = (wxString *) &wxPyEmptyString ;
9087 int arg2 = (int) 0 ;
9088 wxIconLocation *result = 0 ;
9089 bool temp1 = false ;
9090 int val2 ;
9091 int ecode2 = 0 ;
9092 PyObject * obj0 = 0 ;
9093 PyObject * obj1 = 0 ;
9094 char * kwnames[] = {
9095 (char *) "filename",(char *) "num", NULL
9096 };
9097
9098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) SWIG_fail;
9099 if (obj0) {
9100 {
9101 arg1 = wxString_in_helper(obj0);
9102 if (arg1 == NULL) SWIG_fail;
9103 temp1 = true;
9104 }
9105 }
9106 if (obj1) {
9107 ecode2 = SWIG_AsVal_int(obj1, &val2);
9108 if (!SWIG_IsOK(ecode2)) {
9109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconLocation" "', expected argument " "2"" of type '" "int""'");
9110 }
9111 arg2 = static_cast< int >(val2);
9112 }
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconLocation, SWIG_POINTER_NEW | 0 );
9120 {
9121 if (temp1)
9122 delete arg1;
9123 }
9124 return resultobj;
9125 fail:
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return NULL;
9131 }
9132
9133
9134 SWIGINTERN PyObject *_wrap_delete_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9135 PyObject *resultobj = 0;
9136 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9137 void *argp1 = 0 ;
9138 int res1 = 0 ;
9139 PyObject *swig_obj[1] ;
9140
9141 if (!args) SWIG_fail;
9142 swig_obj[0] = args;
9143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, SWIG_POINTER_DISOWN | 0 );
9144 if (!SWIG_IsOK(res1)) {
9145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconLocation" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9146 }
9147 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 delete arg1;
9151
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 resultobj = SWIG_Py_Void();
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 SWIGINTERN PyObject *_wrap_IconLocation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9163 PyObject *resultobj = 0;
9164 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9165 bool result;
9166 void *argp1 = 0 ;
9167 int res1 = 0 ;
9168 PyObject *swig_obj[1] ;
9169
9170 if (!args) SWIG_fail;
9171 swig_obj[0] = args;
9172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9173 if (!SWIG_IsOK(res1)) {
9174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_IsOk" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9175 }
9176 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9177 {
9178 PyThreadState* __tstate = wxPyBeginAllowThreads();
9179 result = (bool)((wxIconLocation const *)arg1)->IsOk();
9180 wxPyEndAllowThreads(__tstate);
9181 if (PyErr_Occurred()) SWIG_fail;
9182 }
9183 {
9184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9185 }
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 SWIGINTERN PyObject *_wrap_IconLocation_SetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj = 0;
9194 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9195 wxString *arg2 = 0 ;
9196 void *argp1 = 0 ;
9197 int res1 = 0 ;
9198 bool temp2 = false ;
9199 PyObject * obj0 = 0 ;
9200 PyObject * obj1 = 0 ;
9201 char * kwnames[] = {
9202 (char *) "self",(char *) "filename", NULL
9203 };
9204
9205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) SWIG_fail;
9206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9207 if (!SWIG_IsOK(res1)) {
9208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetFileName" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9209 }
9210 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9211 {
9212 arg2 = wxString_in_helper(obj1);
9213 if (arg2 == NULL) SWIG_fail;
9214 temp2 = true;
9215 }
9216 {
9217 PyThreadState* __tstate = wxPyBeginAllowThreads();
9218 (arg1)->SetFileName((wxString const &)*arg2);
9219 wxPyEndAllowThreads(__tstate);
9220 if (PyErr_Occurred()) SWIG_fail;
9221 }
9222 resultobj = SWIG_Py_Void();
9223 {
9224 if (temp2)
9225 delete arg2;
9226 }
9227 return resultobj;
9228 fail:
9229 {
9230 if (temp2)
9231 delete arg2;
9232 }
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *_wrap_IconLocation_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9240 wxString *result = 0 ;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetFileName" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9250 }
9251 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9252 {
9253 PyThreadState* __tstate = wxPyBeginAllowThreads();
9254 {
9255 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
9256 result = (wxString *) &_result_ref;
9257 }
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 {
9262 #if wxUSE_UNICODE
9263 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9264 #else
9265 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9266 #endif
9267 }
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_IconLocation_SetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj = 0;
9276 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9277 int arg2 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 int val2 ;
9281 int ecode2 = 0 ;
9282 PyObject * obj0 = 0 ;
9283 PyObject * obj1 = 0 ;
9284 char * kwnames[] = {
9285 (char *) "self",(char *) "num", NULL
9286 };
9287
9288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) SWIG_fail;
9289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9290 if (!SWIG_IsOK(res1)) {
9291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9292 }
9293 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9294 ecode2 = SWIG_AsVal_int(obj1, &val2);
9295 if (!SWIG_IsOK(ecode2)) {
9296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IconLocation_SetIndex" "', expected argument " "2"" of type '" "int""'");
9297 }
9298 arg2 = static_cast< int >(val2);
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 wxIconLocation_SetIndex(arg1,arg2);
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_IconLocation_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9315 int result;
9316 void *argp1 = 0 ;
9317 int res1 = 0 ;
9318 PyObject *swig_obj[1] ;
9319
9320 if (!args) SWIG_fail;
9321 swig_obj[0] = args;
9322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9323 if (!SWIG_IsOK(res1)) {
9324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9325 }
9326 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9327 {
9328 PyThreadState* __tstate = wxPyBeginAllowThreads();
9329 result = (int)wxIconLocation_GetIndex(arg1);
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 resultobj = SWIG_From_int(static_cast< int >(result));
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 SWIGINTERN PyObject *IconLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9341 PyObject *obj;
9342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9343 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconLocation, SWIG_NewClientData(obj));
9344 return SWIG_Py_Void();
9345 }
9346
9347 SWIGINTERN PyObject *IconLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9348 return SWIG_Python_InitShadowInstance(args);
9349 }
9350
9351 SWIGINTERN PyObject *_wrap_new_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352 PyObject *resultobj = 0;
9353 wxIconBundle *result = 0 ;
9354
9355 if (!SWIG_Python_UnpackTuple(args,"new_IconBundle",0,0,0)) SWIG_fail;
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (wxIconBundle *)new wxIconBundle();
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_NEW | 0 );
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_new_IconBundleFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = 0;
9371 wxString *arg1 = 0 ;
9372 long arg2 ;
9373 wxIconBundle *result = 0 ;
9374 bool temp1 = false ;
9375 long val2 ;
9376 int ecode2 = 0 ;
9377 PyObject * obj0 = 0 ;
9378 PyObject * obj1 = 0 ;
9379 char * kwnames[] = {
9380 (char *) "file",(char *) "type", NULL
9381 };
9382
9383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) SWIG_fail;
9384 {
9385 arg1 = wxString_in_helper(obj0);
9386 if (arg1 == NULL) SWIG_fail;
9387 temp1 = true;
9388 }
9389 ecode2 = SWIG_AsVal_long(obj1, &val2);
9390 if (!SWIG_IsOK(ecode2)) {
9391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconBundleFromFile" "', expected argument " "2"" of type '" "long""'");
9392 }
9393 arg2 = static_cast< long >(val2);
9394 {
9395 PyThreadState* __tstate = wxPyBeginAllowThreads();
9396 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9401 {
9402 if (temp1)
9403 delete arg1;
9404 }
9405 return resultobj;
9406 fail:
9407 {
9408 if (temp1)
9409 delete arg1;
9410 }
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_new_IconBundleFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj = 0;
9417 wxIcon *arg1 = 0 ;
9418 wxIconBundle *result = 0 ;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject * obj0 = 0 ;
9422 char * kwnames[] = {
9423 (char *) "icon", NULL
9424 };
9425
9426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) SWIG_fail;
9427 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9430 }
9431 if (!argp1) {
9432 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9433 }
9434 arg1 = reinterpret_cast< wxIcon * >(argp1);
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 SWIGINTERN PyObject *_wrap_delete_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9449 PyObject *resultobj = 0;
9450 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 PyObject *swig_obj[1] ;
9454
9455 if (!args) SWIG_fail;
9456 swig_obj[0] = args;
9457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconBundle, SWIG_POINTER_DISOWN | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconBundle" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9460 }
9461 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 delete arg1;
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 resultobj = SWIG_Py_Void();
9470 return resultobj;
9471 fail:
9472 return NULL;
9473 }
9474
9475
9476 SWIGINTERN PyObject *_wrap_IconBundle_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9477 PyObject *resultobj = 0;
9478 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9479 wxIcon *arg2 = 0 ;
9480 void *argp1 = 0 ;
9481 int res1 = 0 ;
9482 void *argp2 = 0 ;
9483 int res2 = 0 ;
9484 PyObject * obj0 = 0 ;
9485 PyObject * obj1 = 0 ;
9486 char * kwnames[] = {
9487 (char *) "self",(char *) "icon", NULL
9488 };
9489
9490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIcon" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9494 }
9495 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
9497 if (!SWIG_IsOK(res2)) {
9498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9499 }
9500 if (!argp2) {
9501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9502 }
9503 arg2 = reinterpret_cast< wxIcon * >(argp2);
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 (arg1)->AddIcon((wxIcon const &)*arg2);
9507 wxPyEndAllowThreads(__tstate);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9520 wxString *arg2 = 0 ;
9521 long arg3 ;
9522 void *argp1 = 0 ;
9523 int res1 = 0 ;
9524 bool temp2 = false ;
9525 long val3 ;
9526 int ecode3 = 0 ;
9527 PyObject * obj0 = 0 ;
9528 PyObject * obj1 = 0 ;
9529 PyObject * obj2 = 0 ;
9530 char * kwnames[] = {
9531 (char *) "self",(char *) "file",(char *) "type", NULL
9532 };
9533
9534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9536 if (!SWIG_IsOK(res1)) {
9537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9538 }
9539 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9540 {
9541 arg2 = wxString_in_helper(obj1);
9542 if (arg2 == NULL) SWIG_fail;
9543 temp2 = true;
9544 }
9545 ecode3 = SWIG_AsVal_long(obj2, &val3);
9546 if (!SWIG_IsOK(ecode3)) {
9547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "3"" of type '" "long""'");
9548 }
9549 arg3 = static_cast< long >(val3);
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 (arg1)->AddIcon((wxString const &)*arg2,arg3);
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 resultobj = SWIG_Py_Void();
9557 {
9558 if (temp2)
9559 delete arg2;
9560 }
9561 return resultobj;
9562 fail:
9563 {
9564 if (temp2)
9565 delete arg2;
9566 }
9567 return NULL;
9568 }
9569
9570
9571 SWIGINTERN PyObject *_wrap_IconBundle_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9572 PyObject *resultobj = 0;
9573 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9574 wxSize *arg2 = 0 ;
9575 wxIcon *result = 0 ;
9576 void *argp1 = 0 ;
9577 int res1 = 0 ;
9578 wxSize temp2 ;
9579 PyObject * obj0 = 0 ;
9580 PyObject * obj1 = 0 ;
9581 char * kwnames[] = {
9582 (char *) "self",(char *) "size", NULL
9583 };
9584
9585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9587 if (!SWIG_IsOK(res1)) {
9588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_GetIcon" "', expected argument " "1"" of type '" "wxIconBundle const *""'");
9589 }
9590 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9591 {
9592 arg2 = &temp2;
9593 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9594 }
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 {
9598 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
9599 result = (wxIcon *) &_result_ref;
9600 }
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 {
9605 wxIcon* resultptr = new wxIcon(*result);
9606 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
9607 }
9608 return resultobj;
9609 fail:
9610 return NULL;
9611 }
9612
9613
9614 SWIGINTERN PyObject *IconBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9615 PyObject *obj;
9616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9617 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconBundle, SWIG_NewClientData(obj));
9618 return SWIG_Py_Void();
9619 }
9620
9621 SWIGINTERN PyObject *IconBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9622 return SWIG_Python_InitShadowInstance(args);
9623 }
9624
9625 SWIGINTERN PyObject *_wrap_new_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxString *arg1 = 0 ;
9628 long arg2 ;
9629 int arg3 = (int) 0 ;
9630 int arg4 = (int) 0 ;
9631 wxCursor *result = 0 ;
9632 bool temp1 = false ;
9633 long val2 ;
9634 int ecode2 = 0 ;
9635 int val3 ;
9636 int ecode3 = 0 ;
9637 int val4 ;
9638 int ecode4 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 PyObject * obj2 = 0 ;
9642 PyObject * obj3 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9648 {
9649 arg1 = wxString_in_helper(obj0);
9650 if (arg1 == NULL) SWIG_fail;
9651 temp1 = true;
9652 }
9653 ecode2 = SWIG_AsVal_long(obj1, &val2);
9654 if (!SWIG_IsOK(ecode2)) {
9655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cursor" "', expected argument " "2"" of type '" "long""'");
9656 }
9657 arg2 = static_cast< long >(val2);
9658 if (obj2) {
9659 ecode3 = SWIG_AsVal_int(obj2, &val3);
9660 if (!SWIG_IsOK(ecode3)) {
9661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cursor" "', expected argument " "3"" of type '" "int""'");
9662 }
9663 arg3 = static_cast< int >(val3);
9664 }
9665 if (obj3) {
9666 ecode4 = SWIG_AsVal_int(obj3, &val4);
9667 if (!SWIG_IsOK(ecode4)) {
9668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cursor" "', expected argument " "4"" of type '" "int""'");
9669 }
9670 arg4 = static_cast< int >(val4);
9671 }
9672 {
9673 if (!wxPyCheckForApp()) SWIG_fail;
9674 PyThreadState* __tstate = wxPyBeginAllowThreads();
9675 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_NEW | 0 );
9680 {
9681 if (temp1)
9682 delete arg1;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *_wrap_delete_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *resultobj = 0;
9696 wxCursor *arg1 = (wxCursor *) 0 ;
9697 void *argp1 = 0 ;
9698 int res1 = 0 ;
9699 PyObject *swig_obj[1] ;
9700
9701 if (!args) SWIG_fail;
9702 swig_obj[0] = args;
9703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, SWIG_POINTER_DISOWN | 0 );
9704 if (!SWIG_IsOK(res1)) {
9705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9706 }
9707 arg1 = reinterpret_cast< wxCursor * >(argp1);
9708 {
9709 PyThreadState* __tstate = wxPyBeginAllowThreads();
9710 delete arg1;
9711
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 resultobj = SWIG_Py_Void();
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 SWIGINTERN PyObject *_wrap_new_StockCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj = 0;
9724 int arg1 ;
9725 wxCursor *result = 0 ;
9726 int val1 ;
9727 int ecode1 = 0 ;
9728 PyObject * obj0 = 0 ;
9729 char * kwnames[] = {
9730 (char *) "id", NULL
9731 };
9732
9733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) SWIG_fail;
9734 ecode1 = SWIG_AsVal_int(obj0, &val1);
9735 if (!SWIG_IsOK(ecode1)) {
9736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StockCursor" "', expected argument " "1"" of type '" "int""'");
9737 }
9738 arg1 = static_cast< int >(val1);
9739 {
9740 if (!wxPyCheckForApp()) SWIG_fail;
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 result = (wxCursor *)new wxCursor(arg1);
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 SWIGINTERN PyObject *_wrap_new_CursorFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9754 PyObject *resultobj = 0;
9755 wxImage *arg1 = 0 ;
9756 wxCursor *result = 0 ;
9757 void *argp1 = 0 ;
9758 int res1 = 0 ;
9759 PyObject * obj0 = 0 ;
9760 char * kwnames[] = {
9761 (char *) "image", NULL
9762 };
9763
9764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) SWIG_fail;
9765 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
9768 }
9769 if (!argp1) {
9770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
9771 }
9772 arg1 = reinterpret_cast< wxImage * >(argp1);
9773 {
9774 if (!wxPyCheckForApp()) SWIG_fail;
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
9777 wxPyEndAllowThreads(__tstate);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Cursor_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxCursor *arg1 = (wxCursor *) 0 ;
9790 bool result;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 PyObject *swig_obj[1] ;
9794
9795 if (!args) SWIG_fail;
9796 swig_obj[0] = args;
9797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9798 if (!SWIG_IsOK(res1)) {
9799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_Ok" "', expected argument " "1"" of type '" "wxCursor *""'");
9800 }
9801 arg1 = reinterpret_cast< wxCursor * >(argp1);
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 result = (bool)(arg1)->Ok();
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *Cursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *obj;
9819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9820 SWIG_TypeNewClientData(SWIGTYPE_p_wxCursor, SWIG_NewClientData(obj));
9821 return SWIG_Py_Void();
9822 }
9823
9824 SWIGINTERN PyObject *Cursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9825 return SWIG_Python_InitShadowInstance(args);
9826 }
9827
9828 SWIGINTERN PyObject *_wrap_new_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj = 0;
9830 int arg1 = (int) 0 ;
9831 int arg2 = (int) 0 ;
9832 int arg3 = (int) 0 ;
9833 int arg4 = (int) 0 ;
9834 wxRegion *result = 0 ;
9835 int val1 ;
9836 int ecode1 = 0 ;
9837 int val2 ;
9838 int ecode2 = 0 ;
9839 int val3 ;
9840 int ecode3 = 0 ;
9841 int val4 ;
9842 int ecode4 = 0 ;
9843 PyObject * obj0 = 0 ;
9844 PyObject * obj1 = 0 ;
9845 PyObject * obj2 = 0 ;
9846 PyObject * obj3 = 0 ;
9847 char * kwnames[] = {
9848 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
9849 };
9850
9851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9852 if (obj0) {
9853 ecode1 = SWIG_AsVal_int(obj0, &val1);
9854 if (!SWIG_IsOK(ecode1)) {
9855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Region" "', expected argument " "1"" of type '" "int""'");
9856 }
9857 arg1 = static_cast< int >(val1);
9858 }
9859 if (obj1) {
9860 ecode2 = SWIG_AsVal_int(obj1, &val2);
9861 if (!SWIG_IsOK(ecode2)) {
9862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Region" "', expected argument " "2"" of type '" "int""'");
9863 }
9864 arg2 = static_cast< int >(val2);
9865 }
9866 if (obj2) {
9867 ecode3 = SWIG_AsVal_int(obj2, &val3);
9868 if (!SWIG_IsOK(ecode3)) {
9869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Region" "', expected argument " "3"" of type '" "int""'");
9870 }
9871 arg3 = static_cast< int >(val3);
9872 }
9873 if (obj3) {
9874 ecode4 = SWIG_AsVal_int(obj3, &val4);
9875 if (!SWIG_IsOK(ecode4)) {
9876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Region" "', expected argument " "4"" of type '" "int""'");
9877 }
9878 arg4 = static_cast< int >(val4);
9879 }
9880 {
9881 if (!wxPyCheckForApp()) SWIG_fail;
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_NEW | 0 );
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *_wrap_new_RegionFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = 0;
9896 wxBitmap *arg1 = 0 ;
9897 wxRegion *result = 0 ;
9898 void *argp1 = 0 ;
9899 int res1 = 0 ;
9900 PyObject * obj0 = 0 ;
9901 char * kwnames[] = {
9902 (char *) "bmp", NULL
9903 };
9904
9905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) SWIG_fail;
9906 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9909 }
9910 if (!argp1) {
9911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9912 }
9913 arg1 = reinterpret_cast< wxBitmap * >(argp1);
9914 {
9915 if (!wxPyCheckForApp()) SWIG_fail;
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 SWIGINTERN PyObject *_wrap_new_RegionFromBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj = 0;
9930 wxBitmap *arg1 = 0 ;
9931 wxColour *arg2 = 0 ;
9932 int arg3 = (int) 0 ;
9933 wxRegion *result = 0 ;
9934 void *argp1 = 0 ;
9935 int res1 = 0 ;
9936 wxColour temp2 ;
9937 int val3 ;
9938 int ecode3 = 0 ;
9939 PyObject * obj0 = 0 ;
9940 PyObject * obj1 = 0 ;
9941 PyObject * obj2 = 0 ;
9942 char * kwnames[] = {
9943 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
9944 };
9945
9946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9947 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
9948 if (!SWIG_IsOK(res1)) {
9949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9950 }
9951 if (!argp1) {
9952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
9953 }
9954 arg1 = reinterpret_cast< wxBitmap * >(argp1);
9955 {
9956 arg2 = &temp2;
9957 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
9958 }
9959 if (obj2) {
9960 ecode3 = SWIG_AsVal_int(obj2, &val3);
9961 if (!SWIG_IsOK(ecode3)) {
9962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromBitmapColour" "', expected argument " "3"" of type '" "int""'");
9963 }
9964 arg3 = static_cast< int >(val3);
9965 }
9966 {
9967 if (!wxPyCheckForApp()) SWIG_fail;
9968 PyThreadState* __tstate = wxPyBeginAllowThreads();
9969 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
9974 return resultobj;
9975 fail:
9976 return NULL;
9977 }
9978
9979
9980 SWIGINTERN PyObject *_wrap_new_RegionFromPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9981 PyObject *resultobj = 0;
9982 int arg1 ;
9983 wxPoint *arg2 = (wxPoint *) 0 ;
9984 int arg3 = (int) wxWINDING_RULE ;
9985 wxRegion *result = 0 ;
9986 int val3 ;
9987 int ecode3 = 0 ;
9988 PyObject * obj0 = 0 ;
9989 PyObject * obj1 = 0 ;
9990 char * kwnames[] = {
9991 (char *) "points",(char *) "fillStyle", NULL
9992 };
9993
9994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) SWIG_fail;
9995 {
9996 arg2 = wxPoint_LIST_helper(obj0, &arg1);
9997 if (arg2 == NULL) SWIG_fail;
9998 }
9999 if (obj1) {
10000 ecode3 = SWIG_AsVal_int(obj1, &val3);
10001 if (!SWIG_IsOK(ecode3)) {
10002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromPoints" "', expected argument " "3"" of type '" "int""'");
10003 }
10004 arg3 = static_cast< int >(val3);
10005 }
10006 {
10007 if (!wxPyCheckForApp()) SWIG_fail;
10008 PyThreadState* __tstate = wxPyBeginAllowThreads();
10009 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
10014 {
10015 if (arg2) delete [] arg2;
10016 }
10017 return resultobj;
10018 fail:
10019 {
10020 if (arg2) delete [] arg2;
10021 }
10022 return NULL;
10023 }
10024
10025
10026 SWIGINTERN PyObject *_wrap_delete_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10027 PyObject *resultobj = 0;
10028 wxRegion *arg1 = (wxRegion *) 0 ;
10029 void *argp1 = 0 ;
10030 int res1 = 0 ;
10031 PyObject *swig_obj[1] ;
10032
10033 if (!args) SWIG_fail;
10034 swig_obj[0] = args;
10035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, SWIG_POINTER_DISOWN | 0 );
10036 if (!SWIG_IsOK(res1)) {
10037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', expected argument " "1"" of type '" "wxRegion *""'");
10038 }
10039 arg1 = reinterpret_cast< wxRegion * >(argp1);
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 delete arg1;
10043
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 resultobj = SWIG_Py_Void();
10048 return resultobj;
10049 fail:
10050 return NULL;
10051 }
10052
10053
10054 SWIGINTERN PyObject *_wrap_Region_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10055 PyObject *resultobj = 0;
10056 wxRegion *arg1 = (wxRegion *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject *swig_obj[1] ;
10060
10061 if (!args) SWIG_fail;
10062 swig_obj[0] = args;
10063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Clear" "', expected argument " "1"" of type '" "wxRegion *""'");
10066 }
10067 arg1 = reinterpret_cast< wxRegion * >(argp1);
10068 {
10069 PyThreadState* __tstate = wxPyBeginAllowThreads();
10070 (arg1)->Clear();
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 resultobj = SWIG_Py_Void();
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_Region_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10082 PyObject *resultobj = 0;
10083 wxRegion *arg1 = (wxRegion *) 0 ;
10084 int arg2 ;
10085 int arg3 ;
10086 bool result;
10087 void *argp1 = 0 ;
10088 int res1 = 0 ;
10089 int val2 ;
10090 int ecode2 = 0 ;
10091 int val3 ;
10092 int ecode3 = 0 ;
10093 PyObject * obj0 = 0 ;
10094 PyObject * obj1 = 0 ;
10095 PyObject * obj2 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "x",(char *) "y", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Offset" "', expected argument " "1"" of type '" "wxRegion *""'");
10104 }
10105 arg1 = reinterpret_cast< wxRegion * >(argp1);
10106 ecode2 = SWIG_AsVal_int(obj1, &val2);
10107 if (!SWIG_IsOK(ecode2)) {
10108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Offset" "', expected argument " "2"" of type '" "int""'");
10109 }
10110 arg2 = static_cast< int >(val2);
10111 ecode3 = SWIG_AsVal_int(obj2, &val3);
10112 if (!SWIG_IsOK(ecode3)) {
10113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Offset" "', expected argument " "3"" of type '" "int""'");
10114 }
10115 arg3 = static_cast< int >(val3);
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 result = (bool)(arg1)->Offset(arg2,arg3);
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 {
10123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10124 }
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_Region_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10132 PyObject *resultobj = 0;
10133 wxRegion *arg1 = (wxRegion *) 0 ;
10134 int arg2 ;
10135 int arg3 ;
10136 wxRegionContain result;
10137 void *argp1 = 0 ;
10138 int res1 = 0 ;
10139 int val2 ;
10140 int ecode2 = 0 ;
10141 int val3 ;
10142 int ecode3 = 0 ;
10143 PyObject * obj0 = 0 ;
10144 PyObject * obj1 = 0 ;
10145 PyObject * obj2 = 0 ;
10146 char * kwnames[] = {
10147 (char *) "self",(char *) "x",(char *) "y", NULL
10148 };
10149
10150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10152 if (!SWIG_IsOK(res1)) {
10153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Contains" "', expected argument " "1"" of type '" "wxRegion *""'");
10154 }
10155 arg1 = reinterpret_cast< wxRegion * >(argp1);
10156 ecode2 = SWIG_AsVal_int(obj1, &val2);
10157 if (!SWIG_IsOK(ecode2)) {
10158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Contains" "', expected argument " "2"" of type '" "int""'");
10159 }
10160 arg2 = static_cast< int >(val2);
10161 ecode3 = SWIG_AsVal_int(obj2, &val3);
10162 if (!SWIG_IsOK(ecode3)) {
10163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Contains" "', expected argument " "3"" of type '" "int""'");
10164 }
10165 arg3 = static_cast< int >(val3);
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 resultobj = SWIG_From_int(static_cast< int >(result));
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 SWIGINTERN PyObject *_wrap_Region_ContainsPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj = 0;
10181 wxRegion *arg1 = (wxRegion *) 0 ;
10182 wxPoint *arg2 = 0 ;
10183 wxRegionContain result;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 wxPoint temp2 ;
10187 PyObject * obj0 = 0 ;
10188 PyObject * obj1 = 0 ;
10189 char * kwnames[] = {
10190 (char *) "self",(char *) "pt", NULL
10191 };
10192
10193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) SWIG_fail;
10194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10195 if (!SWIG_IsOK(res1)) {
10196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsPoint" "', expected argument " "1"" of type '" "wxRegion *""'");
10197 }
10198 arg1 = reinterpret_cast< wxRegion * >(argp1);
10199 {
10200 arg2 = &temp2;
10201 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 resultobj = SWIG_From_int(static_cast< int >(result));
10210 return resultobj;
10211 fail:
10212 return NULL;
10213 }
10214
10215
10216 SWIGINTERN PyObject *_wrap_Region_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj = 0;
10218 wxRegion *arg1 = (wxRegion *) 0 ;
10219 wxRect *arg2 = 0 ;
10220 wxRegionContain result;
10221 void *argp1 = 0 ;
10222 int res1 = 0 ;
10223 wxRect temp2 ;
10224 PyObject * obj0 = 0 ;
10225 PyObject * obj1 = 0 ;
10226 char * kwnames[] = {
10227 (char *) "self",(char *) "rect", NULL
10228 };
10229
10230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10232 if (!SWIG_IsOK(res1)) {
10233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10234 }
10235 arg1 = reinterpret_cast< wxRegion * >(argp1);
10236 {
10237 arg2 = &temp2;
10238 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10239 }
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 resultobj = SWIG_From_int(static_cast< int >(result));
10247 return resultobj;
10248 fail:
10249 return NULL;
10250 }
10251
10252
10253 SWIGINTERN PyObject *_wrap_Region_ContainsRectDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj = 0;
10255 wxRegion *arg1 = (wxRegion *) 0 ;
10256 int arg2 ;
10257 int arg3 ;
10258 int arg4 ;
10259 int arg5 ;
10260 wxRegionContain result;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 int val2 ;
10264 int ecode2 = 0 ;
10265 int val3 ;
10266 int ecode3 = 0 ;
10267 int val4 ;
10268 int ecode4 = 0 ;
10269 int val5 ;
10270 int ecode5 = 0 ;
10271 PyObject * obj0 = 0 ;
10272 PyObject * obj1 = 0 ;
10273 PyObject * obj2 = 0 ;
10274 PyObject * obj3 = 0 ;
10275 PyObject * obj4 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRectDim" "', expected argument " "1"" of type '" "wxRegion *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRegion * >(argp1);
10286 ecode2 = SWIG_AsVal_int(obj1, &val2);
10287 if (!SWIG_IsOK(ecode2)) {
10288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_ContainsRectDim" "', expected argument " "2"" of type '" "int""'");
10289 }
10290 arg2 = static_cast< int >(val2);
10291 ecode3 = SWIG_AsVal_int(obj2, &val3);
10292 if (!SWIG_IsOK(ecode3)) {
10293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_ContainsRectDim" "', expected argument " "3"" of type '" "int""'");
10294 }
10295 arg3 = static_cast< int >(val3);
10296 ecode4 = SWIG_AsVal_int(obj3, &val4);
10297 if (!SWIG_IsOK(ecode4)) {
10298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_ContainsRectDim" "', expected argument " "4"" of type '" "int""'");
10299 }
10300 arg4 = static_cast< int >(val4);
10301 ecode5 = SWIG_AsVal_int(obj4, &val5);
10302 if (!SWIG_IsOK(ecode5)) {
10303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_ContainsRectDim" "', expected argument " "5"" of type '" "int""'");
10304 }
10305 arg5 = static_cast< int >(val5);
10306 {
10307 PyThreadState* __tstate = wxPyBeginAllowThreads();
10308 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 resultobj = SWIG_From_int(static_cast< int >(result));
10313 return resultobj;
10314 fail:
10315 return NULL;
10316 }
10317
10318
10319 SWIGINTERN PyObject *_wrap_Region_GetBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10320 PyObject *resultobj = 0;
10321 wxRegion *arg1 = (wxRegion *) 0 ;
10322 wxRect result;
10323 void *argp1 = 0 ;
10324 int res1 = 0 ;
10325 PyObject *swig_obj[1] ;
10326
10327 if (!args) SWIG_fail;
10328 swig_obj[0] = args;
10329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10330 if (!SWIG_IsOK(res1)) {
10331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_GetBox" "', expected argument " "1"" of type '" "wxRegion *""'");
10332 }
10333 arg1 = reinterpret_cast< wxRegion * >(argp1);
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (arg1)->GetBox();
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_Region_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxRegion *arg1 = (wxRegion *) 0 ;
10350 int arg2 ;
10351 int arg3 ;
10352 int arg4 ;
10353 int arg5 ;
10354 bool result;
10355 void *argp1 = 0 ;
10356 int res1 = 0 ;
10357 int val2 ;
10358 int ecode2 = 0 ;
10359 int val3 ;
10360 int ecode3 = 0 ;
10361 int val4 ;
10362 int ecode4 = 0 ;
10363 int val5 ;
10364 int ecode5 = 0 ;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 PyObject * obj2 = 0 ;
10368 PyObject * obj3 = 0 ;
10369 PyObject * obj4 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Intersect" "', expected argument " "1"" of type '" "wxRegion *""'");
10378 }
10379 arg1 = reinterpret_cast< wxRegion * >(argp1);
10380 ecode2 = SWIG_AsVal_int(obj1, &val2);
10381 if (!SWIG_IsOK(ecode2)) {
10382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Intersect" "', expected argument " "2"" of type '" "int""'");
10383 }
10384 arg2 = static_cast< int >(val2);
10385 ecode3 = SWIG_AsVal_int(obj2, &val3);
10386 if (!SWIG_IsOK(ecode3)) {
10387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Intersect" "', expected argument " "3"" of type '" "int""'");
10388 }
10389 arg3 = static_cast< int >(val3);
10390 ecode4 = SWIG_AsVal_int(obj3, &val4);
10391 if (!SWIG_IsOK(ecode4)) {
10392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Intersect" "', expected argument " "4"" of type '" "int""'");
10393 }
10394 arg4 = static_cast< int >(val4);
10395 ecode5 = SWIG_AsVal_int(obj4, &val5);
10396 if (!SWIG_IsOK(ecode5)) {
10397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Intersect" "', expected argument " "5"" of type '" "int""'");
10398 }
10399 arg5 = static_cast< int >(val5);
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 {
10407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10408 }
10409 return resultobj;
10410 fail:
10411 return NULL;
10412 }
10413
10414
10415 SWIGINTERN PyObject *_wrap_Region_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10416 PyObject *resultobj = 0;
10417 wxRegion *arg1 = (wxRegion *) 0 ;
10418 wxRect *arg2 = 0 ;
10419 bool result;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 wxRect temp2 ;
10423 PyObject * obj0 = 0 ;
10424 PyObject * obj1 = 0 ;
10425 char * kwnames[] = {
10426 (char *) "self",(char *) "rect", NULL
10427 };
10428
10429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
10430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10431 if (!SWIG_IsOK(res1)) {
10432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10433 }
10434 arg1 = reinterpret_cast< wxRegion * >(argp1);
10435 {
10436 arg2 = &temp2;
10437 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10438 }
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 {
10446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10447 }
10448 return resultobj;
10449 fail:
10450 return NULL;
10451 }
10452
10453
10454 SWIGINTERN PyObject *_wrap_Region_IntersectRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10455 PyObject *resultobj = 0;
10456 wxRegion *arg1 = (wxRegion *) 0 ;
10457 wxRegion *arg2 = 0 ;
10458 bool result;
10459 void *argp1 = 0 ;
10460 int res1 = 0 ;
10461 void *argp2 = 0 ;
10462 int res2 = 0 ;
10463 PyObject * obj0 = 0 ;
10464 PyObject * obj1 = 0 ;
10465 char * kwnames[] = {
10466 (char *) "self",(char *) "region", NULL
10467 };
10468
10469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10471 if (!SWIG_IsOK(res1)) {
10472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10473 }
10474 arg1 = reinterpret_cast< wxRegion * >(argp1);
10475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10476 if (!SWIG_IsOK(res2)) {
10477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10478 }
10479 if (!argp2) {
10480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10481 }
10482 arg2 = reinterpret_cast< wxRegion * >(argp2);
10483 {
10484 PyThreadState* __tstate = wxPyBeginAllowThreads();
10485 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 {
10490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10491 }
10492 return resultobj;
10493 fail:
10494 return NULL;
10495 }
10496
10497
10498 SWIGINTERN PyObject *_wrap_Region_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10499 PyObject *resultobj = 0;
10500 wxRegion *arg1 = (wxRegion *) 0 ;
10501 bool result;
10502 void *argp1 = 0 ;
10503 int res1 = 0 ;
10504 PyObject *swig_obj[1] ;
10505
10506 if (!args) SWIG_fail;
10507 swig_obj[0] = args;
10508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10509 if (!SWIG_IsOK(res1)) {
10510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IsEmpty" "', expected argument " "1"" of type '" "wxRegion *""'");
10511 }
10512 arg1 = reinterpret_cast< wxRegion * >(argp1);
10513 {
10514 PyThreadState* __tstate = wxPyBeginAllowThreads();
10515 result = (bool)(arg1)->IsEmpty();
10516 wxPyEndAllowThreads(__tstate);
10517 if (PyErr_Occurred()) SWIG_fail;
10518 }
10519 {
10520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10521 }
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 SWIGINTERN PyObject *_wrap_Region_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj = 0;
10530 wxRegion *arg1 = (wxRegion *) 0 ;
10531 int arg2 ;
10532 int arg3 ;
10533 int arg4 ;
10534 int arg5 ;
10535 bool result;
10536 void *argp1 = 0 ;
10537 int res1 = 0 ;
10538 int val2 ;
10539 int ecode2 = 0 ;
10540 int val3 ;
10541 int ecode3 = 0 ;
10542 int val4 ;
10543 int ecode4 = 0 ;
10544 int val5 ;
10545 int ecode5 = 0 ;
10546 PyObject * obj0 = 0 ;
10547 PyObject * obj1 = 0 ;
10548 PyObject * obj2 = 0 ;
10549 PyObject * obj3 = 0 ;
10550 PyObject * obj4 = 0 ;
10551 char * kwnames[] = {
10552 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10553 };
10554
10555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10557 if (!SWIG_IsOK(res1)) {
10558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Union" "', expected argument " "1"" of type '" "wxRegion *""'");
10559 }
10560 arg1 = reinterpret_cast< wxRegion * >(argp1);
10561 ecode2 = SWIG_AsVal_int(obj1, &val2);
10562 if (!SWIG_IsOK(ecode2)) {
10563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Union" "', expected argument " "2"" of type '" "int""'");
10564 }
10565 arg2 = static_cast< int >(val2);
10566 ecode3 = SWIG_AsVal_int(obj2, &val3);
10567 if (!SWIG_IsOK(ecode3)) {
10568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Union" "', expected argument " "3"" of type '" "int""'");
10569 }
10570 arg3 = static_cast< int >(val3);
10571 ecode4 = SWIG_AsVal_int(obj3, &val4);
10572 if (!SWIG_IsOK(ecode4)) {
10573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Union" "', expected argument " "4"" of type '" "int""'");
10574 }
10575 arg4 = static_cast< int >(val4);
10576 ecode5 = SWIG_AsVal_int(obj4, &val5);
10577 if (!SWIG_IsOK(ecode5)) {
10578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Union" "', expected argument " "5"" of type '" "int""'");
10579 }
10580 arg5 = static_cast< int >(val5);
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 {
10588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10589 }
10590 return resultobj;
10591 fail:
10592 return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *_wrap_Region_UnionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10597 PyObject *resultobj = 0;
10598 wxRegion *arg1 = (wxRegion *) 0 ;
10599 wxRect *arg2 = 0 ;
10600 bool result;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 wxRect temp2 ;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 char * kwnames[] = {
10607 (char *) "self",(char *) "rect", NULL
10608 };
10609
10610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) SWIG_fail;
10611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10614 }
10615 arg1 = reinterpret_cast< wxRegion * >(argp1);
10616 {
10617 arg2 = &temp2;
10618 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10619 }
10620 {
10621 PyThreadState* __tstate = wxPyBeginAllowThreads();
10622 result = (bool)(arg1)->Union((wxRect const &)*arg2);
10623 wxPyEndAllowThreads(__tstate);
10624 if (PyErr_Occurred()) SWIG_fail;
10625 }
10626 {
10627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10628 }
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_Region_UnionRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj = 0;
10637 wxRegion *arg1 = (wxRegion *) 0 ;
10638 wxRegion *arg2 = 0 ;
10639 bool result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 void *argp2 = 0 ;
10643 int res2 = 0 ;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "region", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10654 }
10655 arg1 = reinterpret_cast< wxRegion * >(argp1);
10656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10657 if (!SWIG_IsOK(res2)) {
10658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10659 }
10660 if (!argp2) {
10661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10662 }
10663 arg2 = reinterpret_cast< wxRegion * >(argp2);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10672 }
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_Region_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj = 0;
10681 wxRegion *arg1 = (wxRegion *) 0 ;
10682 int arg2 ;
10683 int arg3 ;
10684 int arg4 ;
10685 int arg5 ;
10686 bool result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 int val2 ;
10690 int ecode2 = 0 ;
10691 int val3 ;
10692 int ecode3 = 0 ;
10693 int val4 ;
10694 int ecode4 = 0 ;
10695 int val5 ;
10696 int ecode5 = 0 ;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 PyObject * obj3 = 0 ;
10701 PyObject * obj4 = 0 ;
10702 char * kwnames[] = {
10703 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10704 };
10705
10706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10708 if (!SWIG_IsOK(res1)) {
10709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Subtract" "', expected argument " "1"" of type '" "wxRegion *""'");
10710 }
10711 arg1 = reinterpret_cast< wxRegion * >(argp1);
10712 ecode2 = SWIG_AsVal_int(obj1, &val2);
10713 if (!SWIG_IsOK(ecode2)) {
10714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Subtract" "', expected argument " "2"" of type '" "int""'");
10715 }
10716 arg2 = static_cast< int >(val2);
10717 ecode3 = SWIG_AsVal_int(obj2, &val3);
10718 if (!SWIG_IsOK(ecode3)) {
10719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Subtract" "', expected argument " "3"" of type '" "int""'");
10720 }
10721 arg3 = static_cast< int >(val3);
10722 ecode4 = SWIG_AsVal_int(obj3, &val4);
10723 if (!SWIG_IsOK(ecode4)) {
10724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Subtract" "', expected argument " "4"" of type '" "int""'");
10725 }
10726 arg4 = static_cast< int >(val4);
10727 ecode5 = SWIG_AsVal_int(obj4, &val5);
10728 if (!SWIG_IsOK(ecode5)) {
10729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Subtract" "', expected argument " "5"" of type '" "int""'");
10730 }
10731 arg5 = static_cast< int >(val5);
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 {
10739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10740 }
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *_wrap_Region_SubtractRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10748 PyObject *resultobj = 0;
10749 wxRegion *arg1 = (wxRegion *) 0 ;
10750 wxRect *arg2 = 0 ;
10751 bool result;
10752 void *argp1 = 0 ;
10753 int res1 = 0 ;
10754 wxRect temp2 ;
10755 PyObject * obj0 = 0 ;
10756 PyObject * obj1 = 0 ;
10757 char * kwnames[] = {
10758 (char *) "self",(char *) "rect", NULL
10759 };
10760
10761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) SWIG_fail;
10762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10765 }
10766 arg1 = reinterpret_cast< wxRegion * >(argp1);
10767 {
10768 arg2 = &temp2;
10769 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10770 }
10771 {
10772 PyThreadState* __tstate = wxPyBeginAllowThreads();
10773 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 {
10778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10779 }
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_Region_SubtractRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10787 PyObject *resultobj = 0;
10788 wxRegion *arg1 = (wxRegion *) 0 ;
10789 wxRegion *arg2 = 0 ;
10790 bool result;
10791 void *argp1 = 0 ;
10792 int res1 = 0 ;
10793 void *argp2 = 0 ;
10794 int res2 = 0 ;
10795 PyObject * obj0 = 0 ;
10796 PyObject * obj1 = 0 ;
10797 char * kwnames[] = {
10798 (char *) "self",(char *) "region", NULL
10799 };
10800
10801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10803 if (!SWIG_IsOK(res1)) {
10804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10805 }
10806 arg1 = reinterpret_cast< wxRegion * >(argp1);
10807 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10808 if (!SWIG_IsOK(res2)) {
10809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10810 }
10811 if (!argp2) {
10812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10813 }
10814 arg2 = reinterpret_cast< wxRegion * >(argp2);
10815 {
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
10818 wxPyEndAllowThreads(__tstate);
10819 if (PyErr_Occurred()) SWIG_fail;
10820 }
10821 {
10822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10823 }
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 SWIGINTERN PyObject *_wrap_Region_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10831 PyObject *resultobj = 0;
10832 wxRegion *arg1 = (wxRegion *) 0 ;
10833 int arg2 ;
10834 int arg3 ;
10835 int arg4 ;
10836 int arg5 ;
10837 bool result;
10838 void *argp1 = 0 ;
10839 int res1 = 0 ;
10840 int val2 ;
10841 int ecode2 = 0 ;
10842 int val3 ;
10843 int ecode3 = 0 ;
10844 int val4 ;
10845 int ecode4 = 0 ;
10846 int val5 ;
10847 int ecode5 = 0 ;
10848 PyObject * obj0 = 0 ;
10849 PyObject * obj1 = 0 ;
10850 PyObject * obj2 = 0 ;
10851 PyObject * obj3 = 0 ;
10852 PyObject * obj4 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10859 if (!SWIG_IsOK(res1)) {
10860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Xor" "', expected argument " "1"" of type '" "wxRegion *""'");
10861 }
10862 arg1 = reinterpret_cast< wxRegion * >(argp1);
10863 ecode2 = SWIG_AsVal_int(obj1, &val2);
10864 if (!SWIG_IsOK(ecode2)) {
10865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Xor" "', expected argument " "2"" of type '" "int""'");
10866 }
10867 arg2 = static_cast< int >(val2);
10868 ecode3 = SWIG_AsVal_int(obj2, &val3);
10869 if (!SWIG_IsOK(ecode3)) {
10870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Xor" "', expected argument " "3"" of type '" "int""'");
10871 }
10872 arg3 = static_cast< int >(val3);
10873 ecode4 = SWIG_AsVal_int(obj3, &val4);
10874 if (!SWIG_IsOK(ecode4)) {
10875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Xor" "', expected argument " "4"" of type '" "int""'");
10876 }
10877 arg4 = static_cast< int >(val4);
10878 ecode5 = SWIG_AsVal_int(obj4, &val5);
10879 if (!SWIG_IsOK(ecode5)) {
10880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Xor" "', expected argument " "5"" of type '" "int""'");
10881 }
10882 arg5 = static_cast< int >(val5);
10883 {
10884 PyThreadState* __tstate = wxPyBeginAllowThreads();
10885 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
10886 wxPyEndAllowThreads(__tstate);
10887 if (PyErr_Occurred()) SWIG_fail;
10888 }
10889 {
10890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10891 }
10892 return resultobj;
10893 fail:
10894 return NULL;
10895 }
10896
10897
10898 SWIGINTERN PyObject *_wrap_Region_XorRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10899 PyObject *resultobj = 0;
10900 wxRegion *arg1 = (wxRegion *) 0 ;
10901 wxRect *arg2 = 0 ;
10902 bool result;
10903 void *argp1 = 0 ;
10904 int res1 = 0 ;
10905 wxRect temp2 ;
10906 PyObject * obj0 = 0 ;
10907 PyObject * obj1 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "self",(char *) "rect", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10916 }
10917 arg1 = reinterpret_cast< wxRegion * >(argp1);
10918 {
10919 arg2 = &temp2;
10920 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10930 }
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 SWIGINTERN PyObject *_wrap_Region_XorRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj = 0;
10939 wxRegion *arg1 = (wxRegion *) 0 ;
10940 wxRegion *arg2 = 0 ;
10941 bool result;
10942 void *argp1 = 0 ;
10943 int res1 = 0 ;
10944 void *argp2 = 0 ;
10945 int res2 = 0 ;
10946 PyObject * obj0 = 0 ;
10947 PyObject * obj1 = 0 ;
10948 char * kwnames[] = {
10949 (char *) "self",(char *) "region", NULL
10950 };
10951
10952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) SWIG_fail;
10953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10954 if (!SWIG_IsOK(res1)) {
10955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
10956 }
10957 arg1 = reinterpret_cast< wxRegion * >(argp1);
10958 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
10959 if (!SWIG_IsOK(res2)) {
10960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10961 }
10962 if (!argp2) {
10963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
10964 }
10965 arg2 = reinterpret_cast< wxRegion * >(argp2);
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
10969 wxPyEndAllowThreads(__tstate);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 {
10973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_Region_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10982 PyObject *resultobj = 0;
10983 wxRegion *arg1 = (wxRegion *) 0 ;
10984 SwigValueWrapper<wxBitmap > result;
10985 void *argp1 = 0 ;
10986 int res1 = 0 ;
10987 PyObject *swig_obj[1] ;
10988
10989 if (!args) SWIG_fail;
10990 swig_obj[0] = args;
10991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10992 if (!SWIG_IsOK(res1)) {
10993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ConvertToBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
10994 }
10995 arg1 = reinterpret_cast< wxRegion * >(argp1);
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (arg1)->ConvertToBitmap();
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_Region_UnionBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11010 PyObject *resultobj = 0;
11011 wxRegion *arg1 = (wxRegion *) 0 ;
11012 wxBitmap *arg2 = 0 ;
11013 bool result;
11014 void *argp1 = 0 ;
11015 int res1 = 0 ;
11016 void *argp2 = 0 ;
11017 int res2 = 0 ;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 char * kwnames[] = {
11021 (char *) "self",(char *) "bmp", NULL
11022 };
11023
11024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
11025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11026 if (!SWIG_IsOK(res1)) {
11027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
11028 }
11029 arg1 = reinterpret_cast< wxRegion * >(argp1);
11030 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11031 if (!SWIG_IsOK(res2)) {
11032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11033 }
11034 if (!argp2) {
11035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11036 }
11037 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 {
11045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11046 }
11047 return resultobj;
11048 fail:
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_Region_UnionBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj = 0;
11055 wxRegion *arg1 = (wxRegion *) 0 ;
11056 wxBitmap *arg2 = 0 ;
11057 wxColour *arg3 = 0 ;
11058 int arg4 = (int) 0 ;
11059 bool result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 void *argp2 = 0 ;
11063 int res2 = 0 ;
11064 wxColour temp3 ;
11065 int val4 ;
11066 int ecode4 = 0 ;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 PyObject * obj2 = 0 ;
11070 PyObject * obj3 = 0 ;
11071 char * kwnames[] = {
11072 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
11073 };
11074
11075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11077 if (!SWIG_IsOK(res1)) {
11078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmapColour" "', expected argument " "1"" of type '" "wxRegion *""'");
11079 }
11080 arg1 = reinterpret_cast< wxRegion * >(argp1);
11081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11082 if (!SWIG_IsOK(res2)) {
11083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11084 }
11085 if (!argp2) {
11086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11087 }
11088 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11089 {
11090 arg3 = &temp3;
11091 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
11092 }
11093 if (obj3) {
11094 ecode4 = SWIG_AsVal_int(obj3, &val4);
11095 if (!SWIG_IsOK(ecode4)) {
11096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_UnionBitmapColour" "', expected argument " "4"" of type '" "int""'");
11097 }
11098 arg4 = static_cast< int >(val4);
11099 }
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
11103 wxPyEndAllowThreads(__tstate);
11104 if (PyErr_Occurred()) SWIG_fail;
11105 }
11106 {
11107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11108 }
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11116 PyObject *obj;
11117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11118 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegion, SWIG_NewClientData(obj));
11119 return SWIG_Py_Void();
11120 }
11121
11122 SWIGINTERN PyObject *Region_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11123 return SWIG_Python_InitShadowInstance(args);
11124 }
11125
11126 SWIGINTERN PyObject *_wrap_new_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj = 0;
11128 wxRegion *arg1 = 0 ;
11129 wxRegionIterator *result = 0 ;
11130 void *argp1 = 0 ;
11131 int res1 = 0 ;
11132 PyObject * obj0 = 0 ;
11133 char * kwnames[] = {
11134 (char *) "region", NULL
11135 };
11136
11137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) SWIG_fail;
11138 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRegion, 0 | 0);
11139 if (!SWIG_IsOK(res1)) {
11140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11141 }
11142 if (!argp1) {
11143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11144 }
11145 arg1 = reinterpret_cast< wxRegion * >(argp1);
11146 {
11147 if (!wxPyCheckForApp()) SWIG_fail;
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_NEW | 0 );
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_delete_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11161 PyObject *resultobj = 0;
11162 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 PyObject *swig_obj[1] ;
11166
11167 if (!args) SWIG_fail;
11168 swig_obj[0] = args;
11169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_DISOWN | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegionIterator" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11172 }
11173 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 delete arg1;
11177
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 resultobj = SWIG_Py_Void();
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_RegionIterator_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 PyObject *resultobj = 0;
11190 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11191 int result;
11192 void *argp1 = 0 ;
11193 int res1 = 0 ;
11194 PyObject *swig_obj[1] ;
11195
11196 if (!args) SWIG_fail;
11197 swig_obj[0] = args;
11198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11199 if (!SWIG_IsOK(res1)) {
11200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetX" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11201 }
11202 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11203 {
11204 PyThreadState* __tstate = wxPyBeginAllowThreads();
11205 result = (int)(arg1)->GetX();
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 resultobj = SWIG_From_int(static_cast< int >(result));
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 SWIGINTERN PyObject *_wrap_RegionIterator_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11217 PyObject *resultobj = 0;
11218 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11219 int result;
11220 void *argp1 = 0 ;
11221 int res1 = 0 ;
11222 PyObject *swig_obj[1] ;
11223
11224 if (!args) SWIG_fail;
11225 swig_obj[0] = args;
11226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11227 if (!SWIG_IsOK(res1)) {
11228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetY" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11229 }
11230 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 result = (int)(arg1)->GetY();
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 resultobj = SWIG_From_int(static_cast< int >(result));
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 SWIGINTERN PyObject *_wrap_RegionIterator_GetW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11245 PyObject *resultobj = 0;
11246 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11247 int result;
11248 void *argp1 = 0 ;
11249 int res1 = 0 ;
11250 PyObject *swig_obj[1] ;
11251
11252 if (!args) SWIG_fail;
11253 swig_obj[0] = args;
11254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11255 if (!SWIG_IsOK(res1)) {
11256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetW" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11257 }
11258 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 result = (int)(arg1)->GetW();
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 resultobj = SWIG_From_int(static_cast< int >(result));
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_RegionIterator_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *resultobj = 0;
11274 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11275 int result;
11276 void *argp1 = 0 ;
11277 int res1 = 0 ;
11278 PyObject *swig_obj[1] ;
11279
11280 if (!args) SWIG_fail;
11281 swig_obj[0] = args;
11282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetWidth" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11285 }
11286 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (int)(arg1)->GetWidth();
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 resultobj = SWIG_From_int(static_cast< int >(result));
11294 return resultobj;
11295 fail:
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *_wrap_RegionIterator_GetH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11301 PyObject *resultobj = 0;
11302 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11303 int result;
11304 void *argp1 = 0 ;
11305 int res1 = 0 ;
11306 PyObject *swig_obj[1] ;
11307
11308 if (!args) SWIG_fail;
11309 swig_obj[0] = args;
11310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11311 if (!SWIG_IsOK(res1)) {
11312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetH" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11313 }
11314 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11315 {
11316 PyThreadState* __tstate = wxPyBeginAllowThreads();
11317 result = (int)(arg1)->GetH();
11318 wxPyEndAllowThreads(__tstate);
11319 if (PyErr_Occurred()) SWIG_fail;
11320 }
11321 resultobj = SWIG_From_int(static_cast< int >(result));
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_RegionIterator_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 PyObject *resultobj = 0;
11330 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11331 int result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 PyObject *swig_obj[1] ;
11335
11336 if (!args) SWIG_fail;
11337 swig_obj[0] = args;
11338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11339 if (!SWIG_IsOK(res1)) {
11340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetHeight" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11341 }
11342 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (int)(arg1)->GetHeight();
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 resultobj = SWIG_From_int(static_cast< int >(result));
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_RegionIterator_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11357 PyObject *resultobj = 0;
11358 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11359 wxRect result;
11360 void *argp1 = 0 ;
11361 int res1 = 0 ;
11362 PyObject *swig_obj[1] ;
11363
11364 if (!args) SWIG_fail;
11365 swig_obj[0] = args;
11366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11367 if (!SWIG_IsOK(res1)) {
11368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetRect" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11369 }
11370 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11371 {
11372 PyThreadState* __tstate = wxPyBeginAllowThreads();
11373 result = (arg1)->GetRect();
11374 wxPyEndAllowThreads(__tstate);
11375 if (PyErr_Occurred()) SWIG_fail;
11376 }
11377 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
11378 return resultobj;
11379 fail:
11380 return NULL;
11381 }
11382
11383
11384 SWIGINTERN PyObject *_wrap_RegionIterator_HaveRects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11385 PyObject *resultobj = 0;
11386 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11387 bool result;
11388 void *argp1 = 0 ;
11389 int res1 = 0 ;
11390 PyObject *swig_obj[1] ;
11391
11392 if (!args) SWIG_fail;
11393 swig_obj[0] = args;
11394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11395 if (!SWIG_IsOK(res1)) {
11396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_HaveRects" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11397 }
11398 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (bool)(arg1)->HaveRects();
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 {
11406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11407 }
11408 return resultobj;
11409 fail:
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_RegionIterator_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11415 PyObject *resultobj = 0;
11416 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11417 void *argp1 = 0 ;
11418 int res1 = 0 ;
11419 PyObject *swig_obj[1] ;
11420
11421 if (!args) SWIG_fail;
11422 swig_obj[0] = args;
11423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Reset" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11426 }
11427 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 (arg1)->Reset();
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_Py_Void();
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 SWIGINTERN PyObject *_wrap_RegionIterator_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11442 PyObject *resultobj = 0;
11443 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11444 void *argp1 = 0 ;
11445 int res1 = 0 ;
11446 PyObject *swig_obj[1] ;
11447
11448 if (!args) SWIG_fail;
11449 swig_obj[0] = args;
11450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11451 if (!SWIG_IsOK(res1)) {
11452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Next" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11453 }
11454 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11455 {
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 wxRegionIterator_Next(arg1);
11458 wxPyEndAllowThreads(__tstate);
11459 if (PyErr_Occurred()) SWIG_fail;
11460 }
11461 resultobj = SWIG_Py_Void();
11462 return resultobj;
11463 fail:
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_RegionIterator___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11471 bool result;
11472 void *argp1 = 0 ;
11473 int res1 = 0 ;
11474 PyObject *swig_obj[1] ;
11475
11476 if (!args) SWIG_fail;
11477 swig_obj[0] = args;
11478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11479 if (!SWIG_IsOK(res1)) {
11480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator___nonzero__" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11481 }
11482 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11483 {
11484 PyThreadState* __tstate = wxPyBeginAllowThreads();
11485 result = (bool)wxRegionIterator___nonzero__(arg1);
11486 wxPyEndAllowThreads(__tstate);
11487 if (PyErr_Occurred()) SWIG_fail;
11488 }
11489 {
11490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11491 }
11492 return resultobj;
11493 fail:
11494 return NULL;
11495 }
11496
11497
11498 SWIGINTERN PyObject *RegionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11499 PyObject *obj;
11500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11501 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegionIterator, SWIG_NewClientData(obj));
11502 return SWIG_Py_Void();
11503 }
11504
11505 SWIGINTERN PyObject *RegionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11506 return SWIG_Python_InitShadowInstance(args);
11507 }
11508
11509 SWIGINTERN PyObject *_wrap_new_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxNativeFontInfo *result = 0 ;
11512
11513 if (!SWIG_Python_UnpackTuple(args,"new_NativeFontInfo",0,0,0)) SWIG_fail;
11514 {
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 result = (wxNativeFontInfo *)new wxNativeFontInfo();
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_NEW | 0 );
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_delete_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11530 void *argp1 = 0 ;
11531 int res1 = 0 ;
11532 PyObject *swig_obj[1] ;
11533
11534 if (!args) SWIG_fail;
11535 swig_obj[0] = args;
11536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_DISOWN | 0 );
11537 if (!SWIG_IsOK(res1)) {
11538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeFontInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11539 }
11540 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 delete arg1;
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 resultobj = SWIG_Py_Void();
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_NativeFontInfo_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11556 PyObject *resultobj = 0;
11557 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11558 void *argp1 = 0 ;
11559 int res1 = 0 ;
11560 PyObject *swig_obj[1] ;
11561
11562 if (!args) SWIG_fail;
11563 swig_obj[0] = args;
11564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11565 if (!SWIG_IsOK(res1)) {
11566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_Init" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11567 }
11568 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 (arg1)->Init();
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 resultobj = SWIG_Py_Void();
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11585 wxFont *arg2 = 0 ;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 void *argp2 = 0 ;
11589 int res2 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 char * kwnames[] = {
11593 (char *) "self",(char *) "font", NULL
11594 };
11595
11596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) SWIG_fail;
11597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11600 }
11601 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11602 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
11603 if (!SWIG_IsOK(res2)) {
11604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
11605 }
11606 if (!argp2) {
11607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
11608 }
11609 arg2 = reinterpret_cast< wxFont * >(argp2);
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 (arg1)->InitFromFont((wxFont const &)*arg2);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 resultobj = SWIG_Py_Void();
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11626 int result;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 PyObject *swig_obj[1] ;
11630
11631 if (!args) SWIG_fail;
11632 swig_obj[0] = args;
11633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11636 }
11637 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 resultobj = SWIG_From_int(static_cast< int >(result));
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11652 PyObject *resultobj = 0;
11653 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11654 wxFontStyle result;
11655 void *argp1 = 0 ;
11656 int res1 = 0 ;
11657 PyObject *swig_obj[1] ;
11658
11659 if (!args) SWIG_fail;
11660 swig_obj[0] = args;
11661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11662 if (!SWIG_IsOK(res1)) {
11663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11664 }
11665 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 resultobj = SWIG_From_int(static_cast< int >(result));
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *resultobj = 0;
11681 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11682 wxFontWeight result;
11683 void *argp1 = 0 ;
11684 int res1 = 0 ;
11685 PyObject *swig_obj[1] ;
11686
11687 if (!args) SWIG_fail;
11688 swig_obj[0] = args;
11689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11692 }
11693 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11694 {
11695 PyThreadState* __tstate = wxPyBeginAllowThreads();
11696 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 resultobj = SWIG_From_int(static_cast< int >(result));
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *resultobj = 0;
11709 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11710 bool result;
11711 void *argp1 = 0 ;
11712 int res1 = 0 ;
11713 PyObject *swig_obj[1] ;
11714
11715 if (!args) SWIG_fail;
11716 swig_obj[0] = args;
11717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11718 if (!SWIG_IsOK(res1)) {
11719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11720 }
11721 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11730 }
11731 return resultobj;
11732 fail:
11733 return NULL;
11734 }
11735
11736
11737 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11740 wxString result;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 PyObject *swig_obj[1] ;
11744
11745 if (!args) SWIG_fail;
11746 swig_obj[0] = args;
11747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11750 }
11751 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
11755 wxPyEndAllowThreads(__tstate);
11756 if (PyErr_Occurred()) SWIG_fail;
11757 }
11758 {
11759 #if wxUSE_UNICODE
11760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11761 #else
11762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11763 #endif
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11774 wxFontFamily result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11784 }
11785 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 resultobj = SWIG_From_int(static_cast< int >(result));
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 PyObject *resultobj = 0;
11801 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11802 wxFontEncoding result;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
11812 }
11813 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_From_int(static_cast< int >(result));
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj = 0;
11829 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11830 int arg2 ;
11831 void *argp1 = 0 ;
11832 int res1 = 0 ;
11833 int val2 ;
11834 int ecode2 = 0 ;
11835 PyObject * obj0 = 0 ;
11836 PyObject * obj1 = 0 ;
11837 char * kwnames[] = {
11838 (char *) "self",(char *) "pointsize", NULL
11839 };
11840
11841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
11842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11843 if (!SWIG_IsOK(res1)) {
11844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11845 }
11846 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11847 ecode2 = SWIG_AsVal_int(obj1, &val2);
11848 if (!SWIG_IsOK(ecode2)) {
11849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "2"" of type '" "int""'");
11850 }
11851 arg2 = static_cast< int >(val2);
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 (arg1)->SetPointSize(arg2);
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 resultobj = SWIG_Py_Void();
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11866 PyObject *resultobj = 0;
11867 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11868 wxFontStyle arg2 ;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 int val2 ;
11872 int ecode2 = 0 ;
11873 PyObject * obj0 = 0 ;
11874 PyObject * obj1 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "self",(char *) "style", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
11880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11881 if (!SWIG_IsOK(res1)) {
11882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11883 }
11884 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11885 ecode2 = SWIG_AsVal_int(obj1, &val2);
11886 if (!SWIG_IsOK(ecode2)) {
11887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
11888 }
11889 arg2 = static_cast< wxFontStyle >(val2);
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 (arg1)->SetStyle(arg2);
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 resultobj = SWIG_Py_Void();
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = 0;
11905 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11906 wxFontWeight arg2 ;
11907 void *argp1 = 0 ;
11908 int res1 = 0 ;
11909 int val2 ;
11910 int ecode2 = 0 ;
11911 PyObject * obj0 = 0 ;
11912 PyObject * obj1 = 0 ;
11913 char * kwnames[] = {
11914 (char *) "self",(char *) "weight", NULL
11915 };
11916
11917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
11918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11921 }
11922 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11923 ecode2 = SWIG_AsVal_int(obj1, &val2);
11924 if (!SWIG_IsOK(ecode2)) {
11925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
11926 }
11927 arg2 = static_cast< wxFontWeight >(val2);
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 (arg1)->SetWeight(arg2);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_Py_Void();
11935 return resultobj;
11936 fail:
11937 return NULL;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11942 PyObject *resultobj = 0;
11943 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11944 bool arg2 ;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 bool val2 ;
11948 int ecode2 = 0 ;
11949 PyObject * obj0 = 0 ;
11950 PyObject * obj1 = 0 ;
11951 char * kwnames[] = {
11952 (char *) "self",(char *) "underlined", NULL
11953 };
11954
11955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
11956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11959 }
11960 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11961 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11962 if (!SWIG_IsOK(ecode2)) {
11963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
11964 }
11965 arg2 = static_cast< bool >(val2);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 (arg1)->SetUnderlined(arg2);
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 resultobj = SWIG_Py_Void();
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj = 0;
11981 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
11982 wxString arg2 ;
11983 bool result;
11984 void *argp1 = 0 ;
11985 int res1 = 0 ;
11986 PyObject * obj0 = 0 ;
11987 PyObject * obj1 = 0 ;
11988 char * kwnames[] = {
11989 (char *) "self",(char *) "facename", NULL
11990 };
11991
11992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
11993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
11996 }
11997 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
11998 {
11999 wxString* sptr = wxString_in_helper(obj1);
12000 if (sptr == NULL) SWIG_fail;
12001 arg2 = *sptr;
12002 delete sptr;
12003 }
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = (bool)(arg1)->SetFaceName(arg2);
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj = 0;
12021 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12022 wxFontFamily arg2 ;
12023 void *argp1 = 0 ;
12024 int res1 = 0 ;
12025 int val2 ;
12026 int ecode2 = 0 ;
12027 PyObject * obj0 = 0 ;
12028 PyObject * obj1 = 0 ;
12029 char * kwnames[] = {
12030 (char *) "self",(char *) "family", NULL
12031 };
12032
12033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
12034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12035 if (!SWIG_IsOK(res1)) {
12036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12037 }
12038 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12039 ecode2 = SWIG_AsVal_int(obj1, &val2);
12040 if (!SWIG_IsOK(ecode2)) {
12041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
12042 }
12043 arg2 = static_cast< wxFontFamily >(val2);
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 (arg1)->SetFamily(arg2);
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_Py_Void();
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj = 0;
12059 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12060 wxFontEncoding arg2 ;
12061 void *argp1 = 0 ;
12062 int res1 = 0 ;
12063 int val2 ;
12064 int ecode2 = 0 ;
12065 PyObject * obj0 = 0 ;
12066 PyObject * obj1 = 0 ;
12067 char * kwnames[] = {
12068 (char *) "self",(char *) "encoding", NULL
12069 };
12070
12071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
12072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12073 if (!SWIG_IsOK(res1)) {
12074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12075 }
12076 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12077 ecode2 = SWIG_AsVal_int(obj1, &val2);
12078 if (!SWIG_IsOK(ecode2)) {
12079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12080 }
12081 arg2 = static_cast< wxFontEncoding >(val2);
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 (arg1)->SetEncoding(arg2);
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_Py_Void();
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = 0;
12097 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12098 wxString *arg2 = 0 ;
12099 bool result;
12100 void *argp1 = 0 ;
12101 int res1 = 0 ;
12102 bool temp2 = false ;
12103 PyObject * obj0 = 0 ;
12104 PyObject * obj1 = 0 ;
12105 char * kwnames[] = {
12106 (char *) "self",(char *) "s", NULL
12107 };
12108
12109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
12110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12111 if (!SWIG_IsOK(res1)) {
12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12113 }
12114 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12115 {
12116 arg2 = wxString_in_helper(obj1);
12117 if (arg2 == NULL) SWIG_fail;
12118 temp2 = true;
12119 }
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (bool)(arg1)->FromString((wxString const &)*arg2);
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12128 }
12129 {
12130 if (temp2)
12131 delete arg2;
12132 }
12133 return resultobj;
12134 fail:
12135 {
12136 if (temp2)
12137 delete arg2;
12138 }
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *resultobj = 0;
12145 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12146 wxString result;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12156 }
12157 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = ((wxNativeFontInfo const *)arg1)->ToString();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 {
12165 #if wxUSE_UNICODE
12166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12167 #else
12168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12169 #endif
12170 }
12171 return resultobj;
12172 fail:
12173 return NULL;
12174 }
12175
12176
12177 SWIGINTERN PyObject *_wrap_NativeFontInfo___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12178 PyObject *resultobj = 0;
12179 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12180 wxString result;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 PyObject *swig_obj[1] ;
12184
12185 if (!args) SWIG_fail;
12186 swig_obj[0] = args;
12187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12188 if (!SWIG_IsOK(res1)) {
12189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo___str__" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12190 }
12191 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = wxNativeFontInfo___str__(arg1);
12195 wxPyEndAllowThreads(__tstate);
12196 if (PyErr_Occurred()) SWIG_fail;
12197 }
12198 {
12199 #if wxUSE_UNICODE
12200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12201 #else
12202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12203 #endif
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj = 0;
12213 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12214 wxString *arg2 = 0 ;
12215 bool result;
12216 void *argp1 = 0 ;
12217 int res1 = 0 ;
12218 bool temp2 = false ;
12219 PyObject * obj0 = 0 ;
12220 PyObject * obj1 = 0 ;
12221 char * kwnames[] = {
12222 (char *) "self",(char *) "s", NULL
12223 };
12224
12225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) SWIG_fail;
12226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12227 if (!SWIG_IsOK(res1)) {
12228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12229 }
12230 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12231 {
12232 arg2 = wxString_in_helper(obj1);
12233 if (arg2 == NULL) SWIG_fail;
12234 temp2 = true;
12235 }
12236 {
12237 PyThreadState* __tstate = wxPyBeginAllowThreads();
12238 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
12239 wxPyEndAllowThreads(__tstate);
12240 if (PyErr_Occurred()) SWIG_fail;
12241 }
12242 {
12243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12244 }
12245 {
12246 if (temp2)
12247 delete arg2;
12248 }
12249 return resultobj;
12250 fail:
12251 {
12252 if (temp2)
12253 delete arg2;
12254 }
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12260 PyObject *resultobj = 0;
12261 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12262 wxString result;
12263 void *argp1 = 0 ;
12264 int res1 = 0 ;
12265 PyObject *swig_obj[1] ;
12266
12267 if (!args) SWIG_fail;
12268 swig_obj[0] = args;
12269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12270 if (!SWIG_IsOK(res1)) {
12271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12272 }
12273 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 {
12281 #if wxUSE_UNICODE
12282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12283 #else
12284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12285 #endif
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 SWIGINTERN PyObject *NativeFontInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12294 PyObject *obj;
12295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12296 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeFontInfo, SWIG_NewClientData(obj));
12297 return SWIG_Py_Void();
12298 }
12299
12300 SWIGINTERN PyObject *NativeFontInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12301 return SWIG_Python_InitShadowInstance(args);
12302 }
12303
12304 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12305 PyObject *resultobj = 0;
12306 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12307 wxString *arg2 = (wxString *) 0 ;
12308 void *argp1 = 0 ;
12309 int res1 = 0 ;
12310 bool temp2 = false ;
12311 PyObject *swig_obj[2] ;
12312
12313 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_facename_set",2,2,swig_obj)) SWIG_fail;
12314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12315 if (!SWIG_IsOK(res1)) {
12316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12317 }
12318 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12319 {
12320 arg2 = wxString_in_helper(swig_obj[1]);
12321 if (arg2 == NULL) SWIG_fail;
12322 temp2 = true;
12323 }
12324 if (arg1) (arg1)->facename = *arg2;
12325
12326 resultobj = SWIG_Py_Void();
12327 {
12328 if (temp2)
12329 delete arg2;
12330 }
12331 return resultobj;
12332 fail:
12333 {
12334 if (temp2)
12335 delete arg2;
12336 }
12337 return NULL;
12338 }
12339
12340
12341 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12342 PyObject *resultobj = 0;
12343 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12344 wxString *result = 0 ;
12345 void *argp1 = 0 ;
12346 int res1 = 0 ;
12347 PyObject *swig_obj[1] ;
12348
12349 if (!args) SWIG_fail;
12350 swig_obj[0] = args;
12351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12352 if (!SWIG_IsOK(res1)) {
12353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12354 }
12355 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12356 result = (wxString *)& ((arg1)->facename);
12357 {
12358 #if wxUSE_UNICODE
12359 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12360 #else
12361 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12362 #endif
12363 }
12364 return resultobj;
12365 fail:
12366 return NULL;
12367 }
12368
12369
12370 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12371 PyObject *resultobj = 0;
12372 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12373 wxFontEncoding arg2 ;
12374 void *argp1 = 0 ;
12375 int res1 = 0 ;
12376 int val2 ;
12377 int ecode2 = 0 ;
12378 PyObject *swig_obj[2] ;
12379
12380 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_encoding_set",2,2,swig_obj)) SWIG_fail;
12381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12382 if (!SWIG_IsOK(res1)) {
12383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12384 }
12385 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12386 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12387 if (!SWIG_IsOK(ecode2)) {
12388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12389 }
12390 arg2 = static_cast< wxFontEncoding >(val2);
12391 if (arg1) (arg1)->encoding = arg2;
12392
12393 resultobj = SWIG_Py_Void();
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401 PyObject *resultobj = 0;
12402 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12403 wxFontEncoding result;
12404 void *argp1 = 0 ;
12405 int res1 = 0 ;
12406 PyObject *swig_obj[1] ;
12407
12408 if (!args) SWIG_fail;
12409 swig_obj[0] = args;
12410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12411 if (!SWIG_IsOK(res1)) {
12412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12413 }
12414 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12415 result = (wxFontEncoding) ((arg1)->encoding);
12416 resultobj = SWIG_From_int(static_cast< int >(result));
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 SWIGINTERN PyObject *_wrap_new_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12424 PyObject *resultobj = 0;
12425 wxNativeEncodingInfo *result = 0 ;
12426
12427 if (!SWIG_Python_UnpackTuple(args,"new_NativeEncodingInfo",0,0,0)) SWIG_fail;
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_NEW | 0 );
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 SWIGINTERN PyObject *_wrap_delete_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12442 PyObject *resultobj = 0;
12443 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12444 void *argp1 = 0 ;
12445 int res1 = 0 ;
12446 PyObject *swig_obj[1] ;
12447
12448 if (!args) SWIG_fail;
12449 swig_obj[0] = args;
12450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_DISOWN | 0 );
12451 if (!SWIG_IsOK(res1)) {
12452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeEncodingInfo" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12453 }
12454 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 delete arg1;
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 resultobj = SWIG_Py_Void();
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj = 0;
12471 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12472 wxString *arg2 = 0 ;
12473 bool result;
12474 void *argp1 = 0 ;
12475 int res1 = 0 ;
12476 bool temp2 = false ;
12477 PyObject * obj0 = 0 ;
12478 PyObject * obj1 = 0 ;
12479 char * kwnames[] = {
12480 (char *) "self",(char *) "s", NULL
12481 };
12482
12483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
12484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_FromString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12487 }
12488 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12489 {
12490 arg2 = wxString_in_helper(obj1);
12491 if (arg2 == NULL) SWIG_fail;
12492 temp2 = true;
12493 }
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (bool)(arg1)->FromString((wxString const &)*arg2);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 {
12501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12502 }
12503 {
12504 if (temp2)
12505 delete arg2;
12506 }
12507 return resultobj;
12508 fail:
12509 {
12510 if (temp2)
12511 delete arg2;
12512 }
12513 return NULL;
12514 }
12515
12516
12517 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518 PyObject *resultobj = 0;
12519 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12520 wxString result;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 PyObject *swig_obj[1] ;
12524
12525 if (!args) SWIG_fail;
12526 swig_obj[0] = args;
12527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12528 if (!SWIG_IsOK(res1)) {
12529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_ToString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const *""'");
12530 }
12531 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12532 {
12533 PyThreadState* __tstate = wxPyBeginAllowThreads();
12534 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 #if wxUSE_UNICODE
12540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12541 #else
12542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12543 #endif
12544 }
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 SWIGINTERN PyObject *NativeEncodingInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552 PyObject *obj;
12553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12554 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeEncodingInfo, SWIG_NewClientData(obj));
12555 return SWIG_Py_Void();
12556 }
12557
12558 SWIGINTERN PyObject *NativeEncodingInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12559 return SWIG_Python_InitShadowInstance(args);
12560 }
12561
12562 SWIGINTERN PyObject *_wrap_GetNativeFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxFontEncoding arg1 ;
12565 wxNativeEncodingInfo *result = 0 ;
12566 int val1 ;
12567 int ecode1 = 0 ;
12568 PyObject * obj0 = 0 ;
12569 char * kwnames[] = {
12570 (char *) "encoding", NULL
12571 };
12572
12573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) SWIG_fail;
12574 ecode1 = SWIG_AsVal_int(obj0, &val1);
12575 if (!SWIG_IsOK(ecode1)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetNativeFontEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12577 }
12578 arg1 = static_cast< wxFontEncoding >(val1);
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding(arg1);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_TestFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12593 PyObject *resultobj = 0;
12594 wxNativeEncodingInfo *arg1 = 0 ;
12595 bool result;
12596 void *argp1 = 0 ;
12597 int res1 = 0 ;
12598 PyObject * obj0 = 0 ;
12599 char * kwnames[] = {
12600 (char *) "info", NULL
12601 };
12602
12603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) SWIG_fail;
12604 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0);
12605 if (!SWIG_IsOK(res1)) {
12606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
12607 }
12608 if (!argp1) {
12609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
12610 }
12611 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
12615 wxPyEndAllowThreads(__tstate);
12616 if (PyErr_Occurred()) SWIG_fail;
12617 }
12618 {
12619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12620 }
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_new_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 PyObject *resultobj = 0;
12629 wxFontMapper *result = 0 ;
12630
12631 if (!SWIG_Python_UnpackTuple(args,"new_FontMapper",0,0,0)) SWIG_fail;
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (wxFontMapper *)new wxFontMapper();
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, SWIG_POINTER_NEW | 0 );
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_delete_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12646 PyObject *resultobj = 0;
12647 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
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_wxFontMapper, SWIG_POINTER_DISOWN | 0 );
12655 if (!SWIG_IsOK(res1)) {
12656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontMapper" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12657 }
12658 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 delete arg1;
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_Py_Void();
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 SWIGINTERN PyObject *_wrap_FontMapper_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 PyObject *resultobj = 0;
12675 wxFontMapper *result = 0 ;
12676
12677 if (!SWIG_Python_UnpackTuple(args,"FontMapper_Get",0,0,0)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (wxFontMapper *)wxFontMapper::Get();
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
12685 return resultobj;
12686 fail:
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_FontMapper_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12692 PyObject *resultobj = 0;
12693 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12694 wxFontMapper *result = 0 ;
12695 void *argp1 = 0 ;
12696 int res1 = 0 ;
12697 PyObject * obj0 = 0 ;
12698 char * kwnames[] = {
12699 (char *) "mapper", NULL
12700 };
12701
12702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) SWIG_fail;
12703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12704 if (!SWIG_IsOK(res1)) {
12705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_Set" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12706 }
12707 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (wxFontMapper *)wxFontMapper::Set(arg1);
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12722 PyObject *resultobj = 0;
12723 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12724 wxString *arg2 = 0 ;
12725 bool arg3 = (bool) true ;
12726 wxFontEncoding result;
12727 void *argp1 = 0 ;
12728 int res1 = 0 ;
12729 bool temp2 = false ;
12730 bool val3 ;
12731 int ecode3 = 0 ;
12732 PyObject * obj0 = 0 ;
12733 PyObject * obj1 = 0 ;
12734 PyObject * obj2 = 0 ;
12735 char * kwnames[] = {
12736 (char *) "self",(char *) "charset",(char *) "interactive", NULL
12737 };
12738
12739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12743 }
12744 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12745 {
12746 arg2 = wxString_in_helper(obj1);
12747 if (arg2 == NULL) SWIG_fail;
12748 temp2 = true;
12749 }
12750 if (obj2) {
12751 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12752 if (!SWIG_IsOK(ecode3)) {
12753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "3"" of type '" "bool""'");
12754 }
12755 arg3 = static_cast< bool >(val3);
12756 }
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 resultobj = SWIG_From_int(static_cast< int >(result));
12764 {
12765 if (temp2)
12766 delete arg2;
12767 }
12768 return resultobj;
12769 fail:
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 size_t result;
12781
12782 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetSupportedEncodingsCount",0,0,0)) SWIG_fail;
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_FontMapper_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj = 0;
12798 size_t arg1 ;
12799 wxFontEncoding result;
12800 size_t val1 ;
12801 int ecode1 = 0 ;
12802 PyObject * obj0 = 0 ;
12803 char * kwnames[] = {
12804 (char *) "n", NULL
12805 };
12806
12807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) SWIG_fail;
12808 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
12809 if (!SWIG_IsOK(ecode1)) {
12810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncoding" "', expected argument " "1"" of type '" "size_t""'");
12811 }
12812 arg1 = static_cast< size_t >(val1);
12813 {
12814 PyThreadState* __tstate = wxPyBeginAllowThreads();
12815 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
12816 wxPyEndAllowThreads(__tstate);
12817 if (PyErr_Occurred()) SWIG_fail;
12818 }
12819 resultobj = SWIG_From_int(static_cast< int >(result));
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12827 PyObject *resultobj = 0;
12828 wxFontEncoding arg1 ;
12829 wxString result;
12830 int val1 ;
12831 int ecode1 = 0 ;
12832 PyObject * obj0 = 0 ;
12833 char * kwnames[] = {
12834 (char *) "encoding", NULL
12835 };
12836
12837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) SWIG_fail;
12838 ecode1 = SWIG_AsVal_int(obj0, &val1);
12839 if (!SWIG_IsOK(ecode1)) {
12840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingName" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12841 }
12842 arg1 = static_cast< wxFontEncoding >(val1);
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = wxFontMapper::GetEncodingName(arg1);
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 #if wxUSE_UNICODE
12851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12852 #else
12853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12854 #endif
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12863 PyObject *resultobj = 0;
12864 wxFontEncoding arg1 ;
12865 wxString result;
12866 int val1 ;
12867 int ecode1 = 0 ;
12868 PyObject * obj0 = 0 ;
12869 char * kwnames[] = {
12870 (char *) "encoding", NULL
12871 };
12872
12873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) SWIG_fail;
12874 ecode1 = SWIG_AsVal_int(obj0, &val1);
12875 if (!SWIG_IsOK(ecode1)) {
12876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingDescription" "', expected argument " "1"" of type '" "wxFontEncoding""'");
12877 }
12878 arg1 = static_cast< wxFontEncoding >(val1);
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 result = wxFontMapper::GetEncodingDescription(arg1);
12882 wxPyEndAllowThreads(__tstate);
12883 if (PyErr_Occurred()) SWIG_fail;
12884 }
12885 {
12886 #if wxUSE_UNICODE
12887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12888 #else
12889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12890 #endif
12891 }
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj = 0;
12900 wxString *arg1 = 0 ;
12901 wxFontEncoding result;
12902 bool temp1 = false ;
12903 PyObject * obj0 = 0 ;
12904 char * kwnames[] = {
12905 (char *) "name", NULL
12906 };
12907
12908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) SWIG_fail;
12909 {
12910 arg1 = wxString_in_helper(obj0);
12911 if (arg1 == NULL) SWIG_fail;
12912 temp1 = true;
12913 }
12914 {
12915 PyThreadState* __tstate = wxPyBeginAllowThreads();
12916 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
12917 wxPyEndAllowThreads(__tstate);
12918 if (PyErr_Occurred()) SWIG_fail;
12919 }
12920 resultobj = SWIG_From_int(static_cast< int >(result));
12921 {
12922 if (temp1)
12923 delete arg1;
12924 }
12925 return resultobj;
12926 fail:
12927 {
12928 if (temp1)
12929 delete arg1;
12930 }
12931 return NULL;
12932 }
12933
12934
12935 SWIGINTERN PyObject *_wrap_FontMapper_SetConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj = 0;
12937 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
12938 wxString *arg2 = 0 ;
12939 void *argp1 = 0 ;
12940 int res1 = 0 ;
12941 bool temp2 = false ;
12942 PyObject * obj0 = 0 ;
12943 PyObject * obj1 = 0 ;
12944 char * kwnames[] = {
12945 (char *) "self",(char *) "prefix", NULL
12946 };
12947
12948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) SWIG_fail;
12949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
12950 if (!SWIG_IsOK(res1)) {
12951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetConfigPath" "', expected argument " "1"" of type '" "wxFontMapper *""'");
12952 }
12953 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
12954 {
12955 arg2 = wxString_in_helper(obj1);
12956 if (arg2 == NULL) SWIG_fail;
12957 temp2 = true;
12958 }
12959 {
12960 PyThreadState* __tstate = wxPyBeginAllowThreads();
12961 (arg1)->SetConfigPath((wxString const &)*arg2);
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 resultobj = SWIG_Py_Void();
12966 {
12967 if (temp2)
12968 delete arg2;
12969 }
12970 return resultobj;
12971 fail:
12972 {
12973 if (temp2)
12974 delete arg2;
12975 }
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *resultobj = 0;
12982 wxString result;
12983
12984 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetDefaultConfigPath",0,0,0)) SWIG_fail;
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = wxFontMapper::GetDefaultConfigPath();
12988 wxPyEndAllowThreads(__tstate);
12989 if (PyErr_Occurred()) SWIG_fail;
12990 }
12991 {
12992 #if wxUSE_UNICODE
12993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12994 #else
12995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12996 #endif
12997 }
12998 return resultobj;
12999 fail:
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = 0;
13006 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13007 wxFontEncoding arg2 ;
13008 wxString const &arg3_defvalue = wxPyEmptyString ;
13009 wxString *arg3 = (wxString *) &arg3_defvalue ;
13010 bool arg4 = (bool) true ;
13011 PyObject *result = 0 ;
13012 void *argp1 = 0 ;
13013 int res1 = 0 ;
13014 int val2 ;
13015 int ecode2 = 0 ;
13016 bool temp3 = false ;
13017 bool val4 ;
13018 int ecode4 = 0 ;
13019 PyObject * obj0 = 0 ;
13020 PyObject * obj1 = 0 ;
13021 PyObject * obj2 = 0 ;
13022 PyObject * obj3 = 0 ;
13023 char * kwnames[] = {
13024 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
13025 };
13026
13027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13029 if (!SWIG_IsOK(res1)) {
13030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13031 }
13032 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13033 ecode2 = SWIG_AsVal_int(obj1, &val2);
13034 if (!SWIG_IsOK(ecode2)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13036 }
13037 arg2 = static_cast< wxFontEncoding >(val2);
13038 if (obj2) {
13039 {
13040 arg3 = wxString_in_helper(obj2);
13041 if (arg3 == NULL) SWIG_fail;
13042 temp3 = true;
13043 }
13044 }
13045 if (obj3) {
13046 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13047 if (!SWIG_IsOK(ecode4)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "4"" of type '" "bool""'");
13049 }
13050 arg4 = static_cast< bool >(val4);
13051 }
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,arg2,(wxString const &)*arg3,arg4);
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 resultobj = result;
13059 {
13060 if (temp3)
13061 delete arg3;
13062 }
13063 return resultobj;
13064 fail:
13065 {
13066 if (temp3)
13067 delete arg3;
13068 }
13069 return NULL;
13070 }
13071
13072
13073 SWIGINTERN PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj = 0;
13075 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13076 wxFontEncoding arg2 ;
13077 wxString const &arg3_defvalue = wxPyEmptyString ;
13078 wxString *arg3 = (wxString *) &arg3_defvalue ;
13079 bool result;
13080 void *argp1 = 0 ;
13081 int res1 = 0 ;
13082 int val2 ;
13083 int ecode2 = 0 ;
13084 bool temp3 = false ;
13085 PyObject * obj0 = 0 ;
13086 PyObject * obj1 = 0 ;
13087 PyObject * obj2 = 0 ;
13088 char * kwnames[] = {
13089 (char *) "self",(char *) "encoding",(char *) "facename", NULL
13090 };
13091
13092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13096 }
13097 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13098 ecode2 = SWIG_AsVal_int(obj1, &val2);
13099 if (!SWIG_IsOK(ecode2)) {
13100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13101 }
13102 arg2 = static_cast< wxFontEncoding >(val2);
13103 if (obj2) {
13104 {
13105 arg3 = wxString_in_helper(obj2);
13106 if (arg3 == NULL) SWIG_fail;
13107 temp3 = true;
13108 }
13109 }
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 result = (bool)(arg1)->IsEncodingAvailable(arg2,(wxString const &)*arg3);
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 {
13117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13118 }
13119 {
13120 if (temp3)
13121 delete arg3;
13122 }
13123 return resultobj;
13124 fail:
13125 {
13126 if (temp3)
13127 delete arg3;
13128 }
13129 return NULL;
13130 }
13131
13132
13133 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13134 PyObject *resultobj = 0;
13135 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13136 wxWindow *arg2 = (wxWindow *) 0 ;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 void *argp2 = 0 ;
13140 int res2 = 0 ;
13141 PyObject * obj0 = 0 ;
13142 PyObject * obj1 = 0 ;
13143 char * kwnames[] = {
13144 (char *) "self",(char *) "parent", NULL
13145 };
13146
13147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) SWIG_fail;
13148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13149 if (!SWIG_IsOK(res1)) {
13150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogParent" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13151 }
13152 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
13154 if (!SWIG_IsOK(res2)) {
13155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontMapper_SetDialogParent" "', expected argument " "2"" of type '" "wxWindow *""'");
13156 }
13157 arg2 = reinterpret_cast< wxWindow * >(argp2);
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 (arg1)->SetDialogParent(arg2);
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 resultobj = SWIG_Py_Void();
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13172 PyObject *resultobj = 0;
13173 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13174 wxString *arg2 = 0 ;
13175 void *argp1 = 0 ;
13176 int res1 = 0 ;
13177 bool temp2 = false ;
13178 PyObject * obj0 = 0 ;
13179 PyObject * obj1 = 0 ;
13180 char * kwnames[] = {
13181 (char *) "self",(char *) "title", NULL
13182 };
13183
13184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) SWIG_fail;
13185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13186 if (!SWIG_IsOK(res1)) {
13187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogTitle" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13188 }
13189 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13190 {
13191 arg2 = wxString_in_helper(obj1);
13192 if (arg2 == NULL) SWIG_fail;
13193 temp2 = true;
13194 }
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 (arg1)->SetDialogTitle((wxString const &)*arg2);
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 resultobj = SWIG_Py_Void();
13202 {
13203 if (temp2)
13204 delete arg2;
13205 }
13206 return resultobj;
13207 fail:
13208 {
13209 if (temp2)
13210 delete arg2;
13211 }
13212 return NULL;
13213 }
13214
13215
13216 SWIGINTERN PyObject *FontMapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13217 PyObject *obj;
13218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13219 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontMapper, SWIG_NewClientData(obj));
13220 return SWIG_Py_Void();
13221 }
13222
13223 SWIGINTERN PyObject *FontMapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13224 return SWIG_Python_InitShadowInstance(args);
13225 }
13226
13227 SWIGINTERN PyObject *_wrap_new_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj = 0;
13229 int arg1 ;
13230 int arg2 ;
13231 int arg3 ;
13232 int arg4 ;
13233 bool arg5 = (bool) false ;
13234 wxString const &arg6_defvalue = wxPyEmptyString ;
13235 wxString *arg6 = (wxString *) &arg6_defvalue ;
13236 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13237 wxFont *result = 0 ;
13238 int val1 ;
13239 int ecode1 = 0 ;
13240 int val2 ;
13241 int ecode2 = 0 ;
13242 int val3 ;
13243 int ecode3 = 0 ;
13244 int val4 ;
13245 int ecode4 = 0 ;
13246 bool val5 ;
13247 int ecode5 = 0 ;
13248 bool temp6 = false ;
13249 int val7 ;
13250 int ecode7 = 0 ;
13251 PyObject * obj0 = 0 ;
13252 PyObject * obj1 = 0 ;
13253 PyObject * obj2 = 0 ;
13254 PyObject * obj3 = 0 ;
13255 PyObject * obj4 = 0 ;
13256 PyObject * obj5 = 0 ;
13257 PyObject * obj6 = 0 ;
13258 char * kwnames[] = {
13259 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
13260 };
13261
13262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13263 ecode1 = SWIG_AsVal_int(obj0, &val1);
13264 if (!SWIG_IsOK(ecode1)) {
13265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Font" "', expected argument " "1"" of type '" "int""'");
13266 }
13267 arg1 = static_cast< int >(val1);
13268 ecode2 = SWIG_AsVal_int(obj1, &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Font" "', expected argument " "2"" of type '" "int""'");
13271 }
13272 arg2 = static_cast< int >(val2);
13273 ecode3 = SWIG_AsVal_int(obj2, &val3);
13274 if (!SWIG_IsOK(ecode3)) {
13275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Font" "', expected argument " "3"" of type '" "int""'");
13276 }
13277 arg3 = static_cast< int >(val3);
13278 ecode4 = SWIG_AsVal_int(obj3, &val4);
13279 if (!SWIG_IsOK(ecode4)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Font" "', expected argument " "4"" of type '" "int""'");
13281 }
13282 arg4 = static_cast< int >(val4);
13283 if (obj4) {
13284 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13285 if (!SWIG_IsOK(ecode5)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Font" "', expected argument " "5"" of type '" "bool""'");
13287 }
13288 arg5 = static_cast< bool >(val5);
13289 }
13290 if (obj5) {
13291 {
13292 arg6 = wxString_in_helper(obj5);
13293 if (arg6 == NULL) SWIG_fail;
13294 temp6 = true;
13295 }
13296 }
13297 if (obj6) {
13298 ecode7 = SWIG_AsVal_int(obj6, &val7);
13299 if (!SWIG_IsOK(ecode7)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Font" "', expected argument " "7"" of type '" "wxFontEncoding""'");
13301 }
13302 arg7 = static_cast< wxFontEncoding >(val7);
13303 }
13304 {
13305 if (!wxPyCheckForApp()) SWIG_fail;
13306 PyThreadState* __tstate = wxPyBeginAllowThreads();
13307 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_NEW | 0 );
13312 {
13313 if (temp6)
13314 delete arg6;
13315 }
13316 return resultobj;
13317 fail:
13318 {
13319 if (temp6)
13320 delete arg6;
13321 }
13322 return NULL;
13323 }
13324
13325
13326 SWIGINTERN PyObject *_wrap_delete_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13327 PyObject *resultobj = 0;
13328 wxFont *arg1 = (wxFont *) 0 ;
13329 void *argp1 = 0 ;
13330 int res1 = 0 ;
13331 PyObject *swig_obj[1] ;
13332
13333 if (!args) SWIG_fail;
13334 swig_obj[0] = args;
13335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, SWIG_POINTER_DISOWN | 0 );
13336 if (!SWIG_IsOK(res1)) {
13337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Font" "', expected argument " "1"" of type '" "wxFont *""'");
13338 }
13339 arg1 = reinterpret_cast< wxFont * >(argp1);
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 delete arg1;
13343
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 resultobj = SWIG_Py_Void();
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj = 0;
13356 wxNativeFontInfo *arg1 = 0 ;
13357 wxFont *result = 0 ;
13358 void *argp1 = 0 ;
13359 int res1 = 0 ;
13360 PyObject * obj0 = 0 ;
13361 char * kwnames[] = {
13362 (char *) "info", NULL
13363 };
13364
13365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) SWIG_fail;
13366 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
13369 }
13370 if (!argp1) {
13371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
13372 }
13373 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
13374 {
13375 if (!wxPyCheckForApp()) SWIG_fail;
13376 PyThreadState* __tstate = wxPyBeginAllowThreads();
13377 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
13378 wxPyEndAllowThreads(__tstate);
13379 if (PyErr_Occurred()) SWIG_fail;
13380 }
13381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13382 return resultobj;
13383 fail:
13384 return NULL;
13385 }
13386
13387
13388 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfoString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13389 PyObject *resultobj = 0;
13390 wxString *arg1 = 0 ;
13391 wxFont *result = 0 ;
13392 bool temp1 = false ;
13393 PyObject * obj0 = 0 ;
13394 char * kwnames[] = {
13395 (char *) "info", NULL
13396 };
13397
13398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) SWIG_fail;
13399 {
13400 arg1 = wxString_in_helper(obj0);
13401 if (arg1 == NULL) SWIG_fail;
13402 temp1 = true;
13403 }
13404 {
13405 if (!wxPyCheckForApp()) SWIG_fail;
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (wxFont *)new_wxFont((wxString const &)*arg1);
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13412 {
13413 if (temp1)
13414 delete arg1;
13415 }
13416 return resultobj;
13417 fail:
13418 {
13419 if (temp1)
13420 delete arg1;
13421 }
13422 return NULL;
13423 }
13424
13425
13426 SWIGINTERN PyObject *_wrap_new_FFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj = 0;
13428 int arg1 ;
13429 wxFontFamily arg2 ;
13430 int arg3 = (int) wxFONTFLAG_DEFAULT ;
13431 wxString const &arg4_defvalue = wxPyEmptyString ;
13432 wxString *arg4 = (wxString *) &arg4_defvalue ;
13433 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13434 wxFont *result = 0 ;
13435 int val1 ;
13436 int ecode1 = 0 ;
13437 int val2 ;
13438 int ecode2 = 0 ;
13439 int val3 ;
13440 int ecode3 = 0 ;
13441 bool temp4 = false ;
13442 int val5 ;
13443 int ecode5 = 0 ;
13444 PyObject * obj0 = 0 ;
13445 PyObject * obj1 = 0 ;
13446 PyObject * obj2 = 0 ;
13447 PyObject * obj3 = 0 ;
13448 PyObject * obj4 = 0 ;
13449 char * kwnames[] = {
13450 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
13451 };
13452
13453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13454 ecode1 = SWIG_AsVal_int(obj0, &val1);
13455 if (!SWIG_IsOK(ecode1)) {
13456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FFont" "', expected argument " "1"" of type '" "int""'");
13457 }
13458 arg1 = static_cast< int >(val1);
13459 ecode2 = SWIG_AsVal_int(obj1, &val2);
13460 if (!SWIG_IsOK(ecode2)) {
13461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFont" "', expected argument " "2"" of type '" "wxFontFamily""'");
13462 }
13463 arg2 = static_cast< wxFontFamily >(val2);
13464 if (obj2) {
13465 ecode3 = SWIG_AsVal_int(obj2, &val3);
13466 if (!SWIG_IsOK(ecode3)) {
13467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFont" "', expected argument " "3"" of type '" "int""'");
13468 }
13469 arg3 = static_cast< int >(val3);
13470 }
13471 if (obj3) {
13472 {
13473 arg4 = wxString_in_helper(obj3);
13474 if (arg4 == NULL) SWIG_fail;
13475 temp4 = true;
13476 }
13477 }
13478 if (obj4) {
13479 ecode5 = SWIG_AsVal_int(obj4, &val5);
13480 if (!SWIG_IsOK(ecode5)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFont" "', expected argument " "5"" of type '" "wxFontEncoding""'");
13482 }
13483 arg5 = static_cast< wxFontEncoding >(val5);
13484 }
13485 {
13486 if (!wxPyCheckForApp()) SWIG_fail;
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = (wxFont *)new_wxFont(arg1,arg2,arg3,(wxString const &)*arg4,arg5);
13489 wxPyEndAllowThreads(__tstate);
13490 if (PyErr_Occurred()) SWIG_fail;
13491 }
13492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13493 {
13494 if (temp4)
13495 delete arg4;
13496 }
13497 return resultobj;
13498 fail:
13499 {
13500 if (temp4)
13501 delete arg4;
13502 }
13503 return NULL;
13504 }
13505
13506
13507 SWIGINTERN PyObject *_wrap_new_FontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj = 0;
13509 wxSize *arg1 = 0 ;
13510 int arg2 ;
13511 int arg3 ;
13512 int arg4 ;
13513 bool arg5 = (bool) false ;
13514 wxString const &arg6_defvalue = wxEmptyString ;
13515 wxString *arg6 = (wxString *) &arg6_defvalue ;
13516 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13517 wxFont *result = 0 ;
13518 wxSize temp1 ;
13519 int val2 ;
13520 int ecode2 = 0 ;
13521 int val3 ;
13522 int ecode3 = 0 ;
13523 int val4 ;
13524 int ecode4 = 0 ;
13525 bool val5 ;
13526 int ecode5 = 0 ;
13527 bool temp6 = false ;
13528 int val7 ;
13529 int ecode7 = 0 ;
13530 PyObject * obj0 = 0 ;
13531 PyObject * obj1 = 0 ;
13532 PyObject * obj2 = 0 ;
13533 PyObject * obj3 = 0 ;
13534 PyObject * obj4 = 0 ;
13535 PyObject * obj5 = 0 ;
13536 PyObject * obj6 = 0 ;
13537 char * kwnames[] = {
13538 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
13539 };
13540
13541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13542 {
13543 arg1 = &temp1;
13544 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
13545 }
13546 ecode2 = SWIG_AsVal_int(obj1, &val2);
13547 if (!SWIG_IsOK(ecode2)) {
13548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontFromPixelSize" "', expected argument " "2"" of type '" "int""'");
13549 }
13550 arg2 = static_cast< int >(val2);
13551 ecode3 = SWIG_AsVal_int(obj2, &val3);
13552 if (!SWIG_IsOK(ecode3)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
13554 }
13555 arg3 = static_cast< int >(val3);
13556 ecode4 = SWIG_AsVal_int(obj3, &val4);
13557 if (!SWIG_IsOK(ecode4)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FontFromPixelSize" "', expected argument " "4"" of type '" "int""'");
13559 }
13560 arg4 = static_cast< int >(val4);
13561 if (obj4) {
13562 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13563 if (!SWIG_IsOK(ecode5)) {
13564 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FontFromPixelSize" "', expected argument " "5"" of type '" "bool""'");
13565 }
13566 arg5 = static_cast< bool >(val5);
13567 }
13568 if (obj5) {
13569 {
13570 arg6 = wxString_in_helper(obj5);
13571 if (arg6 == NULL) SWIG_fail;
13572 temp6 = true;
13573 }
13574 }
13575 if (obj6) {
13576 ecode7 = SWIG_AsVal_int(obj6, &val7);
13577 if (!SWIG_IsOK(ecode7)) {
13578 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FontFromPixelSize" "', expected argument " "7"" of type '" "wxFontEncoding""'");
13579 }
13580 arg7 = static_cast< wxFontEncoding >(val7);
13581 }
13582 {
13583 if (!wxPyCheckForApp()) SWIG_fail;
13584 PyThreadState* __tstate = wxPyBeginAllowThreads();
13585 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
13586 wxPyEndAllowThreads(__tstate);
13587 if (PyErr_Occurred()) SWIG_fail;
13588 }
13589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13590 {
13591 if (temp6)
13592 delete arg6;
13593 }
13594 return resultobj;
13595 fail:
13596 {
13597 if (temp6)
13598 delete arg6;
13599 }
13600 return NULL;
13601 }
13602
13603
13604 SWIGINTERN PyObject *_wrap_new_FFontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj = 0;
13606 wxSize *arg1 = 0 ;
13607 wxFontFamily arg2 ;
13608 int arg3 = (int) wxFONTFLAG_DEFAULT ;
13609 wxString const &arg4_defvalue = wxEmptyString ;
13610 wxString *arg4 = (wxString *) &arg4_defvalue ;
13611 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13612 wxFont *result = 0 ;
13613 wxSize temp1 ;
13614 int val2 ;
13615 int ecode2 = 0 ;
13616 int val3 ;
13617 int ecode3 = 0 ;
13618 bool temp4 = false ;
13619 int val5 ;
13620 int ecode5 = 0 ;
13621 PyObject * obj0 = 0 ;
13622 PyObject * obj1 = 0 ;
13623 PyObject * obj2 = 0 ;
13624 PyObject * obj3 = 0 ;
13625 PyObject * obj4 = 0 ;
13626 char * kwnames[] = {
13627 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
13628 };
13629
13630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13631 {
13632 arg1 = &temp1;
13633 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
13634 }
13635 ecode2 = SWIG_AsVal_int(obj1, &val2);
13636 if (!SWIG_IsOK(ecode2)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFontFromPixelSize" "', expected argument " "2"" of type '" "wxFontFamily""'");
13638 }
13639 arg2 = static_cast< wxFontFamily >(val2);
13640 if (obj2) {
13641 ecode3 = SWIG_AsVal_int(obj2, &val3);
13642 if (!SWIG_IsOK(ecode3)) {
13643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
13644 }
13645 arg3 = static_cast< int >(val3);
13646 }
13647 if (obj3) {
13648 {
13649 arg4 = wxString_in_helper(obj3);
13650 if (arg4 == NULL) SWIG_fail;
13651 temp4 = true;
13652 }
13653 }
13654 if (obj4) {
13655 ecode5 = SWIG_AsVal_int(obj4, &val5);
13656 if (!SWIG_IsOK(ecode5)) {
13657 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFontFromPixelSize" "', expected argument " "5"" of type '" "wxFontEncoding""'");
13658 }
13659 arg5 = static_cast< wxFontEncoding >(val5);
13660 }
13661 {
13662 if (!wxPyCheckForApp()) SWIG_fail;
13663 PyThreadState* __tstate = wxPyBeginAllowThreads();
13664 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,(wxString const &)*arg4,arg5);
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13669 {
13670 if (temp4)
13671 delete arg4;
13672 }
13673 return resultobj;
13674 fail:
13675 {
13676 if (temp4)
13677 delete arg4;
13678 }
13679 return NULL;
13680 }
13681
13682
13683 SWIGINTERN PyObject *_wrap_Font_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13684 PyObject *resultobj = 0;
13685 wxFont *arg1 = (wxFont *) 0 ;
13686 bool result;
13687 void *argp1 = 0 ;
13688 int res1 = 0 ;
13689 PyObject *swig_obj[1] ;
13690
13691 if (!args) SWIG_fail;
13692 swig_obj[0] = args;
13693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13694 if (!SWIG_IsOK(res1)) {
13695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_Ok" "', expected argument " "1"" of type '" "wxFont const *""'");
13696 }
13697 arg1 = reinterpret_cast< wxFont * >(argp1);
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 result = (bool)((wxFont const *)arg1)->Ok();
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 {
13705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13706 }
13707 return resultobj;
13708 fail:
13709 return NULL;
13710 }
13711
13712
13713 SWIGINTERN PyObject *_wrap_Font___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj = 0;
13715 wxFont *arg1 = (wxFont *) 0 ;
13716 wxFont *arg2 = (wxFont *) 0 ;
13717 bool result;
13718 void *argp1 = 0 ;
13719 int res1 = 0 ;
13720 void *argp2 = 0 ;
13721 int res2 = 0 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 char * kwnames[] = {
13725 (char *) "self",(char *) "other", NULL
13726 };
13727
13728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
13729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13730 if (!SWIG_IsOK(res1)) {
13731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___eq__" "', expected argument " "1"" of type '" "wxFont *""'");
13732 }
13733 arg1 = reinterpret_cast< wxFont * >(argp1);
13734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
13735 if (!SWIG_IsOK(res2)) {
13736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___eq__" "', expected argument " "2"" of type '" "wxFont const *""'");
13737 }
13738 arg2 = reinterpret_cast< wxFont * >(argp2);
13739 {
13740 PyThreadState* __tstate = wxPyBeginAllowThreads();
13741 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 {
13746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13747 }
13748 return resultobj;
13749 fail:
13750 return NULL;
13751 }
13752
13753
13754 SWIGINTERN PyObject *_wrap_Font___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13755 PyObject *resultobj = 0;
13756 wxFont *arg1 = (wxFont *) 0 ;
13757 wxFont *arg2 = (wxFont *) 0 ;
13758 bool result;
13759 void *argp1 = 0 ;
13760 int res1 = 0 ;
13761 void *argp2 = 0 ;
13762 int res2 = 0 ;
13763 PyObject * obj0 = 0 ;
13764 PyObject * obj1 = 0 ;
13765 char * kwnames[] = {
13766 (char *) "self",(char *) "other", NULL
13767 };
13768
13769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
13770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13771 if (!SWIG_IsOK(res1)) {
13772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___ne__" "', expected argument " "1"" of type '" "wxFont *""'");
13773 }
13774 arg1 = reinterpret_cast< wxFont * >(argp1);
13775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
13776 if (!SWIG_IsOK(res2)) {
13777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___ne__" "', expected argument " "2"" of type '" "wxFont const *""'");
13778 }
13779 arg2 = reinterpret_cast< wxFont * >(argp2);
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 {
13787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13788 }
13789 return resultobj;
13790 fail:
13791 return NULL;
13792 }
13793
13794
13795 SWIGINTERN PyObject *_wrap_Font_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13796 PyObject *resultobj = 0;
13797 wxFont *arg1 = (wxFont *) 0 ;
13798 int result;
13799 void *argp1 = 0 ;
13800 int res1 = 0 ;
13801 PyObject *swig_obj[1] ;
13802
13803 if (!args) SWIG_fail;
13804 swig_obj[0] = args;
13805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13806 if (!SWIG_IsOK(res1)) {
13807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPointSize" "', expected argument " "1"" of type '" "wxFont const *""'");
13808 }
13809 arg1 = reinterpret_cast< wxFont * >(argp1);
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (int)((wxFont const *)arg1)->GetPointSize();
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_From_int(static_cast< int >(result));
13817 return resultobj;
13818 fail:
13819 return NULL;
13820 }
13821
13822
13823 SWIGINTERN PyObject *_wrap_Font_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13824 PyObject *resultobj = 0;
13825 wxFont *arg1 = (wxFont *) 0 ;
13826 wxSize result;
13827 void *argp1 = 0 ;
13828 int res1 = 0 ;
13829 PyObject *swig_obj[1] ;
13830
13831 if (!args) SWIG_fail;
13832 swig_obj[0] = args;
13833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13834 if (!SWIG_IsOK(res1)) {
13835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPixelSize" "', expected argument " "1"" of type '" "wxFont const *""'");
13836 }
13837 arg1 = reinterpret_cast< wxFont * >(argp1);
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 result = ((wxFont const *)arg1)->GetPixelSize();
13841 wxPyEndAllowThreads(__tstate);
13842 if (PyErr_Occurred()) SWIG_fail;
13843 }
13844 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
13845 return resultobj;
13846 fail:
13847 return NULL;
13848 }
13849
13850
13851 SWIGINTERN PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13852 PyObject *resultobj = 0;
13853 wxFont *arg1 = (wxFont *) 0 ;
13854 bool result;
13855 void *argp1 = 0 ;
13856 int res1 = 0 ;
13857 PyObject *swig_obj[1] ;
13858
13859 if (!args) SWIG_fail;
13860 swig_obj[0] = args;
13861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsUsingSizeInPixels" "', expected argument " "1"" of type '" "wxFont const *""'");
13864 }
13865 arg1 = reinterpret_cast< wxFont * >(argp1);
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 {
13873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13874 }
13875 return resultobj;
13876 fail:
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_Font_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13882 PyObject *resultobj = 0;
13883 wxFont *arg1 = (wxFont *) 0 ;
13884 int result;
13885 void *argp1 = 0 ;
13886 int res1 = 0 ;
13887 PyObject *swig_obj[1] ;
13888
13889 if (!args) SWIG_fail;
13890 swig_obj[0] = args;
13891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13892 if (!SWIG_IsOK(res1)) {
13893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamily" "', expected argument " "1"" of type '" "wxFont const *""'");
13894 }
13895 arg1 = reinterpret_cast< wxFont * >(argp1);
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 result = (int)((wxFont const *)arg1)->GetFamily();
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 resultobj = SWIG_From_int(static_cast< int >(result));
13903 return resultobj;
13904 fail:
13905 return NULL;
13906 }
13907
13908
13909 SWIGINTERN PyObject *_wrap_Font_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13910 PyObject *resultobj = 0;
13911 wxFont *arg1 = (wxFont *) 0 ;
13912 int result;
13913 void *argp1 = 0 ;
13914 int res1 = 0 ;
13915 PyObject *swig_obj[1] ;
13916
13917 if (!args) SWIG_fail;
13918 swig_obj[0] = args;
13919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13920 if (!SWIG_IsOK(res1)) {
13921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyle" "', expected argument " "1"" of type '" "wxFont const *""'");
13922 }
13923 arg1 = reinterpret_cast< wxFont * >(argp1);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (int)((wxFont const *)arg1)->GetStyle();
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_int(static_cast< int >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Font_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13938 PyObject *resultobj = 0;
13939 wxFont *arg1 = (wxFont *) 0 ;
13940 int result;
13941 void *argp1 = 0 ;
13942 int res1 = 0 ;
13943 PyObject *swig_obj[1] ;
13944
13945 if (!args) SWIG_fail;
13946 swig_obj[0] = args;
13947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13948 if (!SWIG_IsOK(res1)) {
13949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeight" "', expected argument " "1"" of type '" "wxFont const *""'");
13950 }
13951 arg1 = reinterpret_cast< wxFont * >(argp1);
13952 {
13953 PyThreadState* __tstate = wxPyBeginAllowThreads();
13954 result = (int)((wxFont const *)arg1)->GetWeight();
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 resultobj = SWIG_From_int(static_cast< int >(result));
13959 return resultobj;
13960 fail:
13961 return NULL;
13962 }
13963
13964
13965 SWIGINTERN PyObject *_wrap_Font_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13966 PyObject *resultobj = 0;
13967 wxFont *arg1 = (wxFont *) 0 ;
13968 bool result;
13969 void *argp1 = 0 ;
13970 int res1 = 0 ;
13971 PyObject *swig_obj[1] ;
13972
13973 if (!args) SWIG_fail;
13974 swig_obj[0] = args;
13975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
13976 if (!SWIG_IsOK(res1)) {
13977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetUnderlined" "', expected argument " "1"" of type '" "wxFont const *""'");
13978 }
13979 arg1 = reinterpret_cast< wxFont * >(argp1);
13980 {
13981 PyThreadState* __tstate = wxPyBeginAllowThreads();
13982 result = (bool)((wxFont const *)arg1)->GetUnderlined();
13983 wxPyEndAllowThreads(__tstate);
13984 if (PyErr_Occurred()) SWIG_fail;
13985 }
13986 {
13987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13988 }
13989 return resultobj;
13990 fail:
13991 return NULL;
13992 }
13993
13994
13995 SWIGINTERN PyObject *_wrap_Font_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13996 PyObject *resultobj = 0;
13997 wxFont *arg1 = (wxFont *) 0 ;
13998 wxString result;
13999 void *argp1 = 0 ;
14000 int res1 = 0 ;
14001 PyObject *swig_obj[1] ;
14002
14003 if (!args) SWIG_fail;
14004 swig_obj[0] = args;
14005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFaceName" "', expected argument " "1"" of type '" "wxFont const *""'");
14008 }
14009 arg1 = reinterpret_cast< wxFont * >(argp1);
14010 {
14011 PyThreadState* __tstate = wxPyBeginAllowThreads();
14012 result = ((wxFont const *)arg1)->GetFaceName();
14013 wxPyEndAllowThreads(__tstate);
14014 if (PyErr_Occurred()) SWIG_fail;
14015 }
14016 {
14017 #if wxUSE_UNICODE
14018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14019 #else
14020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14021 #endif
14022 }
14023 return resultobj;
14024 fail:
14025 return NULL;
14026 }
14027
14028
14029 SWIGINTERN PyObject *_wrap_Font_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14030 PyObject *resultobj = 0;
14031 wxFont *arg1 = (wxFont *) 0 ;
14032 wxFontEncoding result;
14033 void *argp1 = 0 ;
14034 int res1 = 0 ;
14035 PyObject *swig_obj[1] ;
14036
14037 if (!args) SWIG_fail;
14038 swig_obj[0] = args;
14039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14040 if (!SWIG_IsOK(res1)) {
14041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetEncoding" "', expected argument " "1"" of type '" "wxFont const *""'");
14042 }
14043 arg1 = reinterpret_cast< wxFont * >(argp1);
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 resultobj = SWIG_From_int(static_cast< int >(result));
14051 return resultobj;
14052 fail:
14053 return NULL;
14054 }
14055
14056
14057 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14058 PyObject *resultobj = 0;
14059 wxFont *arg1 = (wxFont *) 0 ;
14060 wxNativeFontInfo *result = 0 ;
14061 void *argp1 = 0 ;
14062 int res1 = 0 ;
14063 PyObject *swig_obj[1] ;
14064
14065 if (!args) SWIG_fail;
14066 swig_obj[0] = args;
14067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14068 if (!SWIG_IsOK(res1)) {
14069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont const *""'");
14070 }
14071 arg1 = reinterpret_cast< wxFont * >(argp1);
14072 {
14073 PyThreadState* __tstate = wxPyBeginAllowThreads();
14074 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
14075 wxPyEndAllowThreads(__tstate);
14076 if (PyErr_Occurred()) SWIG_fail;
14077 }
14078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
14079 return resultobj;
14080 fail:
14081 return NULL;
14082 }
14083
14084
14085 SWIGINTERN PyObject *_wrap_Font_IsFixedWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14086 PyObject *resultobj = 0;
14087 wxFont *arg1 = (wxFont *) 0 ;
14088 bool result;
14089 void *argp1 = 0 ;
14090 int res1 = 0 ;
14091 PyObject *swig_obj[1] ;
14092
14093 if (!args) SWIG_fail;
14094 swig_obj[0] = args;
14095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14096 if (!SWIG_IsOK(res1)) {
14097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsFixedWidth" "', expected argument " "1"" of type '" "wxFont const *""'");
14098 }
14099 arg1 = reinterpret_cast< wxFont * >(argp1);
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 {
14107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14108 }
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116 PyObject *resultobj = 0;
14117 wxFont *arg1 = (wxFont *) 0 ;
14118 wxString result;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 PyObject *swig_obj[1] ;
14122
14123 if (!args) SWIG_fail;
14124 swig_obj[0] = args;
14125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14126 if (!SWIG_IsOK(res1)) {
14127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14128 }
14129 arg1 = reinterpret_cast< wxFont * >(argp1);
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 {
14137 #if wxUSE_UNICODE
14138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14139 #else
14140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14141 #endif
14142 }
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14150 PyObject *resultobj = 0;
14151 wxFont *arg1 = (wxFont *) 0 ;
14152 wxString result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 PyObject *swig_obj[1] ;
14156
14157 if (!args) SWIG_fail;
14158 swig_obj[0] = args;
14159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14160 if (!SWIG_IsOK(res1)) {
14161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14162 }
14163 arg1 = reinterpret_cast< wxFont * >(argp1);
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 {
14171 #if wxUSE_UNICODE
14172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14173 #else
14174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14175 #endif
14176 }
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 SWIGINTERN PyObject *_wrap_Font_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14184 PyObject *resultobj = 0;
14185 wxFont *arg1 = (wxFont *) 0 ;
14186 int arg2 ;
14187 void *argp1 = 0 ;
14188 int res1 = 0 ;
14189 int val2 ;
14190 int ecode2 = 0 ;
14191 PyObject * obj0 = 0 ;
14192 PyObject * obj1 = 0 ;
14193 char * kwnames[] = {
14194 (char *) "self",(char *) "pointSize", NULL
14195 };
14196
14197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
14198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14199 if (!SWIG_IsOK(res1)) {
14200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPointSize" "', expected argument " "1"" of type '" "wxFont *""'");
14201 }
14202 arg1 = reinterpret_cast< wxFont * >(argp1);
14203 ecode2 = SWIG_AsVal_int(obj1, &val2);
14204 if (!SWIG_IsOK(ecode2)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetPointSize" "', expected argument " "2"" of type '" "int""'");
14206 }
14207 arg2 = static_cast< int >(val2);
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 (arg1)->SetPointSize(arg2);
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 resultobj = SWIG_Py_Void();
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_Font_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxFont *arg1 = (wxFont *) 0 ;
14224 wxSize *arg2 = 0 ;
14225 void *argp1 = 0 ;
14226 int res1 = 0 ;
14227 wxSize temp2 ;
14228 PyObject * obj0 = 0 ;
14229 PyObject * obj1 = 0 ;
14230 char * kwnames[] = {
14231 (char *) "self",(char *) "pixelSize", NULL
14232 };
14233
14234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
14235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14236 if (!SWIG_IsOK(res1)) {
14237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPixelSize" "', expected argument " "1"" of type '" "wxFont *""'");
14238 }
14239 arg1 = reinterpret_cast< wxFont * >(argp1);
14240 {
14241 arg2 = &temp2;
14242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14243 }
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 (arg1)->SetPixelSize((wxSize const &)*arg2);
14247 wxPyEndAllowThreads(__tstate);
14248 if (PyErr_Occurred()) SWIG_fail;
14249 }
14250 resultobj = SWIG_Py_Void();
14251 return resultobj;
14252 fail:
14253 return NULL;
14254 }
14255
14256
14257 SWIGINTERN PyObject *_wrap_Font_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14258 PyObject *resultobj = 0;
14259 wxFont *arg1 = (wxFont *) 0 ;
14260 int arg2 ;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 int val2 ;
14264 int ecode2 = 0 ;
14265 PyObject * obj0 = 0 ;
14266 PyObject * obj1 = 0 ;
14267 char * kwnames[] = {
14268 (char *) "self",(char *) "family", NULL
14269 };
14270
14271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
14272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14273 if (!SWIG_IsOK(res1)) {
14274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFamily" "', expected argument " "1"" of type '" "wxFont *""'");
14275 }
14276 arg1 = reinterpret_cast< wxFont * >(argp1);
14277 ecode2 = SWIG_AsVal_int(obj1, &val2);
14278 if (!SWIG_IsOK(ecode2)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetFamily" "', expected argument " "2"" of type '" "int""'");
14280 }
14281 arg2 = static_cast< int >(val2);
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 (arg1)->SetFamily(arg2);
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_Py_Void();
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Font_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj = 0;
14297 wxFont *arg1 = (wxFont *) 0 ;
14298 int arg2 ;
14299 void *argp1 = 0 ;
14300 int res1 = 0 ;
14301 int val2 ;
14302 int ecode2 = 0 ;
14303 PyObject * obj0 = 0 ;
14304 PyObject * obj1 = 0 ;
14305 char * kwnames[] = {
14306 (char *) "self",(char *) "style", NULL
14307 };
14308
14309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
14310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14311 if (!SWIG_IsOK(res1)) {
14312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetStyle" "', expected argument " "1"" of type '" "wxFont *""'");
14313 }
14314 arg1 = reinterpret_cast< wxFont * >(argp1);
14315 ecode2 = SWIG_AsVal_int(obj1, &val2);
14316 if (!SWIG_IsOK(ecode2)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetStyle" "', expected argument " "2"" of type '" "int""'");
14318 }
14319 arg2 = static_cast< int >(val2);
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 (arg1)->SetStyle(arg2);
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 resultobj = SWIG_Py_Void();
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 SWIGINTERN PyObject *_wrap_Font_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14334 PyObject *resultobj = 0;
14335 wxFont *arg1 = (wxFont *) 0 ;
14336 int arg2 ;
14337 void *argp1 = 0 ;
14338 int res1 = 0 ;
14339 int val2 ;
14340 int ecode2 = 0 ;
14341 PyObject * obj0 = 0 ;
14342 PyObject * obj1 = 0 ;
14343 char * kwnames[] = {
14344 (char *) "self",(char *) "weight", NULL
14345 };
14346
14347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
14348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14349 if (!SWIG_IsOK(res1)) {
14350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetWeight" "', expected argument " "1"" of type '" "wxFont *""'");
14351 }
14352 arg1 = reinterpret_cast< wxFont * >(argp1);
14353 ecode2 = SWIG_AsVal_int(obj1, &val2);
14354 if (!SWIG_IsOK(ecode2)) {
14355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetWeight" "', expected argument " "2"" of type '" "int""'");
14356 }
14357 arg2 = static_cast< int >(val2);
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 (arg1)->SetWeight(arg2);
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 resultobj = SWIG_Py_Void();
14365 return resultobj;
14366 fail:
14367 return NULL;
14368 }
14369
14370
14371 SWIGINTERN PyObject *_wrap_Font_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14372 PyObject *resultobj = 0;
14373 wxFont *arg1 = (wxFont *) 0 ;
14374 wxString *arg2 = 0 ;
14375 bool result;
14376 void *argp1 = 0 ;
14377 int res1 = 0 ;
14378 bool temp2 = false ;
14379 PyObject * obj0 = 0 ;
14380 PyObject * obj1 = 0 ;
14381 char * kwnames[] = {
14382 (char *) "self",(char *) "faceName", NULL
14383 };
14384
14385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
14386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14387 if (!SWIG_IsOK(res1)) {
14388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFaceName" "', expected argument " "1"" of type '" "wxFont *""'");
14389 }
14390 arg1 = reinterpret_cast< wxFont * >(argp1);
14391 {
14392 arg2 = wxString_in_helper(obj1);
14393 if (arg2 == NULL) SWIG_fail;
14394 temp2 = true;
14395 }
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (bool)(arg1)->SetFaceName((wxString const &)*arg2);
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 {
14403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14404 }
14405 {
14406 if (temp2)
14407 delete arg2;
14408 }
14409 return resultobj;
14410 fail:
14411 {
14412 if (temp2)
14413 delete arg2;
14414 }
14415 return NULL;
14416 }
14417
14418
14419 SWIGINTERN PyObject *_wrap_Font_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14420 PyObject *resultobj = 0;
14421 wxFont *arg1 = (wxFont *) 0 ;
14422 bool arg2 ;
14423 void *argp1 = 0 ;
14424 int res1 = 0 ;
14425 bool val2 ;
14426 int ecode2 = 0 ;
14427 PyObject * obj0 = 0 ;
14428 PyObject * obj1 = 0 ;
14429 char * kwnames[] = {
14430 (char *) "self",(char *) "underlined", NULL
14431 };
14432
14433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
14434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetUnderlined" "', expected argument " "1"" of type '" "wxFont *""'");
14437 }
14438 arg1 = reinterpret_cast< wxFont * >(argp1);
14439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14440 if (!SWIG_IsOK(ecode2)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
14442 }
14443 arg2 = static_cast< bool >(val2);
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 (arg1)->SetUnderlined(arg2);
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = SWIG_Py_Void();
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 SWIGINTERN PyObject *_wrap_Font_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj = 0;
14459 wxFont *arg1 = (wxFont *) 0 ;
14460 wxFontEncoding arg2 ;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 int val2 ;
14464 int ecode2 = 0 ;
14465 PyObject * obj0 = 0 ;
14466 PyObject * obj1 = 0 ;
14467 char * kwnames[] = {
14468 (char *) "self",(char *) "encoding", NULL
14469 };
14470
14471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
14472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14473 if (!SWIG_IsOK(res1)) {
14474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetEncoding" "', expected argument " "1"" of type '" "wxFont *""'");
14475 }
14476 arg1 = reinterpret_cast< wxFont * >(argp1);
14477 ecode2 = SWIG_AsVal_int(obj1, &val2);
14478 if (!SWIG_IsOK(ecode2)) {
14479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14480 }
14481 arg2 = static_cast< wxFontEncoding >(val2);
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->SetEncoding(arg2);
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 resultobj = SWIG_Py_Void();
14489 return resultobj;
14490 fail:
14491 return NULL;
14492 }
14493
14494
14495 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14496 PyObject *resultobj = 0;
14497 wxFont *arg1 = (wxFont *) 0 ;
14498 wxNativeFontInfo *arg2 = 0 ;
14499 void *argp1 = 0 ;
14500 int res1 = 0 ;
14501 void *argp2 = 0 ;
14502 int res2 = 0 ;
14503 PyObject * obj0 = 0 ;
14504 PyObject * obj1 = 0 ;
14505 char * kwnames[] = {
14506 (char *) "self",(char *) "info", NULL
14507 };
14508
14509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) SWIG_fail;
14510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14511 if (!SWIG_IsOK(res1)) {
14512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont *""'");
14513 }
14514 arg1 = reinterpret_cast< wxFont * >(argp1);
14515 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
14516 if (!SWIG_IsOK(res2)) {
14517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
14518 }
14519 if (!argp2) {
14520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
14521 }
14522 arg2 = reinterpret_cast< wxNativeFontInfo * >(argp2);
14523 {
14524 PyThreadState* __tstate = wxPyBeginAllowThreads();
14525 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 resultobj = SWIG_Py_Void();
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxFont *arg1 = (wxFont *) 0 ;
14539 wxString *arg2 = 0 ;
14540 bool result;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char * kwnames[] = {
14547 (char *) "self",(char *) "info", NULL
14548 };
14549
14550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) SWIG_fail;
14551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoFromString" "', expected argument " "1"" of type '" "wxFont *""'");
14554 }
14555 arg1 = reinterpret_cast< wxFont * >(argp1);
14556 {
14557 arg2 = wxString_in_helper(obj1);
14558 if (arg2 == NULL) SWIG_fail;
14559 temp2 = true;
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->SetNativeFontInfo((wxString const &)*arg2);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 {
14568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14569 }
14570 {
14571 if (temp2)
14572 delete arg2;
14573 }
14574 return resultobj;
14575 fail:
14576 {
14577 if (temp2)
14578 delete arg2;
14579 }
14580 return NULL;
14581 }
14582
14583
14584 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14585 PyObject *resultobj = 0;
14586 wxFont *arg1 = (wxFont *) 0 ;
14587 wxString *arg2 = 0 ;
14588 bool result;
14589 void *argp1 = 0 ;
14590 int res1 = 0 ;
14591 bool temp2 = false ;
14592 PyObject * obj0 = 0 ;
14593 PyObject * obj1 = 0 ;
14594 char * kwnames[] = {
14595 (char *) "self",(char *) "info", NULL
14596 };
14597
14598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) SWIG_fail;
14599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14600 if (!SWIG_IsOK(res1)) {
14601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont *""'");
14602 }
14603 arg1 = reinterpret_cast< wxFont * >(argp1);
14604 {
14605 arg2 = wxString_in_helper(obj1);
14606 if (arg2 == NULL) SWIG_fail;
14607 temp2 = true;
14608 }
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 return resultobj;
14623 fail:
14624 {
14625 if (temp2)
14626 delete arg2;
14627 }
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Font_GetFamilyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14633 PyObject *resultobj = 0;
14634 wxFont *arg1 = (wxFont *) 0 ;
14635 wxString result;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 PyObject *swig_obj[1] ;
14639
14640 if (!args) SWIG_fail;
14641 swig_obj[0] = args;
14642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14643 if (!SWIG_IsOK(res1)) {
14644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamilyString" "', expected argument " "1"" of type '" "wxFont const *""'");
14645 }
14646 arg1 = reinterpret_cast< wxFont * >(argp1);
14647 {
14648 PyThreadState* __tstate = wxPyBeginAllowThreads();
14649 result = ((wxFont const *)arg1)->GetFamilyString();
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 {
14654 #if wxUSE_UNICODE
14655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14656 #else
14657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14658 #endif
14659 }
14660 return resultobj;
14661 fail:
14662 return NULL;
14663 }
14664
14665
14666 SWIGINTERN PyObject *_wrap_Font_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14667 PyObject *resultobj = 0;
14668 wxFont *arg1 = (wxFont *) 0 ;
14669 wxString result;
14670 void *argp1 = 0 ;
14671 int res1 = 0 ;
14672 PyObject *swig_obj[1] ;
14673
14674 if (!args) SWIG_fail;
14675 swig_obj[0] = args;
14676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14677 if (!SWIG_IsOK(res1)) {
14678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyleString" "', expected argument " "1"" of type '" "wxFont const *""'");
14679 }
14680 arg1 = reinterpret_cast< wxFont * >(argp1);
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 result = ((wxFont const *)arg1)->GetStyleString();
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 {
14688 #if wxUSE_UNICODE
14689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14690 #else
14691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14692 #endif
14693 }
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Font_GetWeightString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14701 PyObject *resultobj = 0;
14702 wxFont *arg1 = (wxFont *) 0 ;
14703 wxString result;
14704 void *argp1 = 0 ;
14705 int res1 = 0 ;
14706 PyObject *swig_obj[1] ;
14707
14708 if (!args) SWIG_fail;
14709 swig_obj[0] = args;
14710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14711 if (!SWIG_IsOK(res1)) {
14712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeightString" "', expected argument " "1"" of type '" "wxFont const *""'");
14713 }
14714 arg1 = reinterpret_cast< wxFont * >(argp1);
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 result = ((wxFont const *)arg1)->GetWeightString();
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 {
14722 #if wxUSE_UNICODE
14723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14724 #else
14725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14726 #endif
14727 }
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 SWIGINTERN PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14735 PyObject *resultobj = 0;
14736 wxFont *arg1 = (wxFont *) 0 ;
14737 bool arg2 = (bool) true ;
14738 void *argp1 = 0 ;
14739 int res1 = 0 ;
14740 bool val2 ;
14741 int ecode2 = 0 ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 char * kwnames[] = {
14745 (char *) "self",(char *) "no", NULL
14746 };
14747
14748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;
14749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14750 if (!SWIG_IsOK(res1)) {
14751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont *""'");
14752 }
14753 arg1 = reinterpret_cast< wxFont * >(argp1);
14754 if (obj1) {
14755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14756 if (!SWIG_IsOK(ecode2)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "2"" of type '" "bool""'");
14758 }
14759 arg2 = static_cast< bool >(val2);
14760 }
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 (arg1)->SetNoAntiAliasing(arg2);
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 resultobj = SWIG_Py_Void();
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 SWIGINTERN PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14775 PyObject *resultobj = 0;
14776 wxFont *arg1 = (wxFont *) 0 ;
14777 bool result;
14778 void *argp1 = 0 ;
14779 int res1 = 0 ;
14780 PyObject *swig_obj[1] ;
14781
14782 if (!args) SWIG_fail;
14783 swig_obj[0] = args;
14784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14785 if (!SWIG_IsOK(res1)) {
14786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont const *""'");
14787 }
14788 arg1 = reinterpret_cast< wxFont * >(argp1);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 return resultobj;
14799 fail:
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Font_GetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14805 PyObject *resultobj = 0;
14806 wxFontEncoding result;
14807
14808 if (!SWIG_Python_UnpackTuple(args,"Font_GetDefaultEncoding",0,0,0)) SWIG_fail;
14809 {
14810 if (!wxPyCheckForApp()) SWIG_fail;
14811 PyThreadState* __tstate = wxPyBeginAllowThreads();
14812 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 resultobj = SWIG_From_int(static_cast< int >(result));
14817 return resultobj;
14818 fail:
14819 return NULL;
14820 }
14821
14822
14823 SWIGINTERN PyObject *_wrap_Font_SetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14824 PyObject *resultobj = 0;
14825 wxFontEncoding arg1 ;
14826 int val1 ;
14827 int ecode1 = 0 ;
14828 PyObject * obj0 = 0 ;
14829 char * kwnames[] = {
14830 (char *) "encoding", NULL
14831 };
14832
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) SWIG_fail;
14834 ecode1 = SWIG_AsVal_int(obj0, &val1);
14835 if (!SWIG_IsOK(ecode1)) {
14836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Font_SetDefaultEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
14837 }
14838 arg1 = static_cast< wxFontEncoding >(val1);
14839 {
14840 if (!wxPyCheckForApp()) SWIG_fail;
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 wxFont::SetDefaultEncoding(arg1);
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 resultobj = SWIG_Py_Void();
14847 return resultobj;
14848 fail:
14849 return NULL;
14850 }
14851
14852
14853 SWIGINTERN PyObject *Font_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14854 PyObject *obj;
14855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14856 SWIG_TypeNewClientData(SWIGTYPE_p_wxFont, SWIG_NewClientData(obj));
14857 return SWIG_Py_Void();
14858 }
14859
14860 SWIGINTERN PyObject *Font_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14861 return SWIG_Python_InitShadowInstance(args);
14862 }
14863
14864 SWIGINTERN PyObject *_wrap_new_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14865 PyObject *resultobj = 0;
14866 wxPyFontEnumerator *result = 0 ;
14867
14868 if (!SWIG_Python_UnpackTuple(args,"new_FontEnumerator",0,0,0)) SWIG_fail;
14869 {
14870 if (!wxPyCheckForApp()) SWIG_fail;
14871 PyThreadState* __tstate = wxPyBeginAllowThreads();
14872 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_NEW | 0 );
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 SWIGINTERN PyObject *_wrap_delete_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14884 PyObject *resultobj = 0;
14885 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14886 void *argp1 = 0 ;
14887 int res1 = 0 ;
14888 PyObject *swig_obj[1] ;
14889
14890 if (!args) SWIG_fail;
14891 swig_obj[0] = args;
14892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_DISOWN | 0 );
14893 if (!SWIG_IsOK(res1)) {
14894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontEnumerator" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14895 }
14896 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 delete arg1;
14900
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 resultobj = SWIG_Py_Void();
14905 return resultobj;
14906 fail:
14907 return NULL;
14908 }
14909
14910
14911 SWIGINTERN PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14912 PyObject *resultobj = 0;
14913 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14914 PyObject *arg2 = (PyObject *) 0 ;
14915 PyObject *arg3 = (PyObject *) 0 ;
14916 bool arg4 ;
14917 void *argp1 = 0 ;
14918 int res1 = 0 ;
14919 bool val4 ;
14920 int ecode4 = 0 ;
14921 PyObject * obj0 = 0 ;
14922 PyObject * obj1 = 0 ;
14923 PyObject * obj2 = 0 ;
14924 PyObject * obj3 = 0 ;
14925 char * kwnames[] = {
14926 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
14927 };
14928
14929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14933 }
14934 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14935 arg2 = obj1;
14936 arg3 = obj2;
14937 ecode4 = SWIG_AsVal_bool(obj3, &val4);
14938 if (!SWIG_IsOK(ecode4)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
14940 }
14941 arg4 = static_cast< bool >(val4);
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 resultobj = SWIG_Py_Void();
14949 return resultobj;
14950 fail:
14951 return NULL;
14952 }
14953
14954
14955 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14956 PyObject *resultobj = 0;
14957 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
14958 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
14959 bool arg3 = (bool) false ;
14960 bool result;
14961 void *argp1 = 0 ;
14962 int res1 = 0 ;
14963 int val2 ;
14964 int ecode2 = 0 ;
14965 bool val3 ;
14966 int ecode3 = 0 ;
14967 PyObject * obj0 = 0 ;
14968 PyObject * obj1 = 0 ;
14969 PyObject * obj2 = 0 ;
14970 char * kwnames[] = {
14971 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
14972 };
14973
14974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
14976 if (!SWIG_IsOK(res1)) {
14977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
14978 }
14979 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
14980 if (obj1) {
14981 ecode2 = SWIG_AsVal_int(obj1, &val2);
14982 if (!SWIG_IsOK(ecode2)) {
14983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "2"" of type '" "wxFontEncoding""'");
14984 }
14985 arg2 = static_cast< wxFontEncoding >(val2);
14986 }
14987 if (obj2) {
14988 ecode3 = SWIG_AsVal_bool(obj2, &val3);
14989 if (!SWIG_IsOK(ecode3)) {
14990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "3"" of type '" "bool""'");
14991 }
14992 arg3 = static_cast< bool >(val3);
14993 }
14994 {
14995 PyThreadState* __tstate = wxPyBeginAllowThreads();
14996 result = (bool)(arg1)->EnumerateFacenames(arg2,arg3);
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 {
15001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15002 }
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj = 0;
15011 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
15012 wxString const &arg2_defvalue = wxPyEmptyString ;
15013 wxString *arg2 = (wxString *) &arg2_defvalue ;
15014 bool result;
15015 void *argp1 = 0 ;
15016 int res1 = 0 ;
15017 bool temp2 = false ;
15018 PyObject * obj0 = 0 ;
15019 PyObject * obj1 = 0 ;
15020 char * kwnames[] = {
15021 (char *) "self",(char *) "facename", NULL
15022 };
15023
15024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) SWIG_fail;
15025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15028 }
15029 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15030 if (obj1) {
15031 {
15032 arg2 = wxString_in_helper(obj1);
15033 if (arg2 == NULL) SWIG_fail;
15034 temp2 = true;
15035 }
15036 }
15037 {
15038 PyThreadState* __tstate = wxPyBeginAllowThreads();
15039 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
15040 wxPyEndAllowThreads(__tstate);
15041 if (PyErr_Occurred()) SWIG_fail;
15042 }
15043 {
15044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15045 }
15046 {
15047 if (temp2)
15048 delete arg2;
15049 }
15050 return resultobj;
15051 fail:
15052 {
15053 if (temp2)
15054 delete arg2;
15055 }
15056 return NULL;
15057 }
15058
15059
15060 SWIGINTERN PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15061 PyObject *resultobj = 0;
15062 PyObject *result = 0 ;
15063
15064 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetEncodings",0,0,0)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (PyObject *)wxPyFontEnumerator_GetEncodings();
15068 wxPyEndAllowThreads(__tstate);
15069 if (PyErr_Occurred()) SWIG_fail;
15070 }
15071 resultobj = result;
15072 return resultobj;
15073 fail:
15074 return NULL;
15075 }
15076
15077
15078 SWIGINTERN PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15079 PyObject *resultobj = 0;
15080 PyObject *result = 0 ;
15081
15082 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetFacenames",0,0,0)) SWIG_fail;
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 result = (PyObject *)wxPyFontEnumerator_GetFacenames();
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 resultobj = result;
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 SWIGINTERN PyObject *_wrap_FontEnumerator_IsValidFacename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj = 0;
15098 wxString *arg1 = 0 ;
15099 bool result;
15100 bool temp1 = false ;
15101 PyObject * obj0 = 0 ;
15102 char * kwnames[] = {
15103 (char *) "str", NULL
15104 };
15105
15106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_IsValidFacename",kwnames,&obj0)) SWIG_fail;
15107 {
15108 arg1 = wxString_in_helper(obj0);
15109 if (arg1 == NULL) SWIG_fail;
15110 temp1 = true;
15111 }
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 result = (bool)wxPyFontEnumerator::IsValidFacename((wxString const &)*arg1);
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 {
15119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15120 }
15121 {
15122 if (temp1)
15123 delete arg1;
15124 }
15125 return resultobj;
15126 fail:
15127 {
15128 if (temp1)
15129 delete arg1;
15130 }
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *FontEnumerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15136 PyObject *obj;
15137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15138 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFontEnumerator, SWIG_NewClientData(obj));
15139 return SWIG_Py_Void();
15140 }
15141
15142 SWIGINTERN PyObject *FontEnumerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 return SWIG_Python_InitShadowInstance(args);
15144 }
15145
15146 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15147 PyObject *resultobj = 0;
15148 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15149 int arg2 ;
15150 void *argp1 = 0 ;
15151 int res1 = 0 ;
15152 int val2 ;
15153 int ecode2 = 0 ;
15154 PyObject *swig_obj[2] ;
15155
15156 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Language_set",2,2,swig_obj)) SWIG_fail;
15157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15158 if (!SWIG_IsOK(res1)) {
15159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15160 }
15161 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15162 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15163 if (!SWIG_IsOK(ecode2)) {
15164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LanguageInfo_Language_set" "', expected argument " "2"" of type '" "int""'");
15165 }
15166 arg2 = static_cast< int >(val2);
15167 if (arg1) (arg1)->Language = arg2;
15168
15169 resultobj = SWIG_Py_Void();
15170 return resultobj;
15171 fail:
15172 return NULL;
15173 }
15174
15175
15176 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15177 PyObject *resultobj = 0;
15178 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15179 int result;
15180 void *argp1 = 0 ;
15181 int res1 = 0 ;
15182 PyObject *swig_obj[1] ;
15183
15184 if (!args) SWIG_fail;
15185 swig_obj[0] = args;
15186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15187 if (!SWIG_IsOK(res1)) {
15188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15189 }
15190 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15191 result = (int) ((arg1)->Language);
15192 resultobj = SWIG_From_int(static_cast< int >(result));
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15200 PyObject *resultobj = 0;
15201 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15202 wxString *arg2 = (wxString *) 0 ;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 bool temp2 = false ;
15206 PyObject *swig_obj[2] ;
15207
15208 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_CanonicalName_set",2,2,swig_obj)) SWIG_fail;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15212 }
15213 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15214 {
15215 arg2 = wxString_in_helper(swig_obj[1]);
15216 if (arg2 == NULL) SWIG_fail;
15217 temp2 = true;
15218 }
15219 if (arg1) (arg1)->CanonicalName = *arg2;
15220
15221 resultobj = SWIG_Py_Void();
15222 {
15223 if (temp2)
15224 delete arg2;
15225 }
15226 return resultobj;
15227 fail:
15228 {
15229 if (temp2)
15230 delete arg2;
15231 }
15232 return NULL;
15233 }
15234
15235
15236 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15237 PyObject *resultobj = 0;
15238 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15239 wxString *result = 0 ;
15240 void *argp1 = 0 ;
15241 int res1 = 0 ;
15242 PyObject *swig_obj[1] ;
15243
15244 if (!args) SWIG_fail;
15245 swig_obj[0] = args;
15246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15247 if (!SWIG_IsOK(res1)) {
15248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15249 }
15250 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15251 result = (wxString *)& ((arg1)->CanonicalName);
15252 {
15253 #if wxUSE_UNICODE
15254 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15255 #else
15256 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15257 #endif
15258 }
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15266 PyObject *resultobj = 0;
15267 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15268 wxString *arg2 = (wxString *) 0 ;
15269 void *argp1 = 0 ;
15270 int res1 = 0 ;
15271 bool temp2 = false ;
15272 PyObject *swig_obj[2] ;
15273
15274 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Description_set",2,2,swig_obj)) SWIG_fail;
15275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15278 }
15279 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15280 {
15281 arg2 = wxString_in_helper(swig_obj[1]);
15282 if (arg2 == NULL) SWIG_fail;
15283 temp2 = true;
15284 }
15285 if (arg1) (arg1)->Description = *arg2;
15286
15287 resultobj = SWIG_Py_Void();
15288 {
15289 if (temp2)
15290 delete arg2;
15291 }
15292 return resultobj;
15293 fail:
15294 {
15295 if (temp2)
15296 delete arg2;
15297 }
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15303 PyObject *resultobj = 0;
15304 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15305 wxString *result = 0 ;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject *swig_obj[1] ;
15309
15310 if (!args) SWIG_fail;
15311 swig_obj[0] = args;
15312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15315 }
15316 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15317 result = (wxString *)& ((arg1)->Description);
15318 {
15319 #if wxUSE_UNICODE
15320 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15321 #else
15322 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15323 #endif
15324 }
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 SWIGINTERN PyObject *LanguageInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15332 PyObject *obj;
15333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15334 SWIG_TypeNewClientData(SWIGTYPE_p_wxLanguageInfo, SWIG_NewClientData(obj));
15335 return SWIG_Py_Void();
15336 }
15337
15338 SWIGINTERN PyObject *_wrap_new_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15339 PyObject *resultobj = 0;
15340 int arg1 = (int) -1 ;
15341 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
15342 wxLocale *result = 0 ;
15343 int val1 ;
15344 int ecode1 = 0 ;
15345 int val2 ;
15346 int ecode2 = 0 ;
15347 PyObject * obj0 = 0 ;
15348 PyObject * obj1 = 0 ;
15349 char * kwnames[] = {
15350 (char *) "language",(char *) "flags", NULL
15351 };
15352
15353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) SWIG_fail;
15354 if (obj0) {
15355 ecode1 = SWIG_AsVal_int(obj0, &val1);
15356 if (!SWIG_IsOK(ecode1)) {
15357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Locale" "', expected argument " "1"" of type '" "int""'");
15358 }
15359 arg1 = static_cast< int >(val1);
15360 }
15361 if (obj1) {
15362 ecode2 = SWIG_AsVal_int(obj1, &val2);
15363 if (!SWIG_IsOK(ecode2)) {
15364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Locale" "', expected argument " "2"" of type '" "int""'");
15365 }
15366 arg2 = static_cast< int >(val2);
15367 }
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 result = (wxLocale *)new_wxLocale(arg1,arg2);
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, SWIG_POINTER_NEW | 0 );
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_delete_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxLocale *arg1 = (wxLocale *) 0 ;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject *swig_obj[1] ;
15387
15388 if (!args) SWIG_fail;
15389 swig_obj[0] = args;
15390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, SWIG_POINTER_DISOWN | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locale" "', expected argument " "1"" of type '" "wxLocale *""'");
15393 }
15394 arg1 = reinterpret_cast< wxLocale * >(argp1);
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 delete arg1;
15398
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = SWIG_Py_Void();
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_Locale_Init1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = 0;
15411 wxLocale *arg1 = (wxLocale *) 0 ;
15412 wxString *arg2 = 0 ;
15413 wxString const &arg3_defvalue = wxPyEmptyString ;
15414 wxString *arg3 = (wxString *) &arg3_defvalue ;
15415 wxString const &arg4_defvalue = wxPyEmptyString ;
15416 wxString *arg4 = (wxString *) &arg4_defvalue ;
15417 bool arg5 = (bool) true ;
15418 bool arg6 = (bool) false ;
15419 bool result;
15420 void *argp1 = 0 ;
15421 int res1 = 0 ;
15422 bool temp2 = false ;
15423 bool temp3 = false ;
15424 bool temp4 = false ;
15425 bool val5 ;
15426 int ecode5 = 0 ;
15427 bool val6 ;
15428 int ecode6 = 0 ;
15429 PyObject * obj0 = 0 ;
15430 PyObject * obj1 = 0 ;
15431 PyObject * obj2 = 0 ;
15432 PyObject * obj3 = 0 ;
15433 PyObject * obj4 = 0 ;
15434 PyObject * obj5 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
15437 };
15438
15439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15441 if (!SWIG_IsOK(res1)) {
15442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init1" "', expected argument " "1"" of type '" "wxLocale *""'");
15443 }
15444 arg1 = reinterpret_cast< wxLocale * >(argp1);
15445 {
15446 arg2 = wxString_in_helper(obj1);
15447 if (arg2 == NULL) SWIG_fail;
15448 temp2 = true;
15449 }
15450 if (obj2) {
15451 {
15452 arg3 = wxString_in_helper(obj2);
15453 if (arg3 == NULL) SWIG_fail;
15454 temp3 = true;
15455 }
15456 }
15457 if (obj3) {
15458 {
15459 arg4 = wxString_in_helper(obj3);
15460 if (arg4 == NULL) SWIG_fail;
15461 temp4 = true;
15462 }
15463 }
15464 if (obj4) {
15465 ecode5 = SWIG_AsVal_bool(obj4, &val5);
15466 if (!SWIG_IsOK(ecode5)) {
15467 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Locale_Init1" "', expected argument " "5"" of type '" "bool""'");
15468 }
15469 arg5 = static_cast< bool >(val5);
15470 }
15471 if (obj5) {
15472 ecode6 = SWIG_AsVal_bool(obj5, &val6);
15473 if (!SWIG_IsOK(ecode6)) {
15474 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Locale_Init1" "', expected argument " "6"" of type '" "bool""'");
15475 }
15476 arg6 = static_cast< bool >(val6);
15477 }
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 {
15485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15486 }
15487 {
15488 if (temp2)
15489 delete arg2;
15490 }
15491 {
15492 if (temp3)
15493 delete arg3;
15494 }
15495 {
15496 if (temp4)
15497 delete arg4;
15498 }
15499 return resultobj;
15500 fail:
15501 {
15502 if (temp2)
15503 delete arg2;
15504 }
15505 {
15506 if (temp3)
15507 delete arg3;
15508 }
15509 {
15510 if (temp4)
15511 delete arg4;
15512 }
15513 return NULL;
15514 }
15515
15516
15517 SWIGINTERN PyObject *_wrap_Locale_Init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15518 PyObject *resultobj = 0;
15519 wxLocale *arg1 = (wxLocale *) 0 ;
15520 int arg2 = (int) wxLANGUAGE_DEFAULT ;
15521 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
15522 bool result;
15523 void *argp1 = 0 ;
15524 int res1 = 0 ;
15525 int val2 ;
15526 int ecode2 = 0 ;
15527 int val3 ;
15528 int ecode3 = 0 ;
15529 PyObject * obj0 = 0 ;
15530 PyObject * obj1 = 0 ;
15531 PyObject * obj2 = 0 ;
15532 char * kwnames[] = {
15533 (char *) "self",(char *) "language",(char *) "flags", NULL
15534 };
15535
15536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15538 if (!SWIG_IsOK(res1)) {
15539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init2" "', expected argument " "1"" of type '" "wxLocale *""'");
15540 }
15541 arg1 = reinterpret_cast< wxLocale * >(argp1);
15542 if (obj1) {
15543 ecode2 = SWIG_AsVal_int(obj1, &val2);
15544 if (!SWIG_IsOK(ecode2)) {
15545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Locale_Init2" "', expected argument " "2"" of type '" "int""'");
15546 }
15547 arg2 = static_cast< int >(val2);
15548 }
15549 if (obj2) {
15550 ecode3 = SWIG_AsVal_int(obj2, &val3);
15551 if (!SWIG_IsOK(ecode3)) {
15552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Locale_Init2" "', expected argument " "3"" of type '" "int""'");
15553 }
15554 arg3 = static_cast< int >(val3);
15555 }
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 {
15563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15564 }
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_Locale_GetSystemLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15572 PyObject *resultobj = 0;
15573 int result;
15574
15575 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemLanguage",0,0,0)) SWIG_fail;
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 result = (int)wxLocale::GetSystemLanguage();
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_From_int(static_cast< int >(result));
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxFontEncoding result;
15592
15593 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncoding",0,0,0)) SWIG_fail;
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
15597 wxPyEndAllowThreads(__tstate);
15598 if (PyErr_Occurred()) SWIG_fail;
15599 }
15600 resultobj = SWIG_From_int(static_cast< int >(result));
15601 return resultobj;
15602 fail:
15603 return NULL;
15604 }
15605
15606
15607 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15608 PyObject *resultobj = 0;
15609 wxString result;
15610
15611 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncodingName",0,0,0)) SWIG_fail;
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 result = wxLocale::GetSystemEncodingName();
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 {
15619 #if wxUSE_UNICODE
15620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15621 #else
15622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15623 #endif
15624 }
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 SWIGINTERN PyObject *_wrap_Locale_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15632 PyObject *resultobj = 0;
15633 wxLocale *arg1 = (wxLocale *) 0 ;
15634 bool result;
15635 void *argp1 = 0 ;
15636 int res1 = 0 ;
15637 PyObject *swig_obj[1] ;
15638
15639 if (!args) SWIG_fail;
15640 swig_obj[0] = args;
15641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15642 if (!SWIG_IsOK(res1)) {
15643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsOk" "', expected argument " "1"" of type '" "wxLocale const *""'");
15644 }
15645 arg1 = reinterpret_cast< wxLocale * >(argp1);
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (bool)((wxLocale const *)arg1)->IsOk();
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 {
15653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15654 }
15655 return resultobj;
15656 fail:
15657 return NULL;
15658 }
15659
15660
15661 SWIGINTERN PyObject *_wrap_Locale_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15662 PyObject *resultobj = 0;
15663 wxLocale *arg1 = (wxLocale *) 0 ;
15664 wxString result;
15665 void *argp1 = 0 ;
15666 int res1 = 0 ;
15667 PyObject *swig_obj[1] ;
15668
15669 if (!args) SWIG_fail;
15670 swig_obj[0] = args;
15671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15672 if (!SWIG_IsOK(res1)) {
15673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLocale" "', expected argument " "1"" of type '" "wxLocale const *""'");
15674 }
15675 arg1 = reinterpret_cast< wxLocale * >(argp1);
15676 {
15677 PyThreadState* __tstate = wxPyBeginAllowThreads();
15678 result = ((wxLocale const *)arg1)->GetLocale();
15679 wxPyEndAllowThreads(__tstate);
15680 if (PyErr_Occurred()) SWIG_fail;
15681 }
15682 {
15683 #if wxUSE_UNICODE
15684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15685 #else
15686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15687 #endif
15688 }
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Locale_GetLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxLocale *arg1 = (wxLocale *) 0 ;
15698 int result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLanguage" "', expected argument " "1"" of type '" "wxLocale const *""'");
15708 }
15709 arg1 = reinterpret_cast< wxLocale * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (int)((wxLocale const *)arg1)->GetLanguage();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 resultobj = SWIG_From_int(static_cast< int >(result));
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 SWIGINTERN PyObject *_wrap_Locale_GetSysName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15724 PyObject *resultobj = 0;
15725 wxLocale *arg1 = (wxLocale *) 0 ;
15726 wxString result;
15727 void *argp1 = 0 ;
15728 int res1 = 0 ;
15729 PyObject *swig_obj[1] ;
15730
15731 if (!args) SWIG_fail;
15732 swig_obj[0] = args;
15733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetSysName" "', expected argument " "1"" of type '" "wxLocale const *""'");
15736 }
15737 arg1 = reinterpret_cast< wxLocale * >(argp1);
15738 {
15739 PyThreadState* __tstate = wxPyBeginAllowThreads();
15740 result = ((wxLocale const *)arg1)->GetSysName();
15741 wxPyEndAllowThreads(__tstate);
15742 if (PyErr_Occurred()) SWIG_fail;
15743 }
15744 {
15745 #if wxUSE_UNICODE
15746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15747 #else
15748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15749 #endif
15750 }
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Locale_GetCanonicalName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15758 PyObject *resultobj = 0;
15759 wxLocale *arg1 = (wxLocale *) 0 ;
15760 wxString result;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 PyObject *swig_obj[1] ;
15764
15765 if (!args) SWIG_fail;
15766 swig_obj[0] = args;
15767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetCanonicalName" "', expected argument " "1"" of type '" "wxLocale const *""'");
15770 }
15771 arg1 = reinterpret_cast< wxLocale * >(argp1);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = ((wxLocale const *)arg1)->GetCanonicalName();
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 {
15779 #if wxUSE_UNICODE
15780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15781 #else
15782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15783 #endif
15784 }
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 SWIGINTERN PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15792 PyObject *resultobj = 0;
15793 wxString *arg1 = 0 ;
15794 bool temp1 = false ;
15795 PyObject * obj0 = 0 ;
15796 char * kwnames[] = {
15797 (char *) "prefix", NULL
15798 };
15799
15800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) SWIG_fail;
15801 {
15802 arg1 = wxString_in_helper(obj0);
15803 if (arg1 == NULL) SWIG_fail;
15804 temp1 = true;
15805 }
15806 {
15807 PyThreadState* __tstate = wxPyBeginAllowThreads();
15808 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 resultobj = SWIG_Py_Void();
15813 {
15814 if (temp1)
15815 delete arg1;
15816 }
15817 return resultobj;
15818 fail:
15819 {
15820 if (temp1)
15821 delete arg1;
15822 }
15823 return NULL;
15824 }
15825
15826
15827 SWIGINTERN PyObject *_wrap_Locale_AddCatalog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15828 PyObject *resultobj = 0;
15829 wxLocale *arg1 = (wxLocale *) 0 ;
15830 wxString *arg2 = 0 ;
15831 bool result;
15832 void *argp1 = 0 ;
15833 int res1 = 0 ;
15834 bool temp2 = false ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 char * kwnames[] = {
15838 (char *) "self",(char *) "szDomain", NULL
15839 };
15840
15841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) SWIG_fail;
15842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddCatalog" "', expected argument " "1"" of type '" "wxLocale *""'");
15845 }
15846 arg1 = reinterpret_cast< wxLocale * >(argp1);
15847 {
15848 arg2 = wxString_in_helper(obj1);
15849 if (arg2 == NULL) SWIG_fail;
15850 temp2 = true;
15851 }
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15860 }
15861 {
15862 if (temp2)
15863 delete arg2;
15864 }
15865 return resultobj;
15866 fail:
15867 {
15868 if (temp2)
15869 delete arg2;
15870 }
15871 return NULL;
15872 }
15873
15874
15875 SWIGINTERN PyObject *_wrap_Locale_IsLoaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj = 0;
15877 wxLocale *arg1 = (wxLocale *) 0 ;
15878 wxString *arg2 = 0 ;
15879 bool result;
15880 void *argp1 = 0 ;
15881 int res1 = 0 ;
15882 bool temp2 = false ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "szDomain", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsLoaded" "', expected argument " "1"" of type '" "wxLocale const *""'");
15893 }
15894 arg1 = reinterpret_cast< wxLocale * >(argp1);
15895 {
15896 arg2 = wxString_in_helper(obj1);
15897 if (arg2 == NULL) SWIG_fail;
15898 temp2 = true;
15899 }
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 {
15907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15908 }
15909 {
15910 if (temp2)
15911 delete arg2;
15912 }
15913 return resultobj;
15914 fail:
15915 {
15916 if (temp2)
15917 delete arg2;
15918 }
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Locale_GetLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj = 0;
15925 int arg1 ;
15926 wxLanguageInfo *result = 0 ;
15927 int val1 ;
15928 int ecode1 = 0 ;
15929 PyObject * obj0 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "lang", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) SWIG_fail;
15935 ecode1 = SWIG_AsVal_int(obj0, &val1);
15936 if (!SWIG_IsOK(ecode1)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageInfo" "', expected argument " "1"" of type '" "int""'");
15938 }
15939 arg1 = static_cast< int >(val1);
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Locale_GetLanguageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15954 PyObject *resultobj = 0;
15955 int arg1 ;
15956 wxString result;
15957 int val1 ;
15958 int ecode1 = 0 ;
15959 PyObject * obj0 = 0 ;
15960 char * kwnames[] = {
15961 (char *) "lang", NULL
15962 };
15963
15964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) SWIG_fail;
15965 ecode1 = SWIG_AsVal_int(obj0, &val1);
15966 if (!SWIG_IsOK(ecode1)) {
15967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageName" "', expected argument " "1"" of type '" "int""'");
15968 }
15969 arg1 = static_cast< int >(val1);
15970 {
15971 PyThreadState* __tstate = wxPyBeginAllowThreads();
15972 result = wxLocale::GetLanguageName(arg1);
15973 wxPyEndAllowThreads(__tstate);
15974 if (PyErr_Occurred()) SWIG_fail;
15975 }
15976 {
15977 #if wxUSE_UNICODE
15978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15979 #else
15980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15981 #endif
15982 }
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Locale_FindLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15990 PyObject *resultobj = 0;
15991 wxString *arg1 = 0 ;
15992 wxLanguageInfo *result = 0 ;
15993 bool temp1 = false ;
15994 PyObject * obj0 = 0 ;
15995 char * kwnames[] = {
15996 (char *) "locale", NULL
15997 };
15998
15999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) SWIG_fail;
16000 {
16001 arg1 = wxString_in_helper(obj0);
16002 if (arg1 == NULL) SWIG_fail;
16003 temp1 = true;
16004 }
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
16012 {
16013 if (temp1)
16014 delete arg1;
16015 }
16016 return resultobj;
16017 fail:
16018 {
16019 if (temp1)
16020 delete arg1;
16021 }
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Locale_AddLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16027 PyObject *resultobj = 0;
16028 wxLanguageInfo *arg1 = 0 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject * obj0 = 0 ;
16032 char * kwnames[] = {
16033 (char *) "info", NULL
16034 };
16035
16036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) SWIG_fail;
16037 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxLanguageInfo, 0 | 0);
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16040 }
16041 if (!argp1) {
16042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16043 }
16044 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
16048 wxPyEndAllowThreads(__tstate);
16049 if (PyErr_Occurred()) SWIG_fail;
16050 }
16051 resultobj = SWIG_Py_Void();
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 SWIGINTERN PyObject *_wrap_Locale_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj = 0;
16060 wxLocale *arg1 = (wxLocale *) 0 ;
16061 wxString *arg2 = 0 ;
16062 wxString const &arg3_defvalue = wxPyEmptyString ;
16063 wxString *arg3 = (wxString *) &arg3_defvalue ;
16064 wxString result;
16065 void *argp1 = 0 ;
16066 int res1 = 0 ;
16067 bool temp2 = false ;
16068 bool temp3 = false ;
16069 PyObject * obj0 = 0 ;
16070 PyObject * obj1 = 0 ;
16071 PyObject * obj2 = 0 ;
16072 char * kwnames[] = {
16073 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16074 };
16075
16076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16078 if (!SWIG_IsOK(res1)) {
16079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetString" "', expected argument " "1"" of type '" "wxLocale const *""'");
16080 }
16081 arg1 = reinterpret_cast< wxLocale * >(argp1);
16082 {
16083 arg2 = wxString_in_helper(obj1);
16084 if (arg2 == NULL) SWIG_fail;
16085 temp2 = true;
16086 }
16087 if (obj2) {
16088 {
16089 arg3 = wxString_in_helper(obj2);
16090 if (arg3 == NULL) SWIG_fail;
16091 temp3 = true;
16092 }
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 {
16101 #if wxUSE_UNICODE
16102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16103 #else
16104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16105 #endif
16106 }
16107 {
16108 if (temp2)
16109 delete arg2;
16110 }
16111 {
16112 if (temp3)
16113 delete arg3;
16114 }
16115 return resultobj;
16116 fail:
16117 {
16118 if (temp2)
16119 delete arg2;
16120 }
16121 {
16122 if (temp3)
16123 delete arg3;
16124 }
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Locale_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131 wxLocale *arg1 = (wxLocale *) 0 ;
16132 wxString *result = 0 ;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 PyObject *swig_obj[1] ;
16136
16137 if (!args) SWIG_fail;
16138 swig_obj[0] = args;
16139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetName" "', expected argument " "1"" of type '" "wxLocale const *""'");
16142 }
16143 arg1 = reinterpret_cast< wxLocale * >(argp1);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 {
16147 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
16148 result = (wxString *) &_result_ref;
16149 }
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 {
16154 #if wxUSE_UNICODE
16155 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16156 #else
16157 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16158 #endif
16159 }
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *Locale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16167 PyObject *obj;
16168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16169 SWIG_TypeNewClientData(SWIGTYPE_p_wxLocale, SWIG_NewClientData(obj));
16170 return SWIG_Py_Void();
16171 }
16172
16173 SWIGINTERN PyObject *Locale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16174 return SWIG_Python_InitShadowInstance(args);
16175 }
16176
16177 SWIGINTERN PyObject *_wrap_new_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj = 0;
16179 int arg1 = (int) -1 ;
16180 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
16181 wxPyLocale *result = 0 ;
16182 int val1 ;
16183 int ecode1 = 0 ;
16184 int val2 ;
16185 int ecode2 = 0 ;
16186 PyObject * obj0 = 0 ;
16187 PyObject * obj1 = 0 ;
16188 char * kwnames[] = {
16189 (char *) "language",(char *) "flags", NULL
16190 };
16191
16192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyLocale",kwnames,&obj0,&obj1)) SWIG_fail;
16193 if (obj0) {
16194 ecode1 = SWIG_AsVal_int(obj0, &val1);
16195 if (!SWIG_IsOK(ecode1)) {
16196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyLocale" "', expected argument " "1"" of type '" "int""'");
16197 }
16198 arg1 = static_cast< int >(val1);
16199 }
16200 if (obj1) {
16201 ecode2 = SWIG_AsVal_int(obj1, &val2);
16202 if (!SWIG_IsOK(ecode2)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyLocale" "', expected argument " "2"" of type '" "int""'");
16204 }
16205 arg2 = static_cast< int >(val2);
16206 }
16207 {
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 result = (wxPyLocale *)new_wxPyLocale(arg1,arg2);
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLocale, SWIG_POINTER_NEW | 0 );
16214 return resultobj;
16215 fail:
16216 return NULL;
16217 }
16218
16219
16220 SWIGINTERN PyObject *_wrap_delete_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16221 PyObject *resultobj = 0;
16222 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16223 void *argp1 = 0 ;
16224 int res1 = 0 ;
16225 PyObject *swig_obj[1] ;
16226
16227 if (!args) SWIG_fail;
16228 swig_obj[0] = args;
16229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyLocale, SWIG_POINTER_DISOWN | 0 );
16230 if (!SWIG_IsOK(res1)) {
16231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyLocale" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16232 }
16233 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16234 {
16235 PyThreadState* __tstate = wxPyBeginAllowThreads();
16236 delete arg1;
16237
16238 wxPyEndAllowThreads(__tstate);
16239 if (PyErr_Occurred()) SWIG_fail;
16240 }
16241 resultobj = SWIG_Py_Void();
16242 return resultobj;
16243 fail:
16244 return NULL;
16245 }
16246
16247
16248 SWIGINTERN PyObject *_wrap_PyLocale__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16249 PyObject *resultobj = 0;
16250 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16251 PyObject *arg2 = (PyObject *) 0 ;
16252 PyObject *arg3 = (PyObject *) 0 ;
16253 void *argp1 = 0 ;
16254 int res1 = 0 ;
16255 PyObject * obj0 = 0 ;
16256 PyObject * obj1 = 0 ;
16257 PyObject * obj2 = 0 ;
16258 char * kwnames[] = {
16259 (char *) "self",(char *) "self",(char *) "_class", NULL
16260 };
16261
16262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLocale__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16266 }
16267 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16268 arg2 = obj1;
16269 arg3 = obj2;
16270 {
16271 PyThreadState* __tstate = wxPyBeginAllowThreads();
16272 (arg1)->_setCallbackInfo(arg2,arg3);
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 resultobj = SWIG_Py_Void();
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 SWIGINTERN PyObject *_wrap_PyLocale_GetSingularString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj = 0;
16285 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16286 wxChar *arg2 = (wxChar *) 0 ;
16287 wxChar *arg3 = (wxChar *) NULL ;
16288 wxChar *result = 0 ;
16289 void *argp1 = 0 ;
16290 int res1 = 0 ;
16291 void *argp2 = 0 ;
16292 int res2 = 0 ;
16293 void *argp3 = 0 ;
16294 int res3 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 PyObject * obj2 = 0 ;
16298 char * kwnames[] = {
16299 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16300 };
16301
16302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyLocale_GetSingularString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetSingularString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
16306 }
16307 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
16309 if (!SWIG_IsOK(res2)) {
16310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetSingularString" "', expected argument " "2"" of type '" "wxChar const *""'");
16311 }
16312 arg2 = reinterpret_cast< wxChar * >(argp2);
16313 if (obj2) {
16314 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
16315 if (!SWIG_IsOK(res3)) {
16316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetSingularString" "', expected argument " "3"" of type '" "wxChar const *""'");
16317 }
16318 arg3 = reinterpret_cast< wxChar * >(argp3);
16319 }
16320 {
16321 PyThreadState* __tstate = wxPyBeginAllowThreads();
16322 result = (wxChar *)((wxPyLocale const *)arg1)->GetSingularString((wxChar const *)arg2,(wxChar const *)arg3);
16323 wxPyEndAllowThreads(__tstate);
16324 if (PyErr_Occurred()) SWIG_fail;
16325 }
16326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
16327 return resultobj;
16328 fail:
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_PyLocale_GetPluralString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16334 PyObject *resultobj = 0;
16335 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16336 wxChar *arg2 = (wxChar *) 0 ;
16337 wxChar *arg3 = (wxChar *) 0 ;
16338 size_t arg4 ;
16339 wxChar *arg5 = (wxChar *) NULL ;
16340 wxChar *result = 0 ;
16341 void *argp1 = 0 ;
16342 int res1 = 0 ;
16343 void *argp2 = 0 ;
16344 int res2 = 0 ;
16345 void *argp3 = 0 ;
16346 int res3 = 0 ;
16347 size_t val4 ;
16348 int ecode4 = 0 ;
16349 void *argp5 = 0 ;
16350 int res5 = 0 ;
16351 PyObject * obj0 = 0 ;
16352 PyObject * obj1 = 0 ;
16353 PyObject * obj2 = 0 ;
16354 PyObject * obj3 = 0 ;
16355 PyObject * obj4 = 0 ;
16356 char * kwnames[] = {
16357 (char *) "self",(char *) "szOrigString",(char *) "szOrigString2",(char *) "n",(char *) "szDomain", NULL
16358 };
16359
16360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PyLocale_GetPluralString",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16362 if (!SWIG_IsOK(res1)) {
16363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetPluralString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
16364 }
16365 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
16367 if (!SWIG_IsOK(res2)) {
16368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetPluralString" "', expected argument " "2"" of type '" "wxChar const *""'");
16369 }
16370 arg2 = reinterpret_cast< wxChar * >(argp2);
16371 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
16372 if (!SWIG_IsOK(res3)) {
16373 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetPluralString" "', expected argument " "3"" of type '" "wxChar const *""'");
16374 }
16375 arg3 = reinterpret_cast< wxChar * >(argp3);
16376 ecode4 = SWIG_AsVal_size_t(obj3, &val4);
16377 if (!SWIG_IsOK(ecode4)) {
16378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyLocale_GetPluralString" "', expected argument " "4"" of type '" "size_t""'");
16379 }
16380 arg4 = static_cast< size_t >(val4);
16381 if (obj4) {
16382 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxChar, 0 | 0 );
16383 if (!SWIG_IsOK(res5)) {
16384 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PyLocale_GetPluralString" "', expected argument " "5"" of type '" "wxChar const *""'");
16385 }
16386 arg5 = reinterpret_cast< wxChar * >(argp5);
16387 }
16388 {
16389 PyThreadState* __tstate = wxPyBeginAllowThreads();
16390 result = (wxChar *)((wxPyLocale const *)arg1)->GetPluralString((wxChar const *)arg2,(wxChar const *)arg3,arg4,(wxChar const *)arg5);
16391 wxPyEndAllowThreads(__tstate);
16392 if (PyErr_Occurred()) SWIG_fail;
16393 }
16394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
16395 return resultobj;
16396 fail:
16397 return NULL;
16398 }
16399
16400
16401 SWIGINTERN PyObject *PyLocale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16402 PyObject *obj;
16403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16404 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLocale, SWIG_NewClientData(obj));
16405 return SWIG_Py_Void();
16406 }
16407
16408 SWIGINTERN PyObject *PyLocale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16409 return SWIG_Python_InitShadowInstance(args);
16410 }
16411
16412 SWIGINTERN PyObject *_wrap_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16413 PyObject *resultobj = 0;
16414 wxLocale *result = 0 ;
16415
16416 if (!SWIG_Python_UnpackTuple(args,"GetLocale",0,0,0)) SWIG_fail;
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (wxLocale *)wxGetLocale();
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, 0 | 0 );
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16431 PyObject *resultobj = 0;
16432 wxString *arg1 = 0 ;
16433 wxString result;
16434 bool temp1 = false ;
16435
16436 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
16437 {
16438 arg1 = wxString_in_helper(swig_obj[0]);
16439 if (arg1 == NULL) SWIG_fail;
16440 temp1 = true;
16441 }
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = wxGetTranslation((wxString const &)*arg1);
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 {
16449 #if wxUSE_UNICODE
16450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16451 #else
16452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16453 #endif
16454 }
16455 {
16456 if (temp1)
16457 delete arg1;
16458 }
16459 return resultobj;
16460 fail:
16461 {
16462 if (temp1)
16463 delete arg1;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16470 PyObject *resultobj = 0;
16471 wxString *arg1 = 0 ;
16472 wxString *arg2 = 0 ;
16473 wxString result;
16474 bool temp1 = false ;
16475 bool temp2 = false ;
16476
16477 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
16478 {
16479 arg1 = wxString_in_helper(swig_obj[0]);
16480 if (arg1 == NULL) SWIG_fail;
16481 temp1 = true;
16482 }
16483 {
16484 arg2 = wxString_in_helper(swig_obj[1]);
16485 if (arg2 == NULL) SWIG_fail;
16486 temp2 = true;
16487 }
16488 {
16489 PyThreadState* __tstate = wxPyBeginAllowThreads();
16490 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2);
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 #if wxUSE_UNICODE
16496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16497 #else
16498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16499 #endif
16500 }
16501 {
16502 if (temp1)
16503 delete arg1;
16504 }
16505 {
16506 if (temp2)
16507 delete arg2;
16508 }
16509 return resultobj;
16510 fail:
16511 {
16512 if (temp1)
16513 delete arg1;
16514 }
16515 {
16516 if (temp2)
16517 delete arg2;
16518 }
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16524 PyObject *resultobj = 0;
16525 wxString *arg1 = 0 ;
16526 wxString *arg2 = 0 ;
16527 size_t arg3 ;
16528 wxString result;
16529 bool temp1 = false ;
16530 bool temp2 = false ;
16531 size_t val3 ;
16532 int ecode3 = 0 ;
16533
16534 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
16535 {
16536 arg1 = wxString_in_helper(swig_obj[0]);
16537 if (arg1 == NULL) SWIG_fail;
16538 temp1 = true;
16539 }
16540 {
16541 arg2 = wxString_in_helper(swig_obj[1]);
16542 if (arg2 == NULL) SWIG_fail;
16543 temp2 = true;
16544 }
16545 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
16546 if (!SWIG_IsOK(ecode3)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
16548 }
16549 arg3 = static_cast< size_t >(val3);
16550 {
16551 PyThreadState* __tstate = wxPyBeginAllowThreads();
16552 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 #if wxUSE_UNICODE
16558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16559 #else
16560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16561 #endif
16562 }
16563 {
16564 if (temp1)
16565 delete arg1;
16566 }
16567 {
16568 if (temp2)
16569 delete arg2;
16570 }
16571 return resultobj;
16572 fail:
16573 {
16574 if (temp1)
16575 delete arg1;
16576 }
16577 {
16578 if (temp2)
16579 delete arg2;
16580 }
16581 return NULL;
16582 }
16583
16584
16585 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
16586 PyObject *resultobj = 0;
16587 wxString *arg1 = 0 ;
16588 wxString *arg2 = 0 ;
16589 size_t arg3 ;
16590 wxString *arg4 = 0 ;
16591 wxString result;
16592 bool temp1 = false ;
16593 bool temp2 = false ;
16594 size_t val3 ;
16595 int ecode3 = 0 ;
16596 bool temp4 = false ;
16597
16598 if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
16599 {
16600 arg1 = wxString_in_helper(swig_obj[0]);
16601 if (arg1 == NULL) SWIG_fail;
16602 temp1 = true;
16603 }
16604 {
16605 arg2 = wxString_in_helper(swig_obj[1]);
16606 if (arg2 == NULL) SWIG_fail;
16607 temp2 = true;
16608 }
16609 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
16610 if (!SWIG_IsOK(ecode3)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
16612 }
16613 arg3 = static_cast< size_t >(val3);
16614 {
16615 arg4 = wxString_in_helper(swig_obj[3]);
16616 if (arg4 == NULL) SWIG_fail;
16617 temp4 = true;
16618 }
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxString const &)*arg4);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 {
16626 #if wxUSE_UNICODE
16627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16628 #else
16629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16630 #endif
16631 }
16632 {
16633 if (temp1)
16634 delete arg1;
16635 }
16636 {
16637 if (temp2)
16638 delete arg2;
16639 }
16640 {
16641 if (temp4)
16642 delete arg4;
16643 }
16644 return resultobj;
16645 fail:
16646 {
16647 if (temp1)
16648 delete arg1;
16649 }
16650 {
16651 if (temp2)
16652 delete arg2;
16653 }
16654 {
16655 if (temp4)
16656 delete arg4;
16657 }
16658 return NULL;
16659 }
16660
16661
16662 SWIGINTERN PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
16663 int argc;
16664 PyObject *argv[5];
16665
16666 if (!(argc = SWIG_Python_UnpackTuple(args,"GetTranslation",0,4,argv))) SWIG_fail;
16667 --argc;
16668 if (argc == 1) {
16669 return _wrap_GetTranslation__SWIG_0(self, argc, argv);
16670 }
16671 if (argc == 2) {
16672 return _wrap_GetTranslation__SWIG_1(self, argc, argv);
16673 }
16674 if (argc == 3) {
16675 return _wrap_GetTranslation__SWIG_2(self, argc, argv);
16676 }
16677 if (argc == 4) {
16678 return _wrap_GetTranslation__SWIG_3(self, argc, argv);
16679 }
16680
16681 fail:
16682 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_new_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16688 PyObject *resultobj = 0;
16689 wxEncodingConverter *result = 0 ;
16690
16691 if (!SWIG_Python_UnpackTuple(args,"new_EncodingConverter",0,0,0)) SWIG_fail;
16692 {
16693 PyThreadState* __tstate = wxPyBeginAllowThreads();
16694 result = (wxEncodingConverter *)new wxEncodingConverter();
16695 wxPyEndAllowThreads(__tstate);
16696 if (PyErr_Occurred()) SWIG_fail;
16697 }
16698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_NEW | 0 );
16699 return resultobj;
16700 fail:
16701 return NULL;
16702 }
16703
16704
16705 SWIGINTERN PyObject *_wrap_delete_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16706 PyObject *resultobj = 0;
16707 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16708 void *argp1 = 0 ;
16709 int res1 = 0 ;
16710 PyObject *swig_obj[1] ;
16711
16712 if (!args) SWIG_fail;
16713 swig_obj[0] = args;
16714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_DISOWN | 0 );
16715 if (!SWIG_IsOK(res1)) {
16716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingConverter" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16717 }
16718 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 delete arg1;
16722
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 resultobj = SWIG_Py_Void();
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 SWIGINTERN PyObject *_wrap_EncodingConverter_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj = 0;
16735 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16736 wxFontEncoding arg2 ;
16737 wxFontEncoding arg3 ;
16738 int arg4 = (int) wxCONVERT_STRICT ;
16739 bool result;
16740 void *argp1 = 0 ;
16741 int res1 = 0 ;
16742 int val2 ;
16743 int ecode2 = 0 ;
16744 int val3 ;
16745 int ecode3 = 0 ;
16746 int val4 ;
16747 int ecode4 = 0 ;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 PyObject * obj2 = 0 ;
16751 PyObject * obj3 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Init" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16760 }
16761 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16762 ecode2 = SWIG_AsVal_int(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_Init" "', expected argument " "2"" of type '" "wxFontEncoding""'");
16765 }
16766 arg2 = static_cast< wxFontEncoding >(val2);
16767 ecode3 = SWIG_AsVal_int(obj2, &val3);
16768 if (!SWIG_IsOK(ecode3)) {
16769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EncodingConverter_Init" "', expected argument " "3"" of type '" "wxFontEncoding""'");
16770 }
16771 arg3 = static_cast< wxFontEncoding >(val3);
16772 if (obj3) {
16773 ecode4 = SWIG_AsVal_int(obj3, &val4);
16774 if (!SWIG_IsOK(ecode4)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EncodingConverter_Init" "', expected argument " "4"" of type '" "int""'");
16776 }
16777 arg4 = static_cast< int >(val4);
16778 }
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 result = (bool)(arg1)->Init(arg2,arg3,arg4);
16782 wxPyEndAllowThreads(__tstate);
16783 if (PyErr_Occurred()) SWIG_fail;
16784 }
16785 {
16786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16787 }
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_EncodingConverter_Convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj = 0;
16796 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
16797 wxString *arg2 = 0 ;
16798 wxString result;
16799 void *argp1 = 0 ;
16800 int res1 = 0 ;
16801 bool temp2 = false ;
16802 PyObject * obj0 = 0 ;
16803 PyObject * obj1 = 0 ;
16804 char * kwnames[] = {
16805 (char *) "self",(char *) "input", NULL
16806 };
16807
16808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) SWIG_fail;
16809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
16810 if (!SWIG_IsOK(res1)) {
16811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Convert" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
16812 }
16813 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
16814 {
16815 arg2 = wxString_in_helper(obj1);
16816 if (arg2 == NULL) SWIG_fail;
16817 temp2 = true;
16818 }
16819 {
16820 PyThreadState* __tstate = wxPyBeginAllowThreads();
16821 result = (arg1)->Convert((wxString const &)*arg2);
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 {
16826 #if wxUSE_UNICODE
16827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16828 #else
16829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16830 #endif
16831 }
16832 {
16833 if (temp2)
16834 delete arg2;
16835 }
16836 return resultobj;
16837 fail:
16838 {
16839 if (temp2)
16840 delete arg2;
16841 }
16842 return NULL;
16843 }
16844
16845
16846 SWIGINTERN PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj = 0;
16848 wxFontEncoding arg1 ;
16849 int arg2 = (int) wxPLATFORM_CURRENT ;
16850 wxFontEncodingArray result;
16851 int val1 ;
16852 int ecode1 = 0 ;
16853 int val2 ;
16854 int ecode2 = 0 ;
16855 PyObject * obj0 = 0 ;
16856 PyObject * obj1 = 0 ;
16857 char * kwnames[] = {
16858 (char *) "enc",(char *) "platform", NULL
16859 };
16860
16861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) SWIG_fail;
16862 ecode1 = SWIG_AsVal_int(obj0, &val1);
16863 if (!SWIG_IsOK(ecode1)) {
16864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16865 }
16866 arg1 = static_cast< wxFontEncoding >(val1);
16867 if (obj1) {
16868 ecode2 = SWIG_AsVal_int(obj1, &val2);
16869 if (!SWIG_IsOK(ecode2)) {
16870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "2"" of type '" "int""'");
16871 }
16872 arg2 = static_cast< int >(val2);
16873 }
16874 {
16875 PyThreadState* __tstate = wxPyBeginAllowThreads();
16876 result = wxEncodingConverter::GetPlatformEquivalents(arg1,arg2);
16877 wxPyEndAllowThreads(__tstate);
16878 if (PyErr_Occurred()) SWIG_fail;
16879 }
16880 {
16881 resultobj = PyList_New(0);
16882 for (size_t i=0; i < (&result)->GetCount(); i++) {
16883 PyObject* number = PyInt_FromLong((&result)->Item(i));
16884 PyList_Append(resultobj, number);
16885 Py_DECREF(number);
16886 }
16887 }
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj = 0;
16896 wxFontEncoding arg1 ;
16897 wxFontEncodingArray result;
16898 int val1 ;
16899 int ecode1 = 0 ;
16900 PyObject * obj0 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "enc", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) SWIG_fail;
16906 ecode1 = SWIG_AsVal_int(obj0, &val1);
16907 if (!SWIG_IsOK(ecode1)) {
16908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetAllEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16909 }
16910 arg1 = static_cast< wxFontEncoding >(val1);
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = wxEncodingConverter::GetAllEquivalents(arg1);
16914 wxPyEndAllowThreads(__tstate);
16915 if (PyErr_Occurred()) SWIG_fail;
16916 }
16917 {
16918 resultobj = PyList_New(0);
16919 for (size_t i=0; i < (&result)->GetCount(); i++) {
16920 PyObject* number = PyInt_FromLong((&result)->Item(i));
16921 PyList_Append(resultobj, number);
16922 Py_DECREF(number);
16923 }
16924 }
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_EncodingConverter_CanConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxFontEncoding arg1 ;
16934 wxFontEncoding arg2 ;
16935 bool result;
16936 int val1 ;
16937 int ecode1 = 0 ;
16938 int val2 ;
16939 int ecode2 = 0 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char * kwnames[] = {
16943 (char *) "encIn",(char *) "encOut", NULL
16944 };
16945
16946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) SWIG_fail;
16947 ecode1 = SWIG_AsVal_int(obj0, &val1);
16948 if (!SWIG_IsOK(ecode1)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_CanConvert" "', expected argument " "1"" of type '" "wxFontEncoding""'");
16950 }
16951 arg1 = static_cast< wxFontEncoding >(val1);
16952 ecode2 = SWIG_AsVal_int(obj1, &val2);
16953 if (!SWIG_IsOK(ecode2)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_CanConvert" "', expected argument " "2"" of type '" "wxFontEncoding""'");
16955 }
16956 arg2 = static_cast< wxFontEncoding >(val2);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (bool)wxEncodingConverter::CanConvert(arg1,arg2);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 {
16964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16965 }
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 SWIGINTERN PyObject *EncodingConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16973 PyObject *obj;
16974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16975 SWIG_TypeNewClientData(SWIGTYPE_p_wxEncodingConverter, SWIG_NewClientData(obj));
16976 return SWIG_Py_Void();
16977 }
16978
16979 SWIGINTERN PyObject *EncodingConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16980 return SWIG_Python_InitShadowInstance(args);
16981 }
16982
16983 SWIGINTERN PyObject *_wrap_delete_DC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16984 PyObject *resultobj = 0;
16985 wxDC *arg1 = (wxDC *) 0 ;
16986 void *argp1 = 0 ;
16987 int res1 = 0 ;
16988 PyObject *swig_obj[1] ;
16989
16990 if (!args) SWIG_fail;
16991 swig_obj[0] = args;
16992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, SWIG_POINTER_DISOWN | 0 );
16993 if (!SWIG_IsOK(res1)) {
16994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DC" "', expected argument " "1"" of type '" "wxDC *""'");
16995 }
16996 arg1 = reinterpret_cast< wxDC * >(argp1);
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 delete arg1;
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 resultobj = SWIG_Py_Void();
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 SWIGINTERN PyObject *_wrap_DC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj = 0;
17013 wxDC *arg1 = (wxDC *) 0 ;
17014 int arg2 ;
17015 int arg3 ;
17016 wxColour *arg4 = 0 ;
17017 int arg5 = (int) wxFLOOD_SURFACE ;
17018 bool result;
17019 void *argp1 = 0 ;
17020 int res1 = 0 ;
17021 int val2 ;
17022 int ecode2 = 0 ;
17023 int val3 ;
17024 int ecode3 = 0 ;
17025 wxColour temp4 ;
17026 int val5 ;
17027 int ecode5 = 0 ;
17028 PyObject * obj0 = 0 ;
17029 PyObject * obj1 = 0 ;
17030 PyObject * obj2 = 0 ;
17031 PyObject * obj3 = 0 ;
17032 PyObject * obj4 = 0 ;
17033 char * kwnames[] = {
17034 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
17035 };
17036
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFill" "', expected argument " "1"" of type '" "wxDC *""'");
17041 }
17042 arg1 = reinterpret_cast< wxDC * >(argp1);
17043 ecode2 = SWIG_AsVal_int(obj1, &val2);
17044 if (!SWIG_IsOK(ecode2)) {
17045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_FloodFill" "', expected argument " "2"" of type '" "int""'");
17046 }
17047 arg2 = static_cast< int >(val2);
17048 ecode3 = SWIG_AsVal_int(obj2, &val3);
17049 if (!SWIG_IsOK(ecode3)) {
17050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_FloodFill" "', expected argument " "3"" of type '" "int""'");
17051 }
17052 arg3 = static_cast< int >(val3);
17053 {
17054 arg4 = &temp4;
17055 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17056 }
17057 if (obj4) {
17058 ecode5 = SWIG_AsVal_int(obj4, &val5);
17059 if (!SWIG_IsOK(ecode5)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_FloodFill" "', expected argument " "5"" of type '" "int""'");
17061 }
17062 arg5 = static_cast< int >(val5);
17063 }
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17072 }
17073 return resultobj;
17074 fail:
17075 return NULL;
17076 }
17077
17078
17079 SWIGINTERN PyObject *_wrap_DC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17080 PyObject *resultobj = 0;
17081 wxDC *arg1 = (wxDC *) 0 ;
17082 wxPoint *arg2 = 0 ;
17083 wxColour *arg3 = 0 ;
17084 int arg4 = (int) wxFLOOD_SURFACE ;
17085 bool result;
17086 void *argp1 = 0 ;
17087 int res1 = 0 ;
17088 wxPoint temp2 ;
17089 wxColour temp3 ;
17090 int val4 ;
17091 int ecode4 = 0 ;
17092 PyObject * obj0 = 0 ;
17093 PyObject * obj1 = 0 ;
17094 PyObject * obj2 = 0 ;
17095 PyObject * obj3 = 0 ;
17096 char * kwnames[] = {
17097 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
17098 };
17099
17100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17102 if (!SWIG_IsOK(res1)) {
17103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFillPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17104 }
17105 arg1 = reinterpret_cast< wxDC * >(argp1);
17106 {
17107 arg2 = &temp2;
17108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17109 }
17110 {
17111 arg3 = &temp3;
17112 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17113 }
17114 if (obj3) {
17115 ecode4 = SWIG_AsVal_int(obj3, &val4);
17116 if (!SWIG_IsOK(ecode4)) {
17117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
17118 }
17119 arg4 = static_cast< int >(val4);
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17129 }
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 SWIGINTERN PyObject *_wrap_DC_GradientFillConcentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj = 0;
17138 wxDC *arg1 = (wxDC *) 0 ;
17139 wxRect *arg2 = 0 ;
17140 wxColour *arg3 = 0 ;
17141 wxColour *arg4 = 0 ;
17142 wxPoint *arg5 = 0 ;
17143 void *argp1 = 0 ;
17144 int res1 = 0 ;
17145 wxRect temp2 ;
17146 wxColour temp3 ;
17147 wxColour temp4 ;
17148 wxPoint temp5 ;
17149 PyObject * obj0 = 0 ;
17150 PyObject * obj1 = 0 ;
17151 PyObject * obj2 = 0 ;
17152 PyObject * obj3 = 0 ;
17153 PyObject * obj4 = 0 ;
17154 char * kwnames[] = {
17155 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "circleCenter", NULL
17156 };
17157
17158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_GradientFillConcentric",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17160 if (!SWIG_IsOK(res1)) {
17161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillConcentric" "', expected argument " "1"" of type '" "wxDC *""'");
17162 }
17163 arg1 = reinterpret_cast< wxDC * >(argp1);
17164 {
17165 arg2 = &temp2;
17166 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17167 }
17168 {
17169 arg3 = &temp3;
17170 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17171 }
17172 {
17173 arg4 = &temp4;
17174 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17175 }
17176 {
17177 arg5 = &temp5;
17178 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 (arg1)->GradientFillConcentric((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_Py_Void();
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_DC_GradientFillLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = 0;
17195 wxDC *arg1 = (wxDC *) 0 ;
17196 wxRect *arg2 = 0 ;
17197 wxColour *arg3 = 0 ;
17198 wxColour *arg4 = 0 ;
17199 wxDirection arg5 = (wxDirection) wxEAST ;
17200 void *argp1 = 0 ;
17201 int res1 = 0 ;
17202 wxRect temp2 ;
17203 wxColour temp3 ;
17204 wxColour temp4 ;
17205 int val5 ;
17206 int ecode5 = 0 ;
17207 PyObject * obj0 = 0 ;
17208 PyObject * obj1 = 0 ;
17209 PyObject * obj2 = 0 ;
17210 PyObject * obj3 = 0 ;
17211 PyObject * obj4 = 0 ;
17212 char * kwnames[] = {
17213 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "nDirection", NULL
17214 };
17215
17216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_GradientFillLinear",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17218 if (!SWIG_IsOK(res1)) {
17219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillLinear" "', expected argument " "1"" of type '" "wxDC *""'");
17220 }
17221 arg1 = reinterpret_cast< wxDC * >(argp1);
17222 {
17223 arg2 = &temp2;
17224 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17225 }
17226 {
17227 arg3 = &temp3;
17228 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17229 }
17230 {
17231 arg4 = &temp4;
17232 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17233 }
17234 if (obj4) {
17235 ecode5 = SWIG_AsVal_int(obj4, &val5);
17236 if (!SWIG_IsOK(ecode5)) {
17237 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_GradientFillLinear" "', expected argument " "5"" of type '" "wxDirection""'");
17238 }
17239 arg5 = static_cast< wxDirection >(val5);
17240 }
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 (arg1)->GradientFillLinear((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,arg5);
17244 wxPyEndAllowThreads(__tstate);
17245 if (PyErr_Occurred()) SWIG_fail;
17246 }
17247 resultobj = SWIG_Py_Void();
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *_wrap_DC_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj = 0;
17256 wxDC *arg1 = (wxDC *) 0 ;
17257 int arg2 ;
17258 int arg3 ;
17259 wxColour result;
17260 void *argp1 = 0 ;
17261 int res1 = 0 ;
17262 int val2 ;
17263 int ecode2 = 0 ;
17264 int val3 ;
17265 int ecode3 = 0 ;
17266 PyObject * obj0 = 0 ;
17267 PyObject * obj1 = 0 ;
17268 PyObject * obj2 = 0 ;
17269 char * kwnames[] = {
17270 (char *) "self",(char *) "x",(char *) "y", NULL
17271 };
17272
17273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17275 if (!SWIG_IsOK(res1)) {
17276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixel" "', expected argument " "1"" of type '" "wxDC *""'");
17277 }
17278 arg1 = reinterpret_cast< wxDC * >(argp1);
17279 ecode2 = SWIG_AsVal_int(obj1, &val2);
17280 if (!SWIG_IsOK(ecode2)) {
17281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_GetPixel" "', expected argument " "2"" of type '" "int""'");
17282 }
17283 arg2 = static_cast< int >(val2);
17284 ecode3 = SWIG_AsVal_int(obj2, &val3);
17285 if (!SWIG_IsOK(ecode3)) {
17286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_GetPixel" "', expected argument " "3"" of type '" "int""'");
17287 }
17288 arg3 = static_cast< int >(val3);
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = wxDC_GetPixel(arg1,arg2,arg3);
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17296 return resultobj;
17297 fail:
17298 return NULL;
17299 }
17300
17301
17302 SWIGINTERN PyObject *_wrap_DC_GetPixelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj = 0;
17304 wxDC *arg1 = (wxDC *) 0 ;
17305 wxPoint *arg2 = 0 ;
17306 wxColour result;
17307 void *argp1 = 0 ;
17308 int res1 = 0 ;
17309 wxPoint temp2 ;
17310 PyObject * obj0 = 0 ;
17311 PyObject * obj1 = 0 ;
17312 char * kwnames[] = {
17313 (char *) "self",(char *) "pt", NULL
17314 };
17315
17316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17318 if (!SWIG_IsOK(res1)) {
17319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixelPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17320 }
17321 arg1 = reinterpret_cast< wxDC * >(argp1);
17322 {
17323 arg2 = &temp2;
17324 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17325 }
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *_wrap_DC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj = 0;
17341 wxDC *arg1 = (wxDC *) 0 ;
17342 int arg2 ;
17343 int arg3 ;
17344 int arg4 ;
17345 int arg5 ;
17346 void *argp1 = 0 ;
17347 int res1 = 0 ;
17348 int val2 ;
17349 int ecode2 = 0 ;
17350 int val3 ;
17351 int ecode3 = 0 ;
17352 int val4 ;
17353 int ecode4 = 0 ;
17354 int val5 ;
17355 int ecode5 = 0 ;
17356 PyObject * obj0 = 0 ;
17357 PyObject * obj1 = 0 ;
17358 PyObject * obj2 = 0 ;
17359 PyObject * obj3 = 0 ;
17360 PyObject * obj4 = 0 ;
17361 char * kwnames[] = {
17362 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
17363 };
17364
17365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17367 if (!SWIG_IsOK(res1)) {
17368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLine" "', expected argument " "1"" of type '" "wxDC *""'");
17369 }
17370 arg1 = reinterpret_cast< wxDC * >(argp1);
17371 ecode2 = SWIG_AsVal_int(obj1, &val2);
17372 if (!SWIG_IsOK(ecode2)) {
17373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawLine" "', expected argument " "2"" of type '" "int""'");
17374 }
17375 arg2 = static_cast< int >(val2);
17376 ecode3 = SWIG_AsVal_int(obj2, &val3);
17377 if (!SWIG_IsOK(ecode3)) {
17378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawLine" "', expected argument " "3"" of type '" "int""'");
17379 }
17380 arg3 = static_cast< int >(val3);
17381 ecode4 = SWIG_AsVal_int(obj3, &val4);
17382 if (!SWIG_IsOK(ecode4)) {
17383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLine" "', expected argument " "4"" of type '" "int""'");
17384 }
17385 arg4 = static_cast< int >(val4);
17386 ecode5 = SWIG_AsVal_int(obj4, &val5);
17387 if (!SWIG_IsOK(ecode5)) {
17388 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLine" "', expected argument " "5"" of type '" "int""'");
17389 }
17390 arg5 = static_cast< int >(val5);
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_Py_Void();
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *_wrap_DC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj = 0;
17406 wxDC *arg1 = (wxDC *) 0 ;
17407 wxPoint *arg2 = 0 ;
17408 wxPoint *arg3 = 0 ;
17409 void *argp1 = 0 ;
17410 int res1 = 0 ;
17411 wxPoint temp2 ;
17412 wxPoint temp3 ;
17413 PyObject * obj0 = 0 ;
17414 PyObject * obj1 = 0 ;
17415 PyObject * obj2 = 0 ;
17416 char * kwnames[] = {
17417 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
17418 };
17419
17420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17422 if (!SWIG_IsOK(res1)) {
17423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLinePoint" "', expected argument " "1"" of type '" "wxDC *""'");
17424 }
17425 arg1 = reinterpret_cast< wxDC * >(argp1);
17426 {
17427 arg2 = &temp2;
17428 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17429 }
17430 {
17431 arg3 = &temp3;
17432 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17433 }
17434 {
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 resultobj = SWIG_Py_Void();
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 SWIGINTERN PyObject *_wrap_DC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj = 0;
17449 wxDC *arg1 = (wxDC *) 0 ;
17450 int arg2 ;
17451 int arg3 ;
17452 void *argp1 = 0 ;
17453 int res1 = 0 ;
17454 int val2 ;
17455 int ecode2 = 0 ;
17456 int val3 ;
17457 int ecode3 = 0 ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 char * kwnames[] = {
17462 (char *) "self",(char *) "x",(char *) "y", NULL
17463 };
17464
17465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17467 if (!SWIG_IsOK(res1)) {
17468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHair" "', expected argument " "1"" of type '" "wxDC *""'");
17469 }
17470 arg1 = reinterpret_cast< wxDC * >(argp1);
17471 ecode2 = SWIG_AsVal_int(obj1, &val2);
17472 if (!SWIG_IsOK(ecode2)) {
17473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CrossHair" "', expected argument " "2"" of type '" "int""'");
17474 }
17475 arg2 = static_cast< int >(val2);
17476 ecode3 = SWIG_AsVal_int(obj2, &val3);
17477 if (!SWIG_IsOK(ecode3)) {
17478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CrossHair" "', expected argument " "3"" of type '" "int""'");
17479 }
17480 arg3 = static_cast< int >(val3);
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 (arg1)->CrossHair(arg2,arg3);
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 resultobj = SWIG_Py_Void();
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 SWIGINTERN PyObject *_wrap_DC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj = 0;
17496 wxDC *arg1 = (wxDC *) 0 ;
17497 wxPoint *arg2 = 0 ;
17498 void *argp1 = 0 ;
17499 int res1 = 0 ;
17500 wxPoint temp2 ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 char * kwnames[] = {
17504 (char *) "self",(char *) "pt", NULL
17505 };
17506
17507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17509 if (!SWIG_IsOK(res1)) {
17510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHairPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17511 }
17512 arg1 = reinterpret_cast< wxDC * >(argp1);
17513 {
17514 arg2 = &temp2;
17515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17516 }
17517 {
17518 PyThreadState* __tstate = wxPyBeginAllowThreads();
17519 (arg1)->CrossHair((wxPoint const &)*arg2);
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 resultobj = SWIG_Py_Void();
17524 return resultobj;
17525 fail:
17526 return NULL;
17527 }
17528
17529
17530 SWIGINTERN PyObject *_wrap_DC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17531 PyObject *resultobj = 0;
17532 wxDC *arg1 = (wxDC *) 0 ;
17533 int arg2 ;
17534 int arg3 ;
17535 int arg4 ;
17536 int arg5 ;
17537 int arg6 ;
17538 int arg7 ;
17539 void *argp1 = 0 ;
17540 int res1 = 0 ;
17541 int val2 ;
17542 int ecode2 = 0 ;
17543 int val3 ;
17544 int ecode3 = 0 ;
17545 int val4 ;
17546 int ecode4 = 0 ;
17547 int val5 ;
17548 int ecode5 = 0 ;
17549 int val6 ;
17550 int ecode6 = 0 ;
17551 int val7 ;
17552 int ecode7 = 0 ;
17553 PyObject * obj0 = 0 ;
17554 PyObject * obj1 = 0 ;
17555 PyObject * obj2 = 0 ;
17556 PyObject * obj3 = 0 ;
17557 PyObject * obj4 = 0 ;
17558 PyObject * obj5 = 0 ;
17559 PyObject * obj6 = 0 ;
17560 char * kwnames[] = {
17561 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
17562 };
17563
17564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17566 if (!SWIG_IsOK(res1)) {
17567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArc" "', expected argument " "1"" of type '" "wxDC *""'");
17568 }
17569 arg1 = reinterpret_cast< wxDC * >(argp1);
17570 ecode2 = SWIG_AsVal_int(obj1, &val2);
17571 if (!SWIG_IsOK(ecode2)) {
17572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawArc" "', expected argument " "2"" of type '" "int""'");
17573 }
17574 arg2 = static_cast< int >(val2);
17575 ecode3 = SWIG_AsVal_int(obj2, &val3);
17576 if (!SWIG_IsOK(ecode3)) {
17577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawArc" "', expected argument " "3"" of type '" "int""'");
17578 }
17579 arg3 = static_cast< int >(val3);
17580 ecode4 = SWIG_AsVal_int(obj3, &val4);
17581 if (!SWIG_IsOK(ecode4)) {
17582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawArc" "', expected argument " "4"" of type '" "int""'");
17583 }
17584 arg4 = static_cast< int >(val4);
17585 ecode5 = SWIG_AsVal_int(obj4, &val5);
17586 if (!SWIG_IsOK(ecode5)) {
17587 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawArc" "', expected argument " "5"" of type '" "int""'");
17588 }
17589 arg5 = static_cast< int >(val5);
17590 ecode6 = SWIG_AsVal_int(obj5, &val6);
17591 if (!SWIG_IsOK(ecode6)) {
17592 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawArc" "', expected argument " "6"" of type '" "int""'");
17593 }
17594 arg6 = static_cast< int >(val6);
17595 ecode7 = SWIG_AsVal_int(obj6, &val7);
17596 if (!SWIG_IsOK(ecode7)) {
17597 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawArc" "', expected argument " "7"" of type '" "int""'");
17598 }
17599 arg7 = static_cast< int >(val7);
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
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_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj = 0;
17615 wxDC *arg1 = (wxDC *) 0 ;
17616 wxPoint *arg2 = 0 ;
17617 wxPoint *arg3 = 0 ;
17618 wxPoint *arg4 = 0 ;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 wxPoint temp2 ;
17622 wxPoint temp3 ;
17623 wxPoint temp4 ;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 PyObject * obj2 = 0 ;
17627 PyObject * obj3 = 0 ;
17628 char * kwnames[] = {
17629 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
17630 };
17631
17632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17634 if (!SWIG_IsOK(res1)) {
17635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArcPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17636 }
17637 arg1 = reinterpret_cast< wxDC * >(argp1);
17638 {
17639 arg2 = &temp2;
17640 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17641 }
17642 {
17643 arg3 = &temp3;
17644 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17645 }
17646 {
17647 arg4 = &temp4;
17648 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
17649 }
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 resultobj = SWIG_Py_Void();
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 SWIGINTERN PyObject *_wrap_DC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj = 0;
17665 wxDC *arg1 = (wxDC *) 0 ;
17666 int arg2 ;
17667 int arg3 ;
17668 int arg4 ;
17669 int arg5 ;
17670 void *argp1 = 0 ;
17671 int res1 = 0 ;
17672 int val2 ;
17673 int ecode2 = 0 ;
17674 int val3 ;
17675 int ecode3 = 0 ;
17676 int val4 ;
17677 int ecode4 = 0 ;
17678 int val5 ;
17679 int ecode5 = 0 ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 PyObject * obj2 = 0 ;
17683 PyObject * obj3 = 0 ;
17684 PyObject * obj4 = 0 ;
17685 char * kwnames[] = {
17686 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
17687 };
17688
17689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17691 if (!SWIG_IsOK(res1)) {
17692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMark" "', expected argument " "1"" of type '" "wxDC *""'");
17693 }
17694 arg1 = reinterpret_cast< wxDC * >(argp1);
17695 ecode2 = SWIG_AsVal_int(obj1, &val2);
17696 if (!SWIG_IsOK(ecode2)) {
17697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
17698 }
17699 arg2 = static_cast< int >(val2);
17700 ecode3 = SWIG_AsVal_int(obj2, &val3);
17701 if (!SWIG_IsOK(ecode3)) {
17702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
17703 }
17704 arg3 = static_cast< int >(val3);
17705 ecode4 = SWIG_AsVal_int(obj3, &val4);
17706 if (!SWIG_IsOK(ecode4)) {
17707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
17708 }
17709 arg4 = static_cast< int >(val4);
17710 ecode5 = SWIG_AsVal_int(obj4, &val5);
17711 if (!SWIG_IsOK(ecode5)) {
17712 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
17713 }
17714 arg5 = static_cast< int >(val5);
17715 {
17716 PyThreadState* __tstate = wxPyBeginAllowThreads();
17717 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
17718 wxPyEndAllowThreads(__tstate);
17719 if (PyErr_Occurred()) SWIG_fail;
17720 }
17721 resultobj = SWIG_Py_Void();
17722 return resultobj;
17723 fail:
17724 return NULL;
17725 }
17726
17727
17728 SWIGINTERN PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17729 PyObject *resultobj = 0;
17730 wxDC *arg1 = (wxDC *) 0 ;
17731 wxRect *arg2 = 0 ;
17732 void *argp1 = 0 ;
17733 int res1 = 0 ;
17734 wxRect temp2 ;
17735 PyObject * obj0 = 0 ;
17736 PyObject * obj1 = 0 ;
17737 char * kwnames[] = {
17738 (char *) "self",(char *) "rect", NULL
17739 };
17740
17741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
17742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17743 if (!SWIG_IsOK(res1)) {
17744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxDC *""'");
17745 }
17746 arg1 = reinterpret_cast< wxDC * >(argp1);
17747 {
17748 arg2 = &temp2;
17749 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17750 }
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 (arg1)->DrawCheckMark((wxRect const &)*arg2);
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 resultobj = SWIG_Py_Void();
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxDC *arg1 = (wxDC *) 0 ;
17767 int arg2 ;
17768 int arg3 ;
17769 int arg4 ;
17770 int arg5 ;
17771 double arg6 ;
17772 double arg7 ;
17773 void *argp1 = 0 ;
17774 int res1 = 0 ;
17775 int val2 ;
17776 int ecode2 = 0 ;
17777 int val3 ;
17778 int ecode3 = 0 ;
17779 int val4 ;
17780 int ecode4 = 0 ;
17781 int val5 ;
17782 int ecode5 = 0 ;
17783 double val6 ;
17784 int ecode6 = 0 ;
17785 double val7 ;
17786 int ecode7 = 0 ;
17787 PyObject * obj0 = 0 ;
17788 PyObject * obj1 = 0 ;
17789 PyObject * obj2 = 0 ;
17790 PyObject * obj3 = 0 ;
17791 PyObject * obj4 = 0 ;
17792 PyObject * obj5 = 0 ;
17793 PyObject * obj6 = 0 ;
17794 char * kwnames[] = {
17795 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
17796 };
17797
17798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxDC *""'");
17802 }
17803 arg1 = reinterpret_cast< wxDC * >(argp1);
17804 ecode2 = SWIG_AsVal_int(obj1, &val2);
17805 if (!SWIG_IsOK(ecode2)) {
17806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
17807 }
17808 arg2 = static_cast< int >(val2);
17809 ecode3 = SWIG_AsVal_int(obj2, &val3);
17810 if (!SWIG_IsOK(ecode3)) {
17811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
17812 }
17813 arg3 = static_cast< int >(val3);
17814 ecode4 = SWIG_AsVal_int(obj3, &val4);
17815 if (!SWIG_IsOK(ecode4)) {
17816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
17817 }
17818 arg4 = static_cast< int >(val4);
17819 ecode5 = SWIG_AsVal_int(obj4, &val5);
17820 if (!SWIG_IsOK(ecode5)) {
17821 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
17822 }
17823 arg5 = static_cast< int >(val5);
17824 ecode6 = SWIG_AsVal_double(obj5, &val6);
17825 if (!SWIG_IsOK(ecode6)) {
17826 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
17827 }
17828 arg6 = static_cast< double >(val6);
17829 ecode7 = SWIG_AsVal_double(obj6, &val7);
17830 if (!SWIG_IsOK(ecode7)) {
17831 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
17832 }
17833 arg7 = static_cast< double >(val7);
17834 {
17835 PyThreadState* __tstate = wxPyBeginAllowThreads();
17836 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 resultobj = SWIG_Py_Void();
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj = 0;
17849 wxDC *arg1 = (wxDC *) 0 ;
17850 wxPoint *arg2 = 0 ;
17851 wxSize *arg3 = 0 ;
17852 double arg4 ;
17853 double arg5 ;
17854 void *argp1 = 0 ;
17855 int res1 = 0 ;
17856 wxPoint temp2 ;
17857 wxSize temp3 ;
17858 double val4 ;
17859 int ecode4 = 0 ;
17860 double val5 ;
17861 int ecode5 = 0 ;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 PyObject * obj2 = 0 ;
17865 PyObject * obj3 = 0 ;
17866 PyObject * obj4 = 0 ;
17867 char * kwnames[] = {
17868 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
17869 };
17870
17871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17873 if (!SWIG_IsOK(res1)) {
17874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
17875 }
17876 arg1 = reinterpret_cast< wxDC * >(argp1);
17877 {
17878 arg2 = &temp2;
17879 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17880 }
17881 {
17882 arg3 = &temp3;
17883 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17884 }
17885 ecode4 = SWIG_AsVal_double(obj3, &val4);
17886 if (!SWIG_IsOK(ecode4)) {
17887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
17888 }
17889 arg4 = static_cast< double >(val4);
17890 ecode5 = SWIG_AsVal_double(obj4, &val5);
17891 if (!SWIG_IsOK(ecode5)) {
17892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
17893 }
17894 arg5 = static_cast< double >(val5);
17895 {
17896 PyThreadState* __tstate = wxPyBeginAllowThreads();
17897 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
17898 wxPyEndAllowThreads(__tstate);
17899 if (PyErr_Occurred()) SWIG_fail;
17900 }
17901 resultobj = SWIG_Py_Void();
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 SWIGINTERN PyObject *_wrap_DC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17909 PyObject *resultobj = 0;
17910 wxDC *arg1 = (wxDC *) 0 ;
17911 int arg2 ;
17912 int arg3 ;
17913 void *argp1 = 0 ;
17914 int res1 = 0 ;
17915 int val2 ;
17916 int ecode2 = 0 ;
17917 int val3 ;
17918 int ecode3 = 0 ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 PyObject * obj2 = 0 ;
17922 char * kwnames[] = {
17923 (char *) "self",(char *) "x",(char *) "y", NULL
17924 };
17925
17926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17930 }
17931 arg1 = reinterpret_cast< wxDC * >(argp1);
17932 ecode2 = SWIG_AsVal_int(obj1, &val2);
17933 if (!SWIG_IsOK(ecode2)) {
17934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
17935 }
17936 arg2 = static_cast< int >(val2);
17937 ecode3 = SWIG_AsVal_int(obj2, &val3);
17938 if (!SWIG_IsOK(ecode3)) {
17939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
17940 }
17941 arg3 = static_cast< int >(val3);
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 (arg1)->DrawPoint(arg2,arg3);
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_Py_Void();
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_DC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = 0;
17957 wxDC *arg1 = (wxDC *) 0 ;
17958 wxPoint *arg2 = 0 ;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 wxPoint temp2 ;
17962 PyObject * obj0 = 0 ;
17963 PyObject * obj1 = 0 ;
17964 char * kwnames[] = {
17965 (char *) "self",(char *) "pt", NULL
17966 };
17967
17968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) 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_DrawPointPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17972 }
17973 arg1 = reinterpret_cast< wxDC * >(argp1);
17974 {
17975 arg2 = &temp2;
17976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17977 }
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 (arg1)->DrawPoint((wxPoint const &)*arg2);
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 resultobj = SWIG_Py_Void();
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 SWIGINTERN PyObject *_wrap_DC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj = 0;
17993 wxDC *arg1 = (wxDC *) 0 ;
17994 int arg2 ;
17995 int arg3 ;
17996 int arg4 ;
17997 int arg5 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 int val2 ;
18001 int ecode2 = 0 ;
18002 int val3 ;
18003 int ecode3 = 0 ;
18004 int val4 ;
18005 int ecode4 = 0 ;
18006 int val5 ;
18007 int ecode5 = 0 ;
18008 PyObject * obj0 = 0 ;
18009 PyObject * obj1 = 0 ;
18010 PyObject * obj2 = 0 ;
18011 PyObject * obj3 = 0 ;
18012 PyObject * obj4 = 0 ;
18013 char * kwnames[] = {
18014 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18015 };
18016
18017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18021 }
18022 arg1 = reinterpret_cast< wxDC * >(argp1);
18023 ecode2 = SWIG_AsVal_int(obj1, &val2);
18024 if (!SWIG_IsOK(ecode2)) {
18025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
18026 }
18027 arg2 = static_cast< int >(val2);
18028 ecode3 = SWIG_AsVal_int(obj2, &val3);
18029 if (!SWIG_IsOK(ecode3)) {
18030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
18031 }
18032 arg3 = static_cast< int >(val3);
18033 ecode4 = SWIG_AsVal_int(obj3, &val4);
18034 if (!SWIG_IsOK(ecode4)) {
18035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
18036 }
18037 arg4 = static_cast< int >(val4);
18038 ecode5 = SWIG_AsVal_int(obj4, &val5);
18039 if (!SWIG_IsOK(ecode5)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
18041 }
18042 arg5 = static_cast< int >(val5);
18043 {
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 resultobj = SWIG_Py_Void();
18050 return resultobj;
18051 fail:
18052 return NULL;
18053 }
18054
18055
18056 SWIGINTERN PyObject *_wrap_DC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj = 0;
18058 wxDC *arg1 = (wxDC *) 0 ;
18059 wxRect *arg2 = 0 ;
18060 void *argp1 = 0 ;
18061 int res1 = 0 ;
18062 wxRect temp2 ;
18063 PyObject * obj0 = 0 ;
18064 PyObject * obj1 = 0 ;
18065 char * kwnames[] = {
18066 (char *) "self",(char *) "rect", NULL
18067 };
18068
18069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
18070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18073 }
18074 arg1 = reinterpret_cast< wxDC * >(argp1);
18075 {
18076 arg2 = &temp2;
18077 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18078 }
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 (arg1)->DrawRectangle((wxRect const &)*arg2);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 resultobj = SWIG_Py_Void();
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 SWIGINTERN PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj = 0;
18094 wxDC *arg1 = (wxDC *) 0 ;
18095 wxPoint *arg2 = 0 ;
18096 wxSize *arg3 = 0 ;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 wxPoint temp2 ;
18100 wxSize temp3 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 char * kwnames[] = {
18105 (char *) "self",(char *) "pt",(char *) "sz", NULL
18106 };
18107
18108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18110 if (!SWIG_IsOK(res1)) {
18111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18112 }
18113 arg1 = reinterpret_cast< wxDC * >(argp1);
18114 {
18115 arg2 = &temp2;
18116 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18117 }
18118 {
18119 arg3 = &temp3;
18120 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18121 }
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = SWIG_Py_Void();
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj = 0;
18137 wxDC *arg1 = (wxDC *) 0 ;
18138 int arg2 ;
18139 int arg3 ;
18140 int arg4 ;
18141 int arg5 ;
18142 double arg6 ;
18143 void *argp1 = 0 ;
18144 int res1 = 0 ;
18145 int val2 ;
18146 int ecode2 = 0 ;
18147 int val3 ;
18148 int ecode3 = 0 ;
18149 int val4 ;
18150 int ecode4 = 0 ;
18151 int val5 ;
18152 int ecode5 = 0 ;
18153 double val6 ;
18154 int ecode6 = 0 ;
18155 PyObject * obj0 = 0 ;
18156 PyObject * obj1 = 0 ;
18157 PyObject * obj2 = 0 ;
18158 PyObject * obj3 = 0 ;
18159 PyObject * obj4 = 0 ;
18160 PyObject * obj5 = 0 ;
18161 char * kwnames[] = {
18162 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
18163 };
18164
18165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18169 }
18170 arg1 = reinterpret_cast< wxDC * >(argp1);
18171 ecode2 = SWIG_AsVal_int(obj1, &val2);
18172 if (!SWIG_IsOK(ecode2)) {
18173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
18174 }
18175 arg2 = static_cast< int >(val2);
18176 ecode3 = SWIG_AsVal_int(obj2, &val3);
18177 if (!SWIG_IsOK(ecode3)) {
18178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
18179 }
18180 arg3 = static_cast< int >(val3);
18181 ecode4 = SWIG_AsVal_int(obj3, &val4);
18182 if (!SWIG_IsOK(ecode4)) {
18183 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
18184 }
18185 arg4 = static_cast< int >(val4);
18186 ecode5 = SWIG_AsVal_int(obj4, &val5);
18187 if (!SWIG_IsOK(ecode5)) {
18188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
18189 }
18190 arg5 = static_cast< int >(val5);
18191 ecode6 = SWIG_AsVal_double(obj5, &val6);
18192 if (!SWIG_IsOK(ecode6)) {
18193 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
18194 }
18195 arg6 = static_cast< double >(val6);
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 resultobj = SWIG_Py_Void();
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18210 PyObject *resultobj = 0;
18211 wxDC *arg1 = (wxDC *) 0 ;
18212 wxRect *arg2 = 0 ;
18213 double arg3 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 wxRect temp2 ;
18217 double val3 ;
18218 int ecode3 = 0 ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 PyObject * obj2 = 0 ;
18222 char * kwnames[] = {
18223 (char *) "self",(char *) "r",(char *) "radius", NULL
18224 };
18225
18226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18230 }
18231 arg1 = reinterpret_cast< wxDC * >(argp1);
18232 {
18233 arg2 = &temp2;
18234 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18235 }
18236 ecode3 = SWIG_AsVal_double(obj2, &val3);
18237 if (!SWIG_IsOK(ecode3)) {
18238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
18239 }
18240 arg3 = static_cast< double >(val3);
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = SWIG_Py_Void();
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj = 0;
18256 wxDC *arg1 = (wxDC *) 0 ;
18257 wxPoint *arg2 = 0 ;
18258 wxSize *arg3 = 0 ;
18259 double arg4 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 wxPoint temp2 ;
18263 wxSize temp3 ;
18264 double val4 ;
18265 int ecode4 = 0 ;
18266 PyObject * obj0 = 0 ;
18267 PyObject * obj1 = 0 ;
18268 PyObject * obj2 = 0 ;
18269 PyObject * obj3 = 0 ;
18270 char * kwnames[] = {
18271 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
18272 };
18273
18274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18278 }
18279 arg1 = reinterpret_cast< wxDC * >(argp1);
18280 {
18281 arg2 = &temp2;
18282 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18283 }
18284 {
18285 arg3 = &temp3;
18286 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18287 }
18288 ecode4 = SWIG_AsVal_double(obj3, &val4);
18289 if (!SWIG_IsOK(ecode4)) {
18290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
18291 }
18292 arg4 = static_cast< double >(val4);
18293 {
18294 PyThreadState* __tstate = wxPyBeginAllowThreads();
18295 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
18296 wxPyEndAllowThreads(__tstate);
18297 if (PyErr_Occurred()) SWIG_fail;
18298 }
18299 resultobj = SWIG_Py_Void();
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 SWIGINTERN PyObject *_wrap_DC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj = 0;
18308 wxDC *arg1 = (wxDC *) 0 ;
18309 int arg2 ;
18310 int arg3 ;
18311 int arg4 ;
18312 void *argp1 = 0 ;
18313 int res1 = 0 ;
18314 int val2 ;
18315 int ecode2 = 0 ;
18316 int val3 ;
18317 int ecode3 = 0 ;
18318 int val4 ;
18319 int ecode4 = 0 ;
18320 PyObject * obj0 = 0 ;
18321 PyObject * obj1 = 0 ;
18322 PyObject * obj2 = 0 ;
18323 PyObject * obj3 = 0 ;
18324 char * kwnames[] = {
18325 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
18326 };
18327
18328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCircle" "', expected argument " "1"" of type '" "wxDC *""'");
18332 }
18333 arg1 = reinterpret_cast< wxDC * >(argp1);
18334 ecode2 = SWIG_AsVal_int(obj1, &val2);
18335 if (!SWIG_IsOK(ecode2)) {
18336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
18337 }
18338 arg2 = static_cast< int >(val2);
18339 ecode3 = SWIG_AsVal_int(obj2, &val3);
18340 if (!SWIG_IsOK(ecode3)) {
18341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
18342 }
18343 arg3 = static_cast< int >(val3);
18344 ecode4 = SWIG_AsVal_int(obj3, &val4);
18345 if (!SWIG_IsOK(ecode4)) {
18346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
18347 }
18348 arg4 = static_cast< int >(val4);
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 (arg1)->DrawCircle(arg2,arg3,arg4);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_Py_Void();
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_DC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj = 0;
18364 wxDC *arg1 = (wxDC *) 0 ;
18365 wxPoint *arg2 = 0 ;
18366 int arg3 ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 wxPoint temp2 ;
18370 int val3 ;
18371 int ecode3 = 0 ;
18372 PyObject * obj0 = 0 ;
18373 PyObject * obj1 = 0 ;
18374 PyObject * obj2 = 0 ;
18375 char * kwnames[] = {
18376 (char *) "self",(char *) "pt",(char *) "radius", NULL
18377 };
18378
18379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18381 if (!SWIG_IsOK(res1)) {
18382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxDC *""'");
18383 }
18384 arg1 = reinterpret_cast< wxDC * >(argp1);
18385 {
18386 arg2 = &temp2;
18387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18388 }
18389 ecode3 = SWIG_AsVal_int(obj2, &val3);
18390 if (!SWIG_IsOK(ecode3)) {
18391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
18392 }
18393 arg3 = static_cast< int >(val3);
18394 {
18395 PyThreadState* __tstate = wxPyBeginAllowThreads();
18396 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
18397 wxPyEndAllowThreads(__tstate);
18398 if (PyErr_Occurred()) SWIG_fail;
18399 }
18400 resultobj = SWIG_Py_Void();
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_DC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj = 0;
18409 wxDC *arg1 = (wxDC *) 0 ;
18410 int arg2 ;
18411 int arg3 ;
18412 int arg4 ;
18413 int arg5 ;
18414 void *argp1 = 0 ;
18415 int res1 = 0 ;
18416 int val2 ;
18417 int ecode2 = 0 ;
18418 int val3 ;
18419 int ecode3 = 0 ;
18420 int val4 ;
18421 int ecode4 = 0 ;
18422 int val5 ;
18423 int ecode5 = 0 ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 PyObject * obj2 = 0 ;
18427 PyObject * obj3 = 0 ;
18428 PyObject * obj4 = 0 ;
18429 char * kwnames[] = {
18430 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18431 };
18432
18433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18435 if (!SWIG_IsOK(res1)) {
18436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipse" "', expected argument " "1"" of type '" "wxDC *""'");
18437 }
18438 arg1 = reinterpret_cast< wxDC * >(argp1);
18439 ecode2 = SWIG_AsVal_int(obj1, &val2);
18440 if (!SWIG_IsOK(ecode2)) {
18441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
18442 }
18443 arg2 = static_cast< int >(val2);
18444 ecode3 = SWIG_AsVal_int(obj2, &val3);
18445 if (!SWIG_IsOK(ecode3)) {
18446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
18447 }
18448 arg3 = static_cast< int >(val3);
18449 ecode4 = SWIG_AsVal_int(obj3, &val4);
18450 if (!SWIG_IsOK(ecode4)) {
18451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
18452 }
18453 arg4 = static_cast< int >(val4);
18454 ecode5 = SWIG_AsVal_int(obj4, &val5);
18455 if (!SWIG_IsOK(ecode5)) {
18456 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
18457 }
18458 arg5 = static_cast< int >(val5);
18459 {
18460 PyThreadState* __tstate = wxPyBeginAllowThreads();
18461 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 resultobj = SWIG_Py_Void();
18466 return resultobj;
18467 fail:
18468 return NULL;
18469 }
18470
18471
18472 SWIGINTERN PyObject *_wrap_DC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18473 PyObject *resultobj = 0;
18474 wxDC *arg1 = (wxDC *) 0 ;
18475 wxRect *arg2 = 0 ;
18476 void *argp1 = 0 ;
18477 int res1 = 0 ;
18478 wxRect temp2 ;
18479 PyObject * obj0 = 0 ;
18480 PyObject * obj1 = 0 ;
18481 char * kwnames[] = {
18482 (char *) "self",(char *) "rect", NULL
18483 };
18484
18485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
18486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18487 if (!SWIG_IsOK(res1)) {
18488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxDC *""'");
18489 }
18490 arg1 = reinterpret_cast< wxDC * >(argp1);
18491 {
18492 arg2 = &temp2;
18493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18494 }
18495 {
18496 PyThreadState* __tstate = wxPyBeginAllowThreads();
18497 (arg1)->DrawEllipse((wxRect const &)*arg2);
18498 wxPyEndAllowThreads(__tstate);
18499 if (PyErr_Occurred()) SWIG_fail;
18500 }
18501 resultobj = SWIG_Py_Void();
18502 return resultobj;
18503 fail:
18504 return NULL;
18505 }
18506
18507
18508 SWIGINTERN PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18509 PyObject *resultobj = 0;
18510 wxDC *arg1 = (wxDC *) 0 ;
18511 wxPoint *arg2 = 0 ;
18512 wxSize *arg3 = 0 ;
18513 void *argp1 = 0 ;
18514 int res1 = 0 ;
18515 wxPoint temp2 ;
18516 wxSize temp3 ;
18517 PyObject * obj0 = 0 ;
18518 PyObject * obj1 = 0 ;
18519 PyObject * obj2 = 0 ;
18520 char * kwnames[] = {
18521 (char *) "self",(char *) "pt",(char *) "sz", NULL
18522 };
18523
18524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18526 if (!SWIG_IsOK(res1)) {
18527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18528 }
18529 arg1 = reinterpret_cast< wxDC * >(argp1);
18530 {
18531 arg2 = &temp2;
18532 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18533 }
18534 {
18535 arg3 = &temp3;
18536 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18537 }
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 resultobj = SWIG_Py_Void();
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_DC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18552 PyObject *resultobj = 0;
18553 wxDC *arg1 = (wxDC *) 0 ;
18554 wxIcon *arg2 = 0 ;
18555 int arg3 ;
18556 int arg4 ;
18557 void *argp1 = 0 ;
18558 int res1 = 0 ;
18559 void *argp2 = 0 ;
18560 int res2 = 0 ;
18561 int val3 ;
18562 int ecode3 = 0 ;
18563 int val4 ;
18564 int ecode4 = 0 ;
18565 PyObject * obj0 = 0 ;
18566 PyObject * obj1 = 0 ;
18567 PyObject * obj2 = 0 ;
18568 PyObject * obj3 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIcon" "', expected argument " "1"" of type '" "wxDC *""'");
18577 }
18578 arg1 = reinterpret_cast< wxDC * >(argp1);
18579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
18580 if (!SWIG_IsOK(res2)) {
18581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
18582 }
18583 if (!argp2) {
18584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
18585 }
18586 arg2 = reinterpret_cast< wxIcon * >(argp2);
18587 ecode3 = SWIG_AsVal_int(obj2, &val3);
18588 if (!SWIG_IsOK(ecode3)) {
18589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
18590 }
18591 arg3 = static_cast< int >(val3);
18592 ecode4 = SWIG_AsVal_int(obj3, &val4);
18593 if (!SWIG_IsOK(ecode4)) {
18594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
18595 }
18596 arg4 = static_cast< int >(val4);
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 resultobj = SWIG_Py_Void();
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 SWIGINTERN PyObject *_wrap_DC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18611 PyObject *resultobj = 0;
18612 wxDC *arg1 = (wxDC *) 0 ;
18613 wxIcon *arg2 = 0 ;
18614 wxPoint *arg3 = 0 ;
18615 void *argp1 = 0 ;
18616 int res1 = 0 ;
18617 void *argp2 = 0 ;
18618 int res2 = 0 ;
18619 wxPoint temp3 ;
18620 PyObject * obj0 = 0 ;
18621 PyObject * obj1 = 0 ;
18622 PyObject * obj2 = 0 ;
18623 char * kwnames[] = {
18624 (char *) "self",(char *) "icon",(char *) "pt", NULL
18625 };
18626
18627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18629 if (!SWIG_IsOK(res1)) {
18630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIconPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18631 }
18632 arg1 = reinterpret_cast< wxDC * >(argp1);
18633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
18634 if (!SWIG_IsOK(res2)) {
18635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
18636 }
18637 if (!argp2) {
18638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
18639 }
18640 arg2 = reinterpret_cast< wxIcon * >(argp2);
18641 {
18642 arg3 = &temp3;
18643 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18644 }
18645 {
18646 PyThreadState* __tstate = wxPyBeginAllowThreads();
18647 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
18648 wxPyEndAllowThreads(__tstate);
18649 if (PyErr_Occurred()) SWIG_fail;
18650 }
18651 resultobj = SWIG_Py_Void();
18652 return resultobj;
18653 fail:
18654 return NULL;
18655 }
18656
18657
18658 SWIGINTERN PyObject *_wrap_DC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18659 PyObject *resultobj = 0;
18660 wxDC *arg1 = (wxDC *) 0 ;
18661 wxBitmap *arg2 = 0 ;
18662 int arg3 ;
18663 int arg4 ;
18664 bool arg5 = (bool) false ;
18665 void *argp1 = 0 ;
18666 int res1 = 0 ;
18667 void *argp2 = 0 ;
18668 int res2 = 0 ;
18669 int val3 ;
18670 int ecode3 = 0 ;
18671 int val4 ;
18672 int ecode4 = 0 ;
18673 bool val5 ;
18674 int ecode5 = 0 ;
18675 PyObject * obj0 = 0 ;
18676 PyObject * obj1 = 0 ;
18677 PyObject * obj2 = 0 ;
18678 PyObject * obj3 = 0 ;
18679 PyObject * obj4 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmap" "', expected argument " "1"" of type '" "wxDC *""'");
18688 }
18689 arg1 = reinterpret_cast< wxDC * >(argp1);
18690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
18691 if (!SWIG_IsOK(res2)) {
18692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18693 }
18694 if (!argp2) {
18695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18696 }
18697 arg2 = reinterpret_cast< wxBitmap * >(argp2);
18698 ecode3 = SWIG_AsVal_int(obj2, &val3);
18699 if (!SWIG_IsOK(ecode3)) {
18700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
18701 }
18702 arg3 = static_cast< int >(val3);
18703 ecode4 = SWIG_AsVal_int(obj3, &val4);
18704 if (!SWIG_IsOK(ecode4)) {
18705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
18706 }
18707 arg4 = static_cast< int >(val4);
18708 if (obj4) {
18709 ecode5 = SWIG_AsVal_bool(obj4, &val5);
18710 if (!SWIG_IsOK(ecode5)) {
18711 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
18712 }
18713 arg5 = static_cast< bool >(val5);
18714 }
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_Py_Void();
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_DC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18729 PyObject *resultobj = 0;
18730 wxDC *arg1 = (wxDC *) 0 ;
18731 wxBitmap *arg2 = 0 ;
18732 wxPoint *arg3 = 0 ;
18733 bool arg4 = (bool) false ;
18734 void *argp1 = 0 ;
18735 int res1 = 0 ;
18736 void *argp2 = 0 ;
18737 int res2 = 0 ;
18738 wxPoint temp3 ;
18739 bool val4 ;
18740 int ecode4 = 0 ;
18741 PyObject * obj0 = 0 ;
18742 PyObject * obj1 = 0 ;
18743 PyObject * obj2 = 0 ;
18744 PyObject * obj3 = 0 ;
18745 char * kwnames[] = {
18746 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
18747 };
18748
18749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18751 if (!SWIG_IsOK(res1)) {
18752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18753 }
18754 arg1 = reinterpret_cast< wxDC * >(argp1);
18755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
18756 if (!SWIG_IsOK(res2)) {
18757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18758 }
18759 if (!argp2) {
18760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
18761 }
18762 arg2 = reinterpret_cast< wxBitmap * >(argp2);
18763 {
18764 arg3 = &temp3;
18765 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18766 }
18767 if (obj3) {
18768 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18769 if (!SWIG_IsOK(ecode4)) {
18770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
18771 }
18772 arg4 = static_cast< bool >(val4);
18773 }
18774 {
18775 PyThreadState* __tstate = wxPyBeginAllowThreads();
18776 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
18777 wxPyEndAllowThreads(__tstate);
18778 if (PyErr_Occurred()) SWIG_fail;
18779 }
18780 resultobj = SWIG_Py_Void();
18781 return resultobj;
18782 fail:
18783 return NULL;
18784 }
18785
18786
18787 SWIGINTERN PyObject *_wrap_DC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18788 PyObject *resultobj = 0;
18789 wxDC *arg1 = (wxDC *) 0 ;
18790 wxString *arg2 = 0 ;
18791 int arg3 ;
18792 int arg4 ;
18793 void *argp1 = 0 ;
18794 int res1 = 0 ;
18795 bool temp2 = false ;
18796 int val3 ;
18797 int ecode3 = 0 ;
18798 int val4 ;
18799 int ecode4 = 0 ;
18800 PyObject * obj0 = 0 ;
18801 PyObject * obj1 = 0 ;
18802 PyObject * obj2 = 0 ;
18803 PyObject * obj3 = 0 ;
18804 char * kwnames[] = {
18805 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
18806 };
18807
18808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18810 if (!SWIG_IsOK(res1)) {
18811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawText" "', expected argument " "1"" of type '" "wxDC *""'");
18812 }
18813 arg1 = reinterpret_cast< wxDC * >(argp1);
18814 {
18815 arg2 = wxString_in_helper(obj1);
18816 if (arg2 == NULL) SWIG_fail;
18817 temp2 = true;
18818 }
18819 ecode3 = SWIG_AsVal_int(obj2, &val3);
18820 if (!SWIG_IsOK(ecode3)) {
18821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawText" "', expected argument " "3"" of type '" "int""'");
18822 }
18823 arg3 = static_cast< int >(val3);
18824 ecode4 = SWIG_AsVal_int(obj3, &val4);
18825 if (!SWIG_IsOK(ecode4)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawText" "', expected argument " "4"" of type '" "int""'");
18827 }
18828 arg4 = static_cast< int >(val4);
18829 {
18830 PyThreadState* __tstate = wxPyBeginAllowThreads();
18831 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 resultobj = SWIG_Py_Void();
18836 {
18837 if (temp2)
18838 delete arg2;
18839 }
18840 return resultobj;
18841 fail:
18842 {
18843 if (temp2)
18844 delete arg2;
18845 }
18846 return NULL;
18847 }
18848
18849
18850 SWIGINTERN PyObject *_wrap_DC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj = 0;
18852 wxDC *arg1 = (wxDC *) 0 ;
18853 wxString *arg2 = 0 ;
18854 wxPoint *arg3 = 0 ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 bool temp2 = false ;
18858 wxPoint temp3 ;
18859 PyObject * obj0 = 0 ;
18860 PyObject * obj1 = 0 ;
18861 PyObject * obj2 = 0 ;
18862 char * kwnames[] = {
18863 (char *) "self",(char *) "text",(char *) "pt", NULL
18864 };
18865
18866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18868 if (!SWIG_IsOK(res1)) {
18869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18870 }
18871 arg1 = reinterpret_cast< wxDC * >(argp1);
18872 {
18873 arg2 = wxString_in_helper(obj1);
18874 if (arg2 == NULL) SWIG_fail;
18875 temp2 = true;
18876 }
18877 {
18878 arg3 = &temp3;
18879 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18880 }
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 resultobj = SWIG_Py_Void();
18888 {
18889 if (temp2)
18890 delete arg2;
18891 }
18892 return resultobj;
18893 fail:
18894 {
18895 if (temp2)
18896 delete arg2;
18897 }
18898 return NULL;
18899 }
18900
18901
18902 SWIGINTERN PyObject *_wrap_DC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj = 0;
18904 wxDC *arg1 = (wxDC *) 0 ;
18905 wxString *arg2 = 0 ;
18906 int arg3 ;
18907 int arg4 ;
18908 double arg5 ;
18909 void *argp1 = 0 ;
18910 int res1 = 0 ;
18911 bool temp2 = false ;
18912 int val3 ;
18913 int ecode3 = 0 ;
18914 int val4 ;
18915 int ecode4 = 0 ;
18916 double val5 ;
18917 int ecode5 = 0 ;
18918 PyObject * obj0 = 0 ;
18919 PyObject * obj1 = 0 ;
18920 PyObject * obj2 = 0 ;
18921 PyObject * obj3 = 0 ;
18922 PyObject * obj4 = 0 ;
18923 char * kwnames[] = {
18924 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
18925 };
18926
18927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18929 if (!SWIG_IsOK(res1)) {
18930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedText" "', expected argument " "1"" of type '" "wxDC *""'");
18931 }
18932 arg1 = reinterpret_cast< wxDC * >(argp1);
18933 {
18934 arg2 = wxString_in_helper(obj1);
18935 if (arg2 == NULL) SWIG_fail;
18936 temp2 = true;
18937 }
18938 ecode3 = SWIG_AsVal_int(obj2, &val3);
18939 if (!SWIG_IsOK(ecode3)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
18941 }
18942 arg3 = static_cast< int >(val3);
18943 ecode4 = SWIG_AsVal_int(obj3, &val4);
18944 if (!SWIG_IsOK(ecode4)) {
18945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
18946 }
18947 arg4 = static_cast< int >(val4);
18948 ecode5 = SWIG_AsVal_double(obj4, &val5);
18949 if (!SWIG_IsOK(ecode5)) {
18950 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
18951 }
18952 arg5 = static_cast< double >(val5);
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_Py_Void();
18960 {
18961 if (temp2)
18962 delete arg2;
18963 }
18964 return resultobj;
18965 fail:
18966 {
18967 if (temp2)
18968 delete arg2;
18969 }
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj = 0;
18976 wxDC *arg1 = (wxDC *) 0 ;
18977 wxString *arg2 = 0 ;
18978 wxPoint *arg3 = 0 ;
18979 double arg4 ;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 bool temp2 = false ;
18983 wxPoint temp3 ;
18984 double val4 ;
18985 int ecode4 = 0 ;
18986 PyObject * obj0 = 0 ;
18987 PyObject * obj1 = 0 ;
18988 PyObject * obj2 = 0 ;
18989 PyObject * obj3 = 0 ;
18990 char * kwnames[] = {
18991 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
18992 };
18993
18994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18996 if (!SWIG_IsOK(res1)) {
18997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18998 }
18999 arg1 = reinterpret_cast< wxDC * >(argp1);
19000 {
19001 arg2 = wxString_in_helper(obj1);
19002 if (arg2 == NULL) SWIG_fail;
19003 temp2 = true;
19004 }
19005 {
19006 arg3 = &temp3;
19007 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19008 }
19009 ecode4 = SWIG_AsVal_double(obj3, &val4);
19010 if (!SWIG_IsOK(ecode4)) {
19011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
19012 }
19013 arg4 = static_cast< double >(val4);
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 resultobj = SWIG_Py_Void();
19021 {
19022 if (temp2)
19023 delete arg2;
19024 }
19025 return resultobj;
19026 fail:
19027 {
19028 if (temp2)
19029 delete arg2;
19030 }
19031 return NULL;
19032 }
19033
19034
19035 SWIGINTERN PyObject *_wrap_DC_Blit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj = 0;
19037 wxDC *arg1 = (wxDC *) 0 ;
19038 int arg2 ;
19039 int arg3 ;
19040 int arg4 ;
19041 int arg5 ;
19042 wxDC *arg6 = (wxDC *) 0 ;
19043 int arg7 ;
19044 int arg8 ;
19045 int arg9 = (int) wxCOPY ;
19046 bool arg10 = (bool) false ;
19047 int arg11 = (int) -1 ;
19048 int arg12 = (int) -1 ;
19049 bool result;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 int val2 ;
19053 int ecode2 = 0 ;
19054 int val3 ;
19055 int ecode3 = 0 ;
19056 int val4 ;
19057 int ecode4 = 0 ;
19058 int val5 ;
19059 int ecode5 = 0 ;
19060 void *argp6 = 0 ;
19061 int res6 = 0 ;
19062 int val7 ;
19063 int ecode7 = 0 ;
19064 int val8 ;
19065 int ecode8 = 0 ;
19066 int val9 ;
19067 int ecode9 = 0 ;
19068 bool val10 ;
19069 int ecode10 = 0 ;
19070 int val11 ;
19071 int ecode11 = 0 ;
19072 int val12 ;
19073 int ecode12 = 0 ;
19074 PyObject * obj0 = 0 ;
19075 PyObject * obj1 = 0 ;
19076 PyObject * obj2 = 0 ;
19077 PyObject * obj3 = 0 ;
19078 PyObject * obj4 = 0 ;
19079 PyObject * obj5 = 0 ;
19080 PyObject * obj6 = 0 ;
19081 PyObject * obj7 = 0 ;
19082 PyObject * obj8 = 0 ;
19083 PyObject * obj9 = 0 ;
19084 PyObject * obj10 = 0 ;
19085 PyObject * obj11 = 0 ;
19086 char * kwnames[] = {
19087 (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
19088 };
19089
19090 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;
19091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19092 if (!SWIG_IsOK(res1)) {
19093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Blit" "', expected argument " "1"" of type '" "wxDC *""'");
19094 }
19095 arg1 = reinterpret_cast< wxDC * >(argp1);
19096 ecode2 = SWIG_AsVal_int(obj1, &val2);
19097 if (!SWIG_IsOK(ecode2)) {
19098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_Blit" "', expected argument " "2"" of type '" "int""'");
19099 }
19100 arg2 = static_cast< int >(val2);
19101 ecode3 = SWIG_AsVal_int(obj2, &val3);
19102 if (!SWIG_IsOK(ecode3)) {
19103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_Blit" "', expected argument " "3"" of type '" "int""'");
19104 }
19105 arg3 = static_cast< int >(val3);
19106 ecode4 = SWIG_AsVal_int(obj3, &val4);
19107 if (!SWIG_IsOK(ecode4)) {
19108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_Blit" "', expected argument " "4"" of type '" "int""'");
19109 }
19110 arg4 = static_cast< int >(val4);
19111 ecode5 = SWIG_AsVal_int(obj4, &val5);
19112 if (!SWIG_IsOK(ecode5)) {
19113 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_Blit" "', expected argument " "5"" of type '" "int""'");
19114 }
19115 arg5 = static_cast< int >(val5);
19116 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );
19117 if (!SWIG_IsOK(res6)) {
19118 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_Blit" "', expected argument " "6"" of type '" "wxDC *""'");
19119 }
19120 arg6 = reinterpret_cast< wxDC * >(argp6);
19121 ecode7 = SWIG_AsVal_int(obj6, &val7);
19122 if (!SWIG_IsOK(ecode7)) {
19123 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_Blit" "', expected argument " "7"" of type '" "int""'");
19124 }
19125 arg7 = static_cast< int >(val7);
19126 ecode8 = SWIG_AsVal_int(obj7, &val8);
19127 if (!SWIG_IsOK(ecode8)) {
19128 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DC_Blit" "', expected argument " "8"" of type '" "int""'");
19129 }
19130 arg8 = static_cast< int >(val8);
19131 if (obj8) {
19132 ecode9 = SWIG_AsVal_int(obj8, &val9);
19133 if (!SWIG_IsOK(ecode9)) {
19134 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DC_Blit" "', expected argument " "9"" of type '" "int""'");
19135 }
19136 arg9 = static_cast< int >(val9);
19137 }
19138 if (obj9) {
19139 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19140 if (!SWIG_IsOK(ecode10)) {
19141 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DC_Blit" "', expected argument " "10"" of type '" "bool""'");
19142 }
19143 arg10 = static_cast< bool >(val10);
19144 }
19145 if (obj10) {
19146 ecode11 = SWIG_AsVal_int(obj10, &val11);
19147 if (!SWIG_IsOK(ecode11)) {
19148 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DC_Blit" "', expected argument " "11"" of type '" "int""'");
19149 }
19150 arg11 = static_cast< int >(val11);
19151 }
19152 if (obj11) {
19153 ecode12 = SWIG_AsVal_int(obj11, &val12);
19154 if (!SWIG_IsOK(ecode12)) {
19155 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DC_Blit" "', expected argument " "12"" of type '" "int""'");
19156 }
19157 arg12 = static_cast< int >(val12);
19158 }
19159 {
19160 PyThreadState* __tstate = wxPyBeginAllowThreads();
19161 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 {
19166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19167 }
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_DC_BlitPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj = 0;
19176 wxDC *arg1 = (wxDC *) 0 ;
19177 wxPoint *arg2 = 0 ;
19178 wxSize *arg3 = 0 ;
19179 wxDC *arg4 = (wxDC *) 0 ;
19180 wxPoint *arg5 = 0 ;
19181 int arg6 = (int) wxCOPY ;
19182 bool arg7 = (bool) false ;
19183 wxPoint const &arg8_defvalue = wxDefaultPosition ;
19184 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
19185 bool result;
19186 void *argp1 = 0 ;
19187 int res1 = 0 ;
19188 wxPoint temp2 ;
19189 wxSize temp3 ;
19190 void *argp4 = 0 ;
19191 int res4 = 0 ;
19192 wxPoint temp5 ;
19193 int val6 ;
19194 int ecode6 = 0 ;
19195 bool val7 ;
19196 int ecode7 = 0 ;
19197 wxPoint temp8 ;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 PyObject * obj2 = 0 ;
19201 PyObject * obj3 = 0 ;
19202 PyObject * obj4 = 0 ;
19203 PyObject * obj5 = 0 ;
19204 PyObject * obj6 = 0 ;
19205 PyObject * obj7 = 0 ;
19206 char * kwnames[] = {
19207 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
19208 };
19209
19210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
19211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_BlitPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19214 }
19215 arg1 = reinterpret_cast< wxDC * >(argp1);
19216 {
19217 arg2 = &temp2;
19218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19219 }
19220 {
19221 arg3 = &temp3;
19222 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19223 }
19224 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxDC, 0 | 0 );
19225 if (!SWIG_IsOK(res4)) {
19226 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DC_BlitPointSize" "', expected argument " "4"" of type '" "wxDC *""'");
19227 }
19228 arg4 = reinterpret_cast< wxDC * >(argp4);
19229 {
19230 arg5 = &temp5;
19231 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
19232 }
19233 if (obj5) {
19234 ecode6 = SWIG_AsVal_int(obj5, &val6);
19235 if (!SWIG_IsOK(ecode6)) {
19236 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_BlitPointSize" "', expected argument " "6"" of type '" "int""'");
19237 }
19238 arg6 = static_cast< int >(val6);
19239 }
19240 if (obj6) {
19241 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19242 if (!SWIG_IsOK(ecode7)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_BlitPointSize" "', expected argument " "7"" of type '" "bool""'");
19244 }
19245 arg7 = static_cast< bool >(val7);
19246 }
19247 if (obj7) {
19248 {
19249 arg8 = &temp8;
19250 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
19251 }
19252 }
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 {
19260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19261 }
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_DC_SetClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj = 0;
19270 wxDC *arg1 = (wxDC *) 0 ;
19271 int arg2 ;
19272 int arg3 ;
19273 int arg4 ;
19274 int arg5 ;
19275 void *argp1 = 0 ;
19276 int res1 = 0 ;
19277 int val2 ;
19278 int ecode2 = 0 ;
19279 int val3 ;
19280 int ecode3 = 0 ;
19281 int val4 ;
19282 int ecode4 = 0 ;
19283 int val5 ;
19284 int ecode5 = 0 ;
19285 PyObject * obj0 = 0 ;
19286 PyObject * obj1 = 0 ;
19287 PyObject * obj2 = 0 ;
19288 PyObject * obj3 = 0 ;
19289 PyObject * obj4 = 0 ;
19290 char * kwnames[] = {
19291 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19292 };
19293
19294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
19298 }
19299 arg1 = reinterpret_cast< wxDC * >(argp1);
19300 ecode2 = SWIG_AsVal_int(obj1, &val2);
19301 if (!SWIG_IsOK(ecode2)) {
19302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetClippingRegion" "', expected argument " "2"" of type '" "int""'");
19303 }
19304 arg2 = static_cast< int >(val2);
19305 ecode3 = SWIG_AsVal_int(obj2, &val3);
19306 if (!SWIG_IsOK(ecode3)) {
19307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetClippingRegion" "', expected argument " "3"" of type '" "int""'");
19308 }
19309 arg3 = static_cast< int >(val3);
19310 ecode4 = SWIG_AsVal_int(obj3, &val4);
19311 if (!SWIG_IsOK(ecode4)) {
19312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_SetClippingRegion" "', expected argument " "4"" of type '" "int""'");
19313 }
19314 arg4 = static_cast< int >(val4);
19315 ecode5 = SWIG_AsVal_int(obj4, &val5);
19316 if (!SWIG_IsOK(ecode5)) {
19317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_SetClippingRegion" "', expected argument " "5"" of type '" "int""'");
19318 }
19319 arg5 = static_cast< int >(val5);
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_Py_Void();
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj = 0;
19335 wxDC *arg1 = (wxDC *) 0 ;
19336 wxPoint *arg2 = 0 ;
19337 wxSize *arg3 = 0 ;
19338 void *argp1 = 0 ;
19339 int res1 = 0 ;
19340 wxPoint temp2 ;
19341 wxSize temp3 ;
19342 PyObject * obj0 = 0 ;
19343 PyObject * obj1 = 0 ;
19344 PyObject * obj2 = 0 ;
19345 char * kwnames[] = {
19346 (char *) "self",(char *) "pt",(char *) "sz", NULL
19347 };
19348
19349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19351 if (!SWIG_IsOK(res1)) {
19352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19353 }
19354 arg1 = reinterpret_cast< wxDC * >(argp1);
19355 {
19356 arg2 = &temp2;
19357 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19358 }
19359 {
19360 arg3 = &temp3;
19361 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19362 }
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 resultobj = SWIG_Py_Void();
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj = 0;
19378 wxDC *arg1 = (wxDC *) 0 ;
19379 wxRegion *arg2 = 0 ;
19380 void *argp1 = 0 ;
19381 int res1 = 0 ;
19382 void *argp2 = 0 ;
19383 int res2 = 0 ;
19384 PyObject * obj0 = 0 ;
19385 PyObject * obj1 = 0 ;
19386 char * kwnames[] = {
19387 (char *) "self",(char *) "region", NULL
19388 };
19389
19390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) SWIG_fail;
19391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19392 if (!SWIG_IsOK(res1)) {
19393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "1"" of type '" "wxDC *""'");
19394 }
19395 arg1 = reinterpret_cast< wxDC * >(argp1);
19396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
19397 if (!SWIG_IsOK(res2)) {
19398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
19399 }
19400 if (!argp2) {
19401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
19402 }
19403 arg2 = reinterpret_cast< wxRegion * >(argp2);
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 resultobj = SWIG_Py_Void();
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 SWIGINTERN PyObject *_wrap_DC_SetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj = 0;
19419 wxDC *arg1 = (wxDC *) 0 ;
19420 wxRect *arg2 = 0 ;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 wxRect temp2 ;
19424 PyObject * obj0 = 0 ;
19425 PyObject * obj1 = 0 ;
19426 char * kwnames[] = {
19427 (char *) "self",(char *) "rect", NULL
19428 };
19429
19430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) SWIG_fail;
19431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19432 if (!SWIG_IsOK(res1)) {
19433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
19434 }
19435 arg1 = reinterpret_cast< wxDC * >(argp1);
19436 {
19437 arg2 = &temp2;
19438 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19439 }
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 (arg1)->SetClippingRegion((wxRect const &)*arg2);
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_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj = 0;
19455 wxDC *arg1 = (wxDC *) 0 ;
19456 int arg2 ;
19457 wxPoint *arg3 = (wxPoint *) 0 ;
19458 int arg4 = (int) 0 ;
19459 int arg5 = (int) 0 ;
19460 void *argp1 = 0 ;
19461 int res1 = 0 ;
19462 int val4 ;
19463 int ecode4 = 0 ;
19464 int val5 ;
19465 int ecode5 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 PyObject * obj2 = 0 ;
19469 PyObject * obj3 = 0 ;
19470 char * kwnames[] = {
19471 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
19472 };
19473
19474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19476 if (!SWIG_IsOK(res1)) {
19477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLines" "', expected argument " "1"" of type '" "wxDC *""'");
19478 }
19479 arg1 = reinterpret_cast< wxDC * >(argp1);
19480 {
19481 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19482 if (arg3 == NULL) SWIG_fail;
19483 }
19484 if (obj2) {
19485 ecode4 = SWIG_AsVal_int(obj2, &val4);
19486 if (!SWIG_IsOK(ecode4)) {
19487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLines" "', expected argument " "4"" of type '" "int""'");
19488 }
19489 arg4 = static_cast< int >(val4);
19490 }
19491 if (obj3) {
19492 ecode5 = SWIG_AsVal_int(obj3, &val5);
19493 if (!SWIG_IsOK(ecode5)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLines" "', expected argument " "5"" of type '" "int""'");
19495 }
19496 arg5 = static_cast< int >(val5);
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_Py_Void();
19505 {
19506 if (arg3) delete [] arg3;
19507 }
19508 return resultobj;
19509 fail:
19510 {
19511 if (arg3) delete [] arg3;
19512 }
19513 return NULL;
19514 }
19515
19516
19517 SWIGINTERN PyObject *_wrap_DC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj = 0;
19519 wxDC *arg1 = (wxDC *) 0 ;
19520 int arg2 ;
19521 wxPoint *arg3 = (wxPoint *) 0 ;
19522 int arg4 = (int) 0 ;
19523 int arg5 = (int) 0 ;
19524 int arg6 = (int) wxODDEVEN_RULE ;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 int val4 ;
19528 int ecode4 = 0 ;
19529 int val5 ;
19530 int ecode5 = 0 ;
19531 int val6 ;
19532 int ecode6 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 PyObject * obj3 = 0 ;
19537 PyObject * obj4 = 0 ;
19538 char * kwnames[] = {
19539 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
19540 };
19541
19542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19544 if (!SWIG_IsOK(res1)) {
19545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPolygon" "', expected argument " "1"" of type '" "wxDC *""'");
19546 }
19547 arg1 = reinterpret_cast< wxDC * >(argp1);
19548 {
19549 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19550 if (arg3 == NULL) SWIG_fail;
19551 }
19552 if (obj2) {
19553 ecode4 = SWIG_AsVal_int(obj2, &val4);
19554 if (!SWIG_IsOK(ecode4)) {
19555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
19556 }
19557 arg4 = static_cast< int >(val4);
19558 }
19559 if (obj3) {
19560 ecode5 = SWIG_AsVal_int(obj3, &val5);
19561 if (!SWIG_IsOK(ecode5)) {
19562 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
19563 }
19564 arg5 = static_cast< int >(val5);
19565 }
19566 if (obj4) {
19567 ecode6 = SWIG_AsVal_int(obj4, &val6);
19568 if (!SWIG_IsOK(ecode6)) {
19569 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
19570 }
19571 arg6 = static_cast< int >(val6);
19572 }
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_Py_Void();
19580 {
19581 if (arg3) delete [] arg3;
19582 }
19583 return resultobj;
19584 fail:
19585 {
19586 if (arg3) delete [] arg3;
19587 }
19588 return NULL;
19589 }
19590
19591
19592 SWIGINTERN PyObject *_wrap_DC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19593 PyObject *resultobj = 0;
19594 wxDC *arg1 = (wxDC *) 0 ;
19595 wxString *arg2 = 0 ;
19596 wxRect *arg3 = 0 ;
19597 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
19598 int arg5 = (int) -1 ;
19599 void *argp1 = 0 ;
19600 int res1 = 0 ;
19601 bool temp2 = false ;
19602 wxRect temp3 ;
19603 int val4 ;
19604 int ecode4 = 0 ;
19605 int val5 ;
19606 int ecode5 = 0 ;
19607 PyObject * obj0 = 0 ;
19608 PyObject * obj1 = 0 ;
19609 PyObject * obj2 = 0 ;
19610 PyObject * obj3 = 0 ;
19611 PyObject * obj4 = 0 ;
19612 char * kwnames[] = {
19613 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
19614 };
19615
19616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19618 if (!SWIG_IsOK(res1)) {
19619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLabel" "', expected argument " "1"" of type '" "wxDC *""'");
19620 }
19621 arg1 = reinterpret_cast< wxDC * >(argp1);
19622 {
19623 arg2 = wxString_in_helper(obj1);
19624 if (arg2 == NULL) SWIG_fail;
19625 temp2 = true;
19626 }
19627 {
19628 arg3 = &temp3;
19629 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
19630 }
19631 if (obj3) {
19632 ecode4 = SWIG_AsVal_int(obj3, &val4);
19633 if (!SWIG_IsOK(ecode4)) {
19634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
19635 }
19636 arg4 = static_cast< int >(val4);
19637 }
19638 if (obj4) {
19639 ecode5 = SWIG_AsVal_int(obj4, &val5);
19640 if (!SWIG_IsOK(ecode5)) {
19641 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
19642 }
19643 arg5 = static_cast< int >(val5);
19644 }
19645 {
19646 PyThreadState* __tstate = wxPyBeginAllowThreads();
19647 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 resultobj = SWIG_Py_Void();
19652 {
19653 if (temp2)
19654 delete arg2;
19655 }
19656 return resultobj;
19657 fail:
19658 {
19659 if (temp2)
19660 delete arg2;
19661 }
19662 return NULL;
19663 }
19664
19665
19666 SWIGINTERN PyObject *_wrap_DC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxDC *arg1 = (wxDC *) 0 ;
19669 wxString *arg2 = 0 ;
19670 wxBitmap *arg3 = 0 ;
19671 wxRect *arg4 = 0 ;
19672 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
19673 int arg6 = (int) -1 ;
19674 wxRect result;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 bool temp2 = false ;
19678 void *argp3 = 0 ;
19679 int res3 = 0 ;
19680 wxRect temp4 ;
19681 int val5 ;
19682 int ecode5 = 0 ;
19683 int val6 ;
19684 int ecode6 = 0 ;
19685 PyObject * obj0 = 0 ;
19686 PyObject * obj1 = 0 ;
19687 PyObject * obj2 = 0 ;
19688 PyObject * obj3 = 0 ;
19689 PyObject * obj4 = 0 ;
19690 PyObject * obj5 = 0 ;
19691 char * kwnames[] = {
19692 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
19693 };
19694
19695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19697 if (!SWIG_IsOK(res1)) {
19698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawImageLabel" "', expected argument " "1"" of type '" "wxDC *""'");
19699 }
19700 arg1 = reinterpret_cast< wxDC * >(argp1);
19701 {
19702 arg2 = wxString_in_helper(obj1);
19703 if (arg2 == NULL) SWIG_fail;
19704 temp2 = true;
19705 }
19706 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
19707 if (!SWIG_IsOK(res3)) {
19708 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
19709 }
19710 if (!argp3) {
19711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
19712 }
19713 arg3 = reinterpret_cast< wxBitmap * >(argp3);
19714 {
19715 arg4 = &temp4;
19716 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
19717 }
19718 if (obj4) {
19719 ecode5 = SWIG_AsVal_int(obj4, &val5);
19720 if (!SWIG_IsOK(ecode5)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
19722 }
19723 arg5 = static_cast< int >(val5);
19724 }
19725 if (obj5) {
19726 ecode6 = SWIG_AsVal_int(obj5, &val6);
19727 if (!SWIG_IsOK(ecode6)) {
19728 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
19729 }
19730 arg6 = static_cast< int >(val6);
19731 }
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
19739 {
19740 if (temp2)
19741 delete arg2;
19742 }
19743 return resultobj;
19744 fail:
19745 {
19746 if (temp2)
19747 delete arg2;
19748 }
19749 return NULL;
19750 }
19751
19752
19753 SWIGINTERN PyObject *_wrap_DC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 wxDC *arg1 = (wxDC *) 0 ;
19756 int arg2 ;
19757 wxPoint *arg3 = (wxPoint *) 0 ;
19758 void *argp1 = 0 ;
19759 int res1 = 0 ;
19760 PyObject * obj0 = 0 ;
19761 PyObject * obj1 = 0 ;
19762 char * kwnames[] = {
19763 (char *) "self",(char *) "points", NULL
19764 };
19765
19766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
19767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19768 if (!SWIG_IsOK(res1)) {
19769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawSpline" "', expected argument " "1"" of type '" "wxDC *""'");
19770 }
19771 arg1 = reinterpret_cast< wxDC * >(argp1);
19772 {
19773 arg3 = wxPoint_LIST_helper(obj1, &arg2);
19774 if (arg3 == NULL) SWIG_fail;
19775 }
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 (arg1)->DrawSpline(arg2,arg3);
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 resultobj = SWIG_Py_Void();
19783 {
19784 if (arg3) delete [] arg3;
19785 }
19786 return resultobj;
19787 fail:
19788 {
19789 if (arg3) delete [] arg3;
19790 }
19791 return NULL;
19792 }
19793
19794
19795 SWIGINTERN PyObject *_wrap_DC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19796 PyObject *resultobj = 0;
19797 wxDC *arg1 = (wxDC *) 0 ;
19798 void *argp1 = 0 ;
19799 int res1 = 0 ;
19800 PyObject *swig_obj[1] ;
19801
19802 if (!args) SWIG_fail;
19803 swig_obj[0] = args;
19804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19805 if (!SWIG_IsOK(res1)) {
19806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Clear" "', expected argument " "1"" of type '" "wxDC *""'");
19807 }
19808 arg1 = reinterpret_cast< wxDC * >(argp1);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->Clear();
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_DC_StartDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxDC *arg1 = (wxDC *) 0 ;
19825 wxString *arg2 = 0 ;
19826 bool result;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 bool temp2 = false ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "message", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartDoc" "', expected argument " "1"" of type '" "wxDC *""'");
19840 }
19841 arg1 = reinterpret_cast< wxDC * >(argp1);
19842 {
19843 arg2 = wxString_in_helper(obj1);
19844 if (arg2 == NULL) SWIG_fail;
19845 temp2 = true;
19846 }
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 {
19854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19855 }
19856 {
19857 if (temp2)
19858 delete arg2;
19859 }
19860 return resultobj;
19861 fail:
19862 {
19863 if (temp2)
19864 delete arg2;
19865 }
19866 return NULL;
19867 }
19868
19869
19870 SWIGINTERN PyObject *_wrap_DC_EndDoc(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_EndDoc" "', expected argument " "1"" of type '" "wxDC *""'");
19882 }
19883 arg1 = reinterpret_cast< wxDC * >(argp1);
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 (arg1)->EndDoc();
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_StartPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19898 PyObject *resultobj = 0;
19899 wxDC *arg1 = (wxDC *) 0 ;
19900 void *argp1 = 0 ;
19901 int res1 = 0 ;
19902 PyObject *swig_obj[1] ;
19903
19904 if (!args) SWIG_fail;
19905 swig_obj[0] = args;
19906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19907 if (!SWIG_IsOK(res1)) {
19908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartPage" "', expected argument " "1"" of type '" "wxDC *""'");
19909 }
19910 arg1 = reinterpret_cast< wxDC * >(argp1);
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 (arg1)->StartPage();
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_Py_Void();
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_DC_EndPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19925 PyObject *resultobj = 0;
19926 wxDC *arg1 = (wxDC *) 0 ;
19927 void *argp1 = 0 ;
19928 int res1 = 0 ;
19929 PyObject *swig_obj[1] ;
19930
19931 if (!args) SWIG_fail;
19932 swig_obj[0] = args;
19933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19934 if (!SWIG_IsOK(res1)) {
19935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndPage" "', expected argument " "1"" of type '" "wxDC *""'");
19936 }
19937 arg1 = reinterpret_cast< wxDC * >(argp1);
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 (arg1)->EndPage();
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 resultobj = SWIG_Py_Void();
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 SWIGINTERN PyObject *_wrap_DC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj = 0;
19953 wxDC *arg1 = (wxDC *) 0 ;
19954 wxFont *arg2 = 0 ;
19955 void *argp1 = 0 ;
19956 int res1 = 0 ;
19957 void *argp2 = 0 ;
19958 int res2 = 0 ;
19959 PyObject * obj0 = 0 ;
19960 PyObject * obj1 = 0 ;
19961 char * kwnames[] = {
19962 (char *) "self",(char *) "font", NULL
19963 };
19964
19965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
19966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19967 if (!SWIG_IsOK(res1)) {
19968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetFont" "', expected argument " "1"" of type '" "wxDC *""'");
19969 }
19970 arg1 = reinterpret_cast< wxDC * >(argp1);
19971 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
19972 if (!SWIG_IsOK(res2)) {
19973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
19974 }
19975 if (!argp2) {
19976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
19977 }
19978 arg2 = reinterpret_cast< wxFont * >(argp2);
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 (arg1)->SetFont((wxFont const &)*arg2);
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 resultobj = SWIG_Py_Void();
19986 return resultobj;
19987 fail:
19988 return NULL;
19989 }
19990
19991
19992 SWIGINTERN PyObject *_wrap_DC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj = 0;
19994 wxDC *arg1 = (wxDC *) 0 ;
19995 wxPen *arg2 = 0 ;
19996 void *argp1 = 0 ;
19997 int res1 = 0 ;
19998 void *argp2 = 0 ;
19999 int res2 = 0 ;
20000 PyObject * obj0 = 0 ;
20001 PyObject * obj1 = 0 ;
20002 char * kwnames[] = {
20003 (char *) "self",(char *) "pen", NULL
20004 };
20005
20006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
20007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPen" "', expected argument " "1"" of type '" "wxDC *""'");
20010 }
20011 arg1 = reinterpret_cast< wxDC * >(argp1);
20012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
20013 if (!SWIG_IsOK(res2)) {
20014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20015 }
20016 if (!argp2) {
20017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20018 }
20019 arg2 = reinterpret_cast< wxPen * >(argp2);
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 (arg1)->SetPen((wxPen const &)*arg2);
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 resultobj = SWIG_Py_Void();
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 SWIGINTERN PyObject *_wrap_DC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20034 PyObject *resultobj = 0;
20035 wxDC *arg1 = (wxDC *) 0 ;
20036 wxBrush *arg2 = 0 ;
20037 void *argp1 = 0 ;
20038 int res1 = 0 ;
20039 void *argp2 = 0 ;
20040 int res2 = 0 ;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char * kwnames[] = {
20044 (char *) "self",(char *) "brush", NULL
20045 };
20046
20047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
20048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20049 if (!SWIG_IsOK(res1)) {
20050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBrush" "', expected argument " "1"" of type '" "wxDC *""'");
20051 }
20052 arg1 = reinterpret_cast< wxDC * >(argp1);
20053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20054 if (!SWIG_IsOK(res2)) {
20055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20056 }
20057 if (!argp2) {
20058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20059 }
20060 arg2 = reinterpret_cast< wxBrush * >(argp2);
20061 {
20062 PyThreadState* __tstate = wxPyBeginAllowThreads();
20063 (arg1)->SetBrush((wxBrush const &)*arg2);
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 resultobj = SWIG_Py_Void();
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_DC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj = 0;
20076 wxDC *arg1 = (wxDC *) 0 ;
20077 wxBrush *arg2 = 0 ;
20078 void *argp1 = 0 ;
20079 int res1 = 0 ;
20080 void *argp2 = 0 ;
20081 int res2 = 0 ;
20082 PyObject * obj0 = 0 ;
20083 PyObject * obj1 = 0 ;
20084 char * kwnames[] = {
20085 (char *) "self",(char *) "brush", NULL
20086 };
20087
20088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
20089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20090 if (!SWIG_IsOK(res1)) {
20091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackground" "', expected argument " "1"" of type '" "wxDC *""'");
20092 }
20093 arg1 = reinterpret_cast< wxDC * >(argp1);
20094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20095 if (!SWIG_IsOK(res2)) {
20096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20097 }
20098 if (!argp2) {
20099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20100 }
20101 arg2 = reinterpret_cast< wxBrush * >(argp2);
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 (arg1)->SetBackground((wxBrush const &)*arg2);
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 resultobj = SWIG_Py_Void();
20109 return resultobj;
20110 fail:
20111 return NULL;
20112 }
20113
20114
20115 SWIGINTERN PyObject *_wrap_DC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj = 0;
20117 wxDC *arg1 = (wxDC *) 0 ;
20118 int arg2 ;
20119 void *argp1 = 0 ;
20120 int res1 = 0 ;
20121 int val2 ;
20122 int ecode2 = 0 ;
20123 PyObject * obj0 = 0 ;
20124 PyObject * obj1 = 0 ;
20125 char * kwnames[] = {
20126 (char *) "self",(char *) "mode", NULL
20127 };
20128
20129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
20130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20131 if (!SWIG_IsOK(res1)) {
20132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxDC *""'");
20133 }
20134 arg1 = reinterpret_cast< wxDC * >(argp1);
20135 ecode2 = SWIG_AsVal_int(obj1, &val2);
20136 if (!SWIG_IsOK(ecode2)) {
20137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
20138 }
20139 arg2 = static_cast< int >(val2);
20140 {
20141 PyThreadState* __tstate = wxPyBeginAllowThreads();
20142 (arg1)->SetBackgroundMode(arg2);
20143 wxPyEndAllowThreads(__tstate);
20144 if (PyErr_Occurred()) SWIG_fail;
20145 }
20146 resultobj = SWIG_Py_Void();
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_DC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20154 PyObject *resultobj = 0;
20155 wxDC *arg1 = (wxDC *) 0 ;
20156 wxPalette *arg2 = 0 ;
20157 void *argp1 = 0 ;
20158 int res1 = 0 ;
20159 void *argp2 = 0 ;
20160 int res2 = 0 ;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 char * kwnames[] = {
20164 (char *) "self",(char *) "palette", NULL
20165 };
20166
20167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
20168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20169 if (!SWIG_IsOK(res1)) {
20170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPalette" "', expected argument " "1"" of type '" "wxDC *""'");
20171 }
20172 arg1 = reinterpret_cast< wxDC * >(argp1);
20173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
20174 if (!SWIG_IsOK(res2)) {
20175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20176 }
20177 if (!argp2) {
20178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20179 }
20180 arg2 = reinterpret_cast< wxPalette * >(argp2);
20181 {
20182 PyThreadState* __tstate = wxPyBeginAllowThreads();
20183 (arg1)->SetPalette((wxPalette const &)*arg2);
20184 wxPyEndAllowThreads(__tstate);
20185 if (PyErr_Occurred()) SWIG_fail;
20186 }
20187 resultobj = SWIG_Py_Void();
20188 return resultobj;
20189 fail:
20190 return NULL;
20191 }
20192
20193
20194 SWIGINTERN PyObject *_wrap_DC_DestroyClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20195 PyObject *resultobj = 0;
20196 wxDC *arg1 = (wxDC *) 0 ;
20197 void *argp1 = 0 ;
20198 int res1 = 0 ;
20199 PyObject *swig_obj[1] ;
20200
20201 if (!args) SWIG_fail;
20202 swig_obj[0] = args;
20203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DestroyClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
20206 }
20207 arg1 = reinterpret_cast< wxDC * >(argp1);
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 (arg1)->DestroyClippingRegion();
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_Py_Void();
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 SWIGINTERN PyObject *_wrap_DC_GetClippingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20222 PyObject *resultobj = 0;
20223 wxDC *arg1 = (wxDC *) 0 ;
20224 int *arg2 = (int *) 0 ;
20225 int *arg3 = (int *) 0 ;
20226 int *arg4 = (int *) 0 ;
20227 int *arg5 = (int *) 0 ;
20228 void *argp1 = 0 ;
20229 int res1 = 0 ;
20230 int temp2 ;
20231 int res2 = SWIG_TMPOBJ ;
20232 int temp3 ;
20233 int res3 = SWIG_TMPOBJ ;
20234 int temp4 ;
20235 int res4 = SWIG_TMPOBJ ;
20236 int temp5 ;
20237 int res5 = SWIG_TMPOBJ ;
20238 PyObject *swig_obj[1] ;
20239
20240 arg2 = &temp2;
20241 arg3 = &temp3;
20242 arg4 = &temp4;
20243 arg5 = &temp5;
20244 if (!args) SWIG_fail;
20245 swig_obj[0] = args;
20246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20247 if (!SWIG_IsOK(res1)) {
20248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingBox" "', expected argument " "1"" of type '" "wxDC const *""'");
20249 }
20250 arg1 = reinterpret_cast< wxDC * >(argp1);
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
20254 wxPyEndAllowThreads(__tstate);
20255 if (PyErr_Occurred()) SWIG_fail;
20256 }
20257 resultobj = SWIG_Py_Void();
20258 if (SWIG_IsTmpObj(res2)) {
20259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20260 } else {
20261 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20263 }
20264 if (SWIG_IsTmpObj(res3)) {
20265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20266 } else {
20267 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20269 }
20270 if (SWIG_IsTmpObj(res4)) {
20271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20272 } else {
20273 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20275 }
20276 if (SWIG_IsTmpObj(res5)) {
20277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20278 } else {
20279 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20281 }
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 SWIGINTERN PyObject *_wrap_DC_GetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20289 PyObject *resultobj = 0;
20290 wxDC *arg1 = (wxDC *) 0 ;
20291 wxRect result;
20292 void *argp1 = 0 ;
20293 int res1 = 0 ;
20294 PyObject *swig_obj[1] ;
20295
20296 if (!args) SWIG_fail;
20297 swig_obj[0] = args;
20298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20299 if (!SWIG_IsOK(res1)) {
20300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
20301 }
20302 arg1 = reinterpret_cast< wxDC * >(argp1);
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 result = wxDC_GetClippingRect(arg1);
20306 wxPyEndAllowThreads(__tstate);
20307 if (PyErr_Occurred()) SWIG_fail;
20308 }
20309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
20310 return resultobj;
20311 fail:
20312 return NULL;
20313 }
20314
20315
20316 SWIGINTERN PyObject *_wrap_DC_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxDC *arg1 = (wxDC *) 0 ;
20319 int result;
20320 void *argp1 = 0 ;
20321 int res1 = 0 ;
20322 PyObject *swig_obj[1] ;
20323
20324 if (!args) SWIG_fail;
20325 swig_obj[0] = args;
20326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20327 if (!SWIG_IsOK(res1)) {
20328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharHeight" "', expected argument " "1"" of type '" "wxDC const *""'");
20329 }
20330 arg1 = reinterpret_cast< wxDC * >(argp1);
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (int)((wxDC const *)arg1)->GetCharHeight();
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_From_int(static_cast< int >(result));
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *_wrap_DC_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxDC *arg1 = (wxDC *) 0 ;
20347 int result;
20348 void *argp1 = 0 ;
20349 int res1 = 0 ;
20350 PyObject *swig_obj[1] ;
20351
20352 if (!args) SWIG_fail;
20353 swig_obj[0] = args;
20354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20355 if (!SWIG_IsOK(res1)) {
20356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharWidth" "', expected argument " "1"" of type '" "wxDC const *""'");
20357 }
20358 arg1 = reinterpret_cast< wxDC * >(argp1);
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (int)((wxDC const *)arg1)->GetCharWidth();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 resultobj = SWIG_From_int(static_cast< int >(result));
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 SWIGINTERN PyObject *_wrap_DC_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj = 0;
20374 wxDC *arg1 = (wxDC *) 0 ;
20375 wxString *arg2 = 0 ;
20376 int *arg3 = (int *) 0 ;
20377 int *arg4 = (int *) 0 ;
20378 void *argp1 = 0 ;
20379 int res1 = 0 ;
20380 bool temp2 = false ;
20381 int temp3 ;
20382 int res3 = SWIG_TMPOBJ ;
20383 int temp4 ;
20384 int res4 = SWIG_TMPOBJ ;
20385 PyObject * obj0 = 0 ;
20386 PyObject * obj1 = 0 ;
20387 char * kwnames[] = {
20388 (char *) "self",(char *) "string", NULL
20389 };
20390
20391 arg3 = &temp3;
20392 arg4 = &temp4;
20393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
20394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20395 if (!SWIG_IsOK(res1)) {
20396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20397 }
20398 arg1 = reinterpret_cast< wxDC * >(argp1);
20399 {
20400 arg2 = wxString_in_helper(obj1);
20401 if (arg2 == NULL) SWIG_fail;
20402 temp2 = true;
20403 }
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 resultobj = SWIG_Py_Void();
20411 if (SWIG_IsTmpObj(res3)) {
20412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20413 } else {
20414 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20416 }
20417 if (SWIG_IsTmpObj(res4)) {
20418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20419 } else {
20420 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20422 }
20423 {
20424 if (temp2)
20425 delete arg2;
20426 }
20427 return resultobj;
20428 fail:
20429 {
20430 if (temp2)
20431 delete arg2;
20432 }
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_DC_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj = 0;
20439 wxDC *arg1 = (wxDC *) 0 ;
20440 wxString *arg2 = 0 ;
20441 int *arg3 = (int *) 0 ;
20442 int *arg4 = (int *) 0 ;
20443 int *arg5 = (int *) 0 ;
20444 int *arg6 = (int *) 0 ;
20445 wxFont *arg7 = (wxFont *) NULL ;
20446 void *argp1 = 0 ;
20447 int res1 = 0 ;
20448 bool temp2 = false ;
20449 int temp3 ;
20450 int res3 = SWIG_TMPOBJ ;
20451 int temp4 ;
20452 int res4 = SWIG_TMPOBJ ;
20453 int temp5 ;
20454 int res5 = SWIG_TMPOBJ ;
20455 int temp6 ;
20456 int res6 = SWIG_TMPOBJ ;
20457 void *argp7 = 0 ;
20458 int res7 = 0 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "self",(char *) "string",(char *) "font", NULL
20464 };
20465
20466 arg3 = &temp3;
20467 arg4 = &temp4;
20468 arg5 = &temp5;
20469 arg6 = &temp6;
20470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20472 if (!SWIG_IsOK(res1)) {
20473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFullTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20474 }
20475 arg1 = reinterpret_cast< wxDC * >(argp1);
20476 {
20477 arg2 = wxString_in_helper(obj1);
20478 if (arg2 == NULL) SWIG_fail;
20479 temp2 = true;
20480 }
20481 if (obj2) {
20482 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
20483 if (!SWIG_IsOK(res7)) {
20484 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DC_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont *""'");
20485 }
20486 arg7 = reinterpret_cast< wxFont * >(argp7);
20487 }
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 resultobj = SWIG_Py_Void();
20495 if (SWIG_IsTmpObj(res3)) {
20496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20497 } else {
20498 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20500 }
20501 if (SWIG_IsTmpObj(res4)) {
20502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20503 } else {
20504 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20506 }
20507 if (SWIG_IsTmpObj(res5)) {
20508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20509 } else {
20510 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20512 }
20513 if (SWIG_IsTmpObj(res6)) {
20514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
20515 } else {
20516 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
20518 }
20519 {
20520 if (temp2)
20521 delete arg2;
20522 }
20523 return resultobj;
20524 fail:
20525 {
20526 if (temp2)
20527 delete arg2;
20528 }
20529 return NULL;
20530 }
20531
20532
20533 SWIGINTERN PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj = 0;
20535 wxDC *arg1 = (wxDC *) 0 ;
20536 wxString *arg2 = 0 ;
20537 int *arg3 = (int *) 0 ;
20538 int *arg4 = (int *) 0 ;
20539 int *arg5 = (int *) 0 ;
20540 wxFont *arg6 = (wxFont *) NULL ;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 bool temp2 = false ;
20544 int temp3 ;
20545 int res3 = SWIG_TMPOBJ ;
20546 int temp4 ;
20547 int res4 = SWIG_TMPOBJ ;
20548 int temp5 ;
20549 int res5 = SWIG_TMPOBJ ;
20550 void *argp6 = 0 ;
20551 int res6 = 0 ;
20552 PyObject * obj0 = 0 ;
20553 PyObject * obj1 = 0 ;
20554 PyObject * obj2 = 0 ;
20555 char * kwnames[] = {
20556 (char *) "self",(char *) "text",(char *) "font", NULL
20557 };
20558
20559 arg3 = &temp3;
20560 arg4 = &temp4;
20561 arg5 = &temp5;
20562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20564 if (!SWIG_IsOK(res1)) {
20565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
20566 }
20567 arg1 = reinterpret_cast< wxDC * >(argp1);
20568 {
20569 arg2 = wxString_in_helper(obj1);
20570 if (arg2 == NULL) SWIG_fail;
20571 temp2 = true;
20572 }
20573 if (obj2) {
20574 res6 = SWIG_ConvertPtr(obj2, &argp6,SWIGTYPE_p_wxFont, 0 | 0 );
20575 if (!SWIG_IsOK(res6)) {
20576 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "6"" of type '" "wxFont *""'");
20577 }
20578 arg6 = reinterpret_cast< wxFont * >(argp6);
20579 }
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 resultobj = SWIG_Py_Void();
20587 if (SWIG_IsTmpObj(res3)) {
20588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20589 } else {
20590 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20592 }
20593 if (SWIG_IsTmpObj(res4)) {
20594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20595 } else {
20596 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20598 }
20599 if (SWIG_IsTmpObj(res5)) {
20600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20601 } else {
20602 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20604 }
20605 {
20606 if (temp2)
20607 delete arg2;
20608 }
20609 return resultobj;
20610 fail:
20611 {
20612 if (temp2)
20613 delete arg2;
20614 }
20615 return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_DC_GetPartialTextExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj = 0;
20621 wxDC *arg1 = (wxDC *) 0 ;
20622 wxString *arg2 = 0 ;
20623 wxArrayInt result;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 bool temp2 = false ;
20627 PyObject * obj0 = 0 ;
20628 PyObject * obj1 = 0 ;
20629 char * kwnames[] = {
20630 (char *) "self",(char *) "text", NULL
20631 };
20632
20633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) SWIG_fail;
20634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20635 if (!SWIG_IsOK(res1)) {
20636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPartialTextExtents" "', expected argument " "1"" of type '" "wxDC *""'");
20637 }
20638 arg1 = reinterpret_cast< wxDC * >(argp1);
20639 {
20640 arg2 = wxString_in_helper(obj1);
20641 if (arg2 == NULL) SWIG_fail;
20642 temp2 = true;
20643 }
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = PyList_New(0);
20652 size_t idx;
20653 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
20654 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
20655 PyList_Append(resultobj, val);
20656 Py_DECREF(val);
20657 }
20658 }
20659 {
20660 if (temp2)
20661 delete arg2;
20662 }
20663 return resultobj;
20664 fail:
20665 {
20666 if (temp2)
20667 delete arg2;
20668 }
20669 return NULL;
20670 }
20671
20672
20673 SWIGINTERN PyObject *_wrap_DC_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20674 PyObject *resultobj = 0;
20675 wxDC *arg1 = (wxDC *) 0 ;
20676 wxSize result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 PyObject *swig_obj[1] ;
20680
20681 if (!args) SWIG_fail;
20682 swig_obj[0] = args;
20683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSize" "', expected argument " "1"" of type '" "wxDC *""'");
20686 }
20687 arg1 = reinterpret_cast< wxDC * >(argp1);
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (arg1)->GetSize();
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_DC_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20702 PyObject *resultobj = 0;
20703 wxDC *arg1 = (wxDC *) 0 ;
20704 int *arg2 = (int *) 0 ;
20705 int *arg3 = (int *) 0 ;
20706 void *argp1 = 0 ;
20707 int res1 = 0 ;
20708 int temp2 ;
20709 int res2 = SWIG_TMPOBJ ;
20710 int temp3 ;
20711 int res3 = SWIG_TMPOBJ ;
20712 PyObject *swig_obj[1] ;
20713
20714 arg2 = &temp2;
20715 arg3 = &temp3;
20716 if (!args) SWIG_fail;
20717 swig_obj[0] = args;
20718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20719 if (!SWIG_IsOK(res1)) {
20720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeTuple" "', expected argument " "1"" of type '" "wxDC *""'");
20721 }
20722 arg1 = reinterpret_cast< wxDC * >(argp1);
20723 {
20724 PyThreadState* __tstate = wxPyBeginAllowThreads();
20725 (arg1)->GetSize(arg2,arg3);
20726 wxPyEndAllowThreads(__tstate);
20727 if (PyErr_Occurred()) SWIG_fail;
20728 }
20729 resultobj = SWIG_Py_Void();
20730 if (SWIG_IsTmpObj(res2)) {
20731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20732 } else {
20733 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20735 }
20736 if (SWIG_IsTmpObj(res3)) {
20737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20738 } else {
20739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20741 }
20742 return resultobj;
20743 fail:
20744 return NULL;
20745 }
20746
20747
20748 SWIGINTERN PyObject *_wrap_DC_GetSizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20749 PyObject *resultobj = 0;
20750 wxDC *arg1 = (wxDC *) 0 ;
20751 wxSize result;
20752 void *argp1 = 0 ;
20753 int res1 = 0 ;
20754 PyObject *swig_obj[1] ;
20755
20756 if (!args) SWIG_fail;
20757 swig_obj[0] = args;
20758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20759 if (!SWIG_IsOK(res1)) {
20760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMM" "', expected argument " "1"" of type '" "wxDC const *""'");
20761 }
20762 arg1 = reinterpret_cast< wxDC * >(argp1);
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 result = ((wxDC const *)arg1)->GetSizeMM();
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 SWIGINTERN PyObject *_wrap_DC_GetSizeMMTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20777 PyObject *resultobj = 0;
20778 wxDC *arg1 = (wxDC *) 0 ;
20779 int *arg2 = (int *) 0 ;
20780 int *arg3 = (int *) 0 ;
20781 void *argp1 = 0 ;
20782 int res1 = 0 ;
20783 int temp2 ;
20784 int res2 = SWIG_TMPOBJ ;
20785 int temp3 ;
20786 int res3 = SWIG_TMPOBJ ;
20787 PyObject *swig_obj[1] ;
20788
20789 arg2 = &temp2;
20790 arg3 = &temp3;
20791 if (!args) SWIG_fail;
20792 swig_obj[0] = args;
20793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20794 if (!SWIG_IsOK(res1)) {
20795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMMTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
20796 }
20797 arg1 = reinterpret_cast< wxDC * >(argp1);
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_Py_Void();
20805 if (SWIG_IsTmpObj(res2)) {
20806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20807 } else {
20808 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20810 }
20811 if (SWIG_IsTmpObj(res3)) {
20812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20813 } else {
20814 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20816 }
20817 return resultobj;
20818 fail:
20819 return NULL;
20820 }
20821
20822
20823 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20824 PyObject *resultobj = 0;
20825 wxDC *arg1 = (wxDC *) 0 ;
20826 int arg2 ;
20827 int result;
20828 void *argp1 = 0 ;
20829 int res1 = 0 ;
20830 int val2 ;
20831 int ecode2 = 0 ;
20832 PyObject * obj0 = 0 ;
20833 PyObject * obj1 = 0 ;
20834 char * kwnames[] = {
20835 (char *) "self",(char *) "x", NULL
20836 };
20837
20838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) SWIG_fail;
20839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20840 if (!SWIG_IsOK(res1)) {
20841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalX" "', expected argument " "1"" of type '" "wxDC const *""'");
20842 }
20843 arg1 = reinterpret_cast< wxDC * >(argp1);
20844 ecode2 = SWIG_AsVal_int(obj1, &val2);
20845 if (!SWIG_IsOK(ecode2)) {
20846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalX" "', expected argument " "2"" of type '" "int""'");
20847 }
20848 arg2 = static_cast< int >(val2);
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 resultobj = SWIG_From_int(static_cast< int >(result));
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20863 PyObject *resultobj = 0;
20864 wxDC *arg1 = (wxDC *) 0 ;
20865 int arg2 ;
20866 int result;
20867 void *argp1 = 0 ;
20868 int res1 = 0 ;
20869 int val2 ;
20870 int ecode2 = 0 ;
20871 PyObject * obj0 = 0 ;
20872 PyObject * obj1 = 0 ;
20873 char * kwnames[] = {
20874 (char *) "self",(char *) "y", NULL
20875 };
20876
20877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) SWIG_fail;
20878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20879 if (!SWIG_IsOK(res1)) {
20880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalY" "', expected argument " "1"" of type '" "wxDC const *""'");
20881 }
20882 arg1 = reinterpret_cast< wxDC * >(argp1);
20883 ecode2 = SWIG_AsVal_int(obj1, &val2);
20884 if (!SWIG_IsOK(ecode2)) {
20885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalY" "', expected argument " "2"" of type '" "int""'");
20886 }
20887 arg2 = static_cast< int >(val2);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_From_int(static_cast< int >(result));
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj = 0;
20903 wxDC *arg1 = (wxDC *) 0 ;
20904 int arg2 ;
20905 int result;
20906 void *argp1 = 0 ;
20907 int res1 = 0 ;
20908 int val2 ;
20909 int ecode2 = 0 ;
20910 PyObject * obj0 = 0 ;
20911 PyObject * obj1 = 0 ;
20912 char * kwnames[] = {
20913 (char *) "self",(char *) "x", NULL
20914 };
20915
20916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) SWIG_fail;
20917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20918 if (!SWIG_IsOK(res1)) {
20919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
20920 }
20921 arg1 = reinterpret_cast< wxDC * >(argp1);
20922 ecode2 = SWIG_AsVal_int(obj1, &val2);
20923 if (!SWIG_IsOK(ecode2)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "2"" of type '" "int""'");
20925 }
20926 arg2 = static_cast< int >(val2);
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 resultobj = SWIG_From_int(static_cast< int >(result));
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj = 0;
20942 wxDC *arg1 = (wxDC *) 0 ;
20943 int arg2 ;
20944 int result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 int val2 ;
20948 int ecode2 = 0 ;
20949 PyObject * obj0 = 0 ;
20950 PyObject * obj1 = 0 ;
20951 char * kwnames[] = {
20952 (char *) "self",(char *) "y", NULL
20953 };
20954
20955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) SWIG_fail;
20956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20957 if (!SWIG_IsOK(res1)) {
20958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
20959 }
20960 arg1 = reinterpret_cast< wxDC * >(argp1);
20961 ecode2 = SWIG_AsVal_int(obj1, &val2);
20962 if (!SWIG_IsOK(ecode2)) {
20963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "2"" of type '" "int""'");
20964 }
20965 arg2 = static_cast< int >(val2);
20966 {
20967 PyThreadState* __tstate = wxPyBeginAllowThreads();
20968 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
20969 wxPyEndAllowThreads(__tstate);
20970 if (PyErr_Occurred()) SWIG_fail;
20971 }
20972 resultobj = SWIG_From_int(static_cast< int >(result));
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20980 PyObject *resultobj = 0;
20981 wxDC *arg1 = (wxDC *) 0 ;
20982 int arg2 ;
20983 int result;
20984 void *argp1 = 0 ;
20985 int res1 = 0 ;
20986 int val2 ;
20987 int ecode2 = 0 ;
20988 PyObject * obj0 = 0 ;
20989 PyObject * obj1 = 0 ;
20990 char * kwnames[] = {
20991 (char *) "self",(char *) "x", NULL
20992 };
20993
20994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) SWIG_fail;
20995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20996 if (!SWIG_IsOK(res1)) {
20997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceX" "', expected argument " "1"" of type '" "wxDC const *""'");
20998 }
20999 arg1 = reinterpret_cast< wxDC * >(argp1);
21000 ecode2 = SWIG_AsVal_int(obj1, &val2);
21001 if (!SWIG_IsOK(ecode2)) {
21002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceX" "', expected argument " "2"" of type '" "int""'");
21003 }
21004 arg2 = static_cast< int >(val2);
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
21008 wxPyEndAllowThreads(__tstate);
21009 if (PyErr_Occurred()) SWIG_fail;
21010 }
21011 resultobj = SWIG_From_int(static_cast< int >(result));
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21019 PyObject *resultobj = 0;
21020 wxDC *arg1 = (wxDC *) 0 ;
21021 int arg2 ;
21022 int result;
21023 void *argp1 = 0 ;
21024 int res1 = 0 ;
21025 int val2 ;
21026 int ecode2 = 0 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 char * kwnames[] = {
21030 (char *) "self",(char *) "y", NULL
21031 };
21032
21033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) SWIG_fail;
21034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21035 if (!SWIG_IsOK(res1)) {
21036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceY" "', expected argument " "1"" of type '" "wxDC const *""'");
21037 }
21038 arg1 = reinterpret_cast< wxDC * >(argp1);
21039 ecode2 = SWIG_AsVal_int(obj1, &val2);
21040 if (!SWIG_IsOK(ecode2)) {
21041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceY" "', expected argument " "2"" of type '" "int""'");
21042 }
21043 arg2 = static_cast< int >(val2);
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
21047 wxPyEndAllowThreads(__tstate);
21048 if (PyErr_Occurred()) SWIG_fail;
21049 }
21050 resultobj = SWIG_From_int(static_cast< int >(result));
21051 return resultobj;
21052 fail:
21053 return NULL;
21054 }
21055
21056
21057 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21058 PyObject *resultobj = 0;
21059 wxDC *arg1 = (wxDC *) 0 ;
21060 int arg2 ;
21061 int result;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 int val2 ;
21065 int ecode2 = 0 ;
21066 PyObject * obj0 = 0 ;
21067 PyObject * obj1 = 0 ;
21068 char * kwnames[] = {
21069 (char *) "self",(char *) "x", NULL
21070 };
21071
21072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) SWIG_fail;
21073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21074 if (!SWIG_IsOK(res1)) {
21075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21076 }
21077 arg1 = reinterpret_cast< wxDC * >(argp1);
21078 ecode2 = SWIG_AsVal_int(obj1, &val2);
21079 if (!SWIG_IsOK(ecode2)) {
21080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "2"" of type '" "int""'");
21081 }
21082 arg2 = static_cast< int >(val2);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 resultobj = SWIG_From_int(static_cast< int >(result));
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj = 0;
21098 wxDC *arg1 = (wxDC *) 0 ;
21099 int arg2 ;
21100 int result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 int val2 ;
21104 int ecode2 = 0 ;
21105 PyObject * obj0 = 0 ;
21106 PyObject * obj1 = 0 ;
21107 char * kwnames[] = {
21108 (char *) "self",(char *) "y", NULL
21109 };
21110
21111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) SWIG_fail;
21112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21113 if (!SWIG_IsOK(res1)) {
21114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21115 }
21116 arg1 = reinterpret_cast< wxDC * >(argp1);
21117 ecode2 = SWIG_AsVal_int(obj1, &val2);
21118 if (!SWIG_IsOK(ecode2)) {
21119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "2"" of type '" "int""'");
21120 }
21121 arg2 = static_cast< int >(val2);
21122 {
21123 PyThreadState* __tstate = wxPyBeginAllowThreads();
21124 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
21125 wxPyEndAllowThreads(__tstate);
21126 if (PyErr_Occurred()) SWIG_fail;
21127 }
21128 resultobj = SWIG_From_int(static_cast< int >(result));
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 SWIGINTERN PyObject *_wrap_DC_CanDrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21136 PyObject *resultobj = 0;
21137 wxDC *arg1 = (wxDC *) 0 ;
21138 bool result;
21139 void *argp1 = 0 ;
21140 int res1 = 0 ;
21141 PyObject *swig_obj[1] ;
21142
21143 if (!args) SWIG_fail;
21144 swig_obj[0] = args;
21145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21146 if (!SWIG_IsOK(res1)) {
21147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanDrawBitmap" "', expected argument " "1"" of type '" "wxDC const *""'");
21148 }
21149 arg1 = reinterpret_cast< wxDC * >(argp1);
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 {
21157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21158 }
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 SWIGINTERN PyObject *_wrap_DC_CanGetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21166 PyObject *resultobj = 0;
21167 wxDC *arg1 = (wxDC *) 0 ;
21168 bool result;
21169 void *argp1 = 0 ;
21170 int res1 = 0 ;
21171 PyObject *swig_obj[1] ;
21172
21173 if (!args) SWIG_fail;
21174 swig_obj[0] = args;
21175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21176 if (!SWIG_IsOK(res1)) {
21177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanGetTextExtent" "', expected argument " "1"" of type '" "wxDC const *""'");
21178 }
21179 arg1 = reinterpret_cast< wxDC * >(argp1);
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_DC_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxDC *arg1 = (wxDC *) 0 ;
21198 int result;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 PyObject *swig_obj[1] ;
21202
21203 if (!args) SWIG_fail;
21204 swig_obj[0] = args;
21205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDepth" "', expected argument " "1"" of type '" "wxDC const *""'");
21208 }
21209 arg1 = reinterpret_cast< wxDC * >(argp1);
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (int)((wxDC const *)arg1)->GetDepth();
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 resultobj = SWIG_From_int(static_cast< int >(result));
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 SWIGINTERN PyObject *_wrap_DC_GetPPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21224 PyObject *resultobj = 0;
21225 wxDC *arg1 = (wxDC *) 0 ;
21226 wxSize result;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 PyObject *swig_obj[1] ;
21230
21231 if (!args) SWIG_fail;
21232 swig_obj[0] = args;
21233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21234 if (!SWIG_IsOK(res1)) {
21235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPPI" "', expected argument " "1"" of type '" "wxDC const *""'");
21236 }
21237 arg1 = reinterpret_cast< wxDC * >(argp1);
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = ((wxDC const *)arg1)->GetPPI();
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_DC_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21252 PyObject *resultobj = 0;
21253 wxDC *arg1 = (wxDC *) 0 ;
21254 bool result;
21255 void *argp1 = 0 ;
21256 int res1 = 0 ;
21257 PyObject *swig_obj[1] ;
21258
21259 if (!args) SWIG_fail;
21260 swig_obj[0] = args;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Ok" "', expected argument " "1"" of type '" "wxDC const *""'");
21264 }
21265 arg1 = reinterpret_cast< wxDC * >(argp1);
21266 {
21267 PyThreadState* __tstate = wxPyBeginAllowThreads();
21268 result = (bool)((wxDC const *)arg1)->Ok();
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 {
21273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21274 }
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 SWIGINTERN PyObject *_wrap_DC_GetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282 PyObject *resultobj = 0;
21283 wxDC *arg1 = (wxDC *) 0 ;
21284 int result;
21285 void *argp1 = 0 ;
21286 int res1 = 0 ;
21287 PyObject *swig_obj[1] ;
21288
21289 if (!args) SWIG_fail;
21290 swig_obj[0] = args;
21291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackgroundMode" "', expected argument " "1"" of type '" "wxDC const *""'");
21294 }
21295 arg1 = reinterpret_cast< wxDC * >(argp1);
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
21299 wxPyEndAllowThreads(__tstate);
21300 if (PyErr_Occurred()) SWIG_fail;
21301 }
21302 resultobj = SWIG_From_int(static_cast< int >(result));
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 SWIGINTERN PyObject *_wrap_DC_GetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21310 PyObject *resultobj = 0;
21311 wxDC *arg1 = (wxDC *) 0 ;
21312 wxBrush *result = 0 ;
21313 void *argp1 = 0 ;
21314 int res1 = 0 ;
21315 PyObject *swig_obj[1] ;
21316
21317 if (!args) SWIG_fail;
21318 swig_obj[0] = args;
21319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
21322 }
21323 arg1 = reinterpret_cast< wxDC * >(argp1);
21324 {
21325 PyThreadState* __tstate = wxPyBeginAllowThreads();
21326 {
21327 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
21328 result = (wxBrush *) &_result_ref;
21329 }
21330 wxPyEndAllowThreads(__tstate);
21331 if (PyErr_Occurred()) SWIG_fail;
21332 }
21333 {
21334 wxBrush* resultptr = new wxBrush(*result);
21335 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
21336 }
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *_wrap_DC_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *resultobj = 0;
21345 wxDC *arg1 = (wxDC *) 0 ;
21346 wxBrush *result = 0 ;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 PyObject *swig_obj[1] ;
21350
21351 if (!args) SWIG_fail;
21352 swig_obj[0] = args;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBrush" "', expected argument " "1"" of type '" "wxDC const *""'");
21356 }
21357 arg1 = reinterpret_cast< wxDC * >(argp1);
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 {
21361 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
21362 result = (wxBrush *) &_result_ref;
21363 }
21364 wxPyEndAllowThreads(__tstate);
21365 if (PyErr_Occurred()) SWIG_fail;
21366 }
21367 {
21368 wxBrush* resultptr = new wxBrush(*result);
21369 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
21370 }
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_DC_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxDC *arg1 = (wxDC *) 0 ;
21380 wxFont *result = 0 ;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFont" "', expected argument " "1"" of type '" "wxDC const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxDC * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 {
21395 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
21396 result = (wxFont *) &_result_ref;
21397 }
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 {
21402 wxFont* resultptr = new wxFont(*result);
21403 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
21404 }
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_DC_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21412 PyObject *resultobj = 0;
21413 wxDC *arg1 = (wxDC *) 0 ;
21414 wxPen *result = 0 ;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 PyObject *swig_obj[1] ;
21418
21419 if (!args) SWIG_fail;
21420 swig_obj[0] = args;
21421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21422 if (!SWIG_IsOK(res1)) {
21423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPen" "', expected argument " "1"" of type '" "wxDC const *""'");
21424 }
21425 arg1 = reinterpret_cast< wxDC * >(argp1);
21426 {
21427 PyThreadState* __tstate = wxPyBeginAllowThreads();
21428 {
21429 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
21430 result = (wxPen *) &_result_ref;
21431 }
21432 wxPyEndAllowThreads(__tstate);
21433 if (PyErr_Occurred()) SWIG_fail;
21434 }
21435 {
21436 wxPen* resultptr = new wxPen(*result);
21437 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
21438 }
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_DC_GetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21446 PyObject *resultobj = 0;
21447 wxDC *arg1 = (wxDC *) 0 ;
21448 wxColour *result = 0 ;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 PyObject *swig_obj[1] ;
21452
21453 if (!args) SWIG_fail;
21454 swig_obj[0] = args;
21455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21456 if (!SWIG_IsOK(res1)) {
21457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
21458 }
21459 arg1 = reinterpret_cast< wxDC * >(argp1);
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 {
21463 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
21464 result = (wxColour *) &_result_ref;
21465 }
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_DC_GetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxDC *arg1 = (wxDC *) 0 ;
21479 wxColour *result = 0 ;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 PyObject *swig_obj[1] ;
21483
21484 if (!args) SWIG_fail;
21485 swig_obj[0] = args;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextForeground" "', expected argument " "1"" of type '" "wxDC const *""'");
21489 }
21490 arg1 = reinterpret_cast< wxDC * >(argp1);
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 {
21494 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
21495 result = (wxColour *) &_result_ref;
21496 }
21497 wxPyEndAllowThreads(__tstate);
21498 if (PyErr_Occurred()) SWIG_fail;
21499 }
21500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_DC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21508 PyObject *resultobj = 0;
21509 wxDC *arg1 = (wxDC *) 0 ;
21510 wxColour *arg2 = 0 ;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 wxColour temp2 ;
21514 PyObject * obj0 = 0 ;
21515 PyObject * obj1 = 0 ;
21516 char * kwnames[] = {
21517 (char *) "self",(char *) "colour", NULL
21518 };
21519
21520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
21521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21522 if (!SWIG_IsOK(res1)) {
21523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextForeground" "', expected argument " "1"" of type '" "wxDC *""'");
21524 }
21525 arg1 = reinterpret_cast< wxDC * >(argp1);
21526 {
21527 arg2 = &temp2;
21528 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21529 }
21530 {
21531 PyThreadState* __tstate = wxPyBeginAllowThreads();
21532 (arg1)->SetTextForeground((wxColour const &)*arg2);
21533 wxPyEndAllowThreads(__tstate);
21534 if (PyErr_Occurred()) SWIG_fail;
21535 }
21536 resultobj = SWIG_Py_Void();
21537 return resultobj;
21538 fail:
21539 return NULL;
21540 }
21541
21542
21543 SWIGINTERN PyObject *_wrap_DC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj = 0;
21545 wxDC *arg1 = (wxDC *) 0 ;
21546 wxColour *arg2 = 0 ;
21547 void *argp1 = 0 ;
21548 int res1 = 0 ;
21549 wxColour temp2 ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 char * kwnames[] = {
21553 (char *) "self",(char *) "colour", NULL
21554 };
21555
21556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
21557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextBackground" "', expected argument " "1"" of type '" "wxDC *""'");
21560 }
21561 arg1 = reinterpret_cast< wxDC * >(argp1);
21562 {
21563 arg2 = &temp2;
21564 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21565 }
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 (arg1)->SetTextBackground((wxColour const &)*arg2);
21569 wxPyEndAllowThreads(__tstate);
21570 if (PyErr_Occurred()) SWIG_fail;
21571 }
21572 resultobj = SWIG_Py_Void();
21573 return resultobj;
21574 fail:
21575 return NULL;
21576 }
21577
21578
21579 SWIGINTERN PyObject *_wrap_DC_GetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21580 PyObject *resultobj = 0;
21581 wxDC *arg1 = (wxDC *) 0 ;
21582 int result;
21583 void *argp1 = 0 ;
21584 int res1 = 0 ;
21585 PyObject *swig_obj[1] ;
21586
21587 if (!args) SWIG_fail;
21588 swig_obj[0] = args;
21589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21590 if (!SWIG_IsOK(res1)) {
21591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMapMode" "', expected argument " "1"" of type '" "wxDC const *""'");
21592 }
21593 arg1 = reinterpret_cast< wxDC * >(argp1);
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (int)((wxDC const *)arg1)->GetMapMode();
21597 wxPyEndAllowThreads(__tstate);
21598 if (PyErr_Occurred()) SWIG_fail;
21599 }
21600 resultobj = SWIG_From_int(static_cast< int >(result));
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_DC_SetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21608 PyObject *resultobj = 0;
21609 wxDC *arg1 = (wxDC *) 0 ;
21610 int arg2 ;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 int val2 ;
21614 int ecode2 = 0 ;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 char * kwnames[] = {
21618 (char *) "self",(char *) "mode", NULL
21619 };
21620
21621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) SWIG_fail;
21622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetMapMode" "', expected argument " "1"" of type '" "wxDC *""'");
21625 }
21626 arg1 = reinterpret_cast< wxDC * >(argp1);
21627 ecode2 = SWIG_AsVal_int(obj1, &val2);
21628 if (!SWIG_IsOK(ecode2)) {
21629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetMapMode" "', expected argument " "2"" of type '" "int""'");
21630 }
21631 arg2 = static_cast< int >(val2);
21632 {
21633 PyThreadState* __tstate = wxPyBeginAllowThreads();
21634 (arg1)->SetMapMode(arg2);
21635 wxPyEndAllowThreads(__tstate);
21636 if (PyErr_Occurred()) SWIG_fail;
21637 }
21638 resultobj = SWIG_Py_Void();
21639 return resultobj;
21640 fail:
21641 return NULL;
21642 }
21643
21644
21645 SWIGINTERN PyObject *_wrap_DC_GetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21646 PyObject *resultobj = 0;
21647 wxDC *arg1 = (wxDC *) 0 ;
21648 double *arg2 = (double *) 0 ;
21649 double *arg3 = (double *) 0 ;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 double temp2 ;
21653 int res2 = SWIG_TMPOBJ ;
21654 double temp3 ;
21655 int res3 = SWIG_TMPOBJ ;
21656 PyObject *swig_obj[1] ;
21657
21658 arg2 = &temp2;
21659 arg3 = &temp3;
21660 if (!args) SWIG_fail;
21661 swig_obj[0] = args;
21662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21663 if (!SWIG_IsOK(res1)) {
21664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetUserScale" "', expected argument " "1"" of type '" "wxDC const *""'");
21665 }
21666 arg1 = reinterpret_cast< wxDC * >(argp1);
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 resultobj = SWIG_Py_Void();
21674 if (SWIG_IsTmpObj(res2)) {
21675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
21676 } else {
21677 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21679 }
21680 if (SWIG_IsTmpObj(res3)) {
21681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
21682 } else {
21683 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
21685 }
21686 return resultobj;
21687 fail:
21688 return NULL;
21689 }
21690
21691
21692 SWIGINTERN PyObject *_wrap_DC_SetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21693 PyObject *resultobj = 0;
21694 wxDC *arg1 = (wxDC *) 0 ;
21695 double arg2 ;
21696 double arg3 ;
21697 void *argp1 = 0 ;
21698 int res1 = 0 ;
21699 double val2 ;
21700 int ecode2 = 0 ;
21701 double val3 ;
21702 int ecode3 = 0 ;
21703 PyObject * obj0 = 0 ;
21704 PyObject * obj1 = 0 ;
21705 PyObject * obj2 = 0 ;
21706 char * kwnames[] = {
21707 (char *) "self",(char *) "x",(char *) "y", NULL
21708 };
21709
21710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21712 if (!SWIG_IsOK(res1)) {
21713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetUserScale" "', expected argument " "1"" of type '" "wxDC *""'");
21714 }
21715 arg1 = reinterpret_cast< wxDC * >(argp1);
21716 ecode2 = SWIG_AsVal_double(obj1, &val2);
21717 if (!SWIG_IsOK(ecode2)) {
21718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetUserScale" "', expected argument " "2"" of type '" "double""'");
21719 }
21720 arg2 = static_cast< double >(val2);
21721 ecode3 = SWIG_AsVal_double(obj2, &val3);
21722 if (!SWIG_IsOK(ecode3)) {
21723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetUserScale" "', expected argument " "3"" of type '" "double""'");
21724 }
21725 arg3 = static_cast< double >(val3);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 (arg1)->SetUserScale(arg2,arg3);
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_DC_GetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *resultobj = 0;
21741 wxDC *arg1 = (wxDC *) 0 ;
21742 double *arg2 = (double *) 0 ;
21743 double *arg3 = (double *) 0 ;
21744 void *argp1 = 0 ;
21745 int res1 = 0 ;
21746 double temp2 ;
21747 int res2 = SWIG_TMPOBJ ;
21748 double temp3 ;
21749 int res3 = SWIG_TMPOBJ ;
21750 PyObject *swig_obj[1] ;
21751
21752 arg2 = &temp2;
21753 arg3 = &temp3;
21754 if (!args) SWIG_fail;
21755 swig_obj[0] = args;
21756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21757 if (!SWIG_IsOK(res1)) {
21758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
21759 }
21760 arg1 = reinterpret_cast< wxDC * >(argp1);
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 (arg1)->GetLogicalScale(arg2,arg3);
21764 wxPyEndAllowThreads(__tstate);
21765 if (PyErr_Occurred()) SWIG_fail;
21766 }
21767 resultobj = SWIG_Py_Void();
21768 if (SWIG_IsTmpObj(res2)) {
21769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
21770 } else {
21771 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21773 }
21774 if (SWIG_IsTmpObj(res3)) {
21775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
21776 } else {
21777 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
21779 }
21780 return resultobj;
21781 fail:
21782 return NULL;
21783 }
21784
21785
21786 SWIGINTERN PyObject *_wrap_DC_SetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj = 0;
21788 wxDC *arg1 = (wxDC *) 0 ;
21789 double arg2 ;
21790 double arg3 ;
21791 void *argp1 = 0 ;
21792 int res1 = 0 ;
21793 double val2 ;
21794 int ecode2 = 0 ;
21795 double val3 ;
21796 int ecode3 = 0 ;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 PyObject * obj2 = 0 ;
21800 char * kwnames[] = {
21801 (char *) "self",(char *) "x",(char *) "y", NULL
21802 };
21803
21804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
21808 }
21809 arg1 = reinterpret_cast< wxDC * >(argp1);
21810 ecode2 = SWIG_AsVal_double(obj1, &val2);
21811 if (!SWIG_IsOK(ecode2)) {
21812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalScale" "', expected argument " "2"" of type '" "double""'");
21813 }
21814 arg2 = static_cast< double >(val2);
21815 ecode3 = SWIG_AsVal_double(obj2, &val3);
21816 if (!SWIG_IsOK(ecode3)) {
21817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalScale" "', expected argument " "3"" of type '" "double""'");
21818 }
21819 arg3 = static_cast< double >(val3);
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 (arg1)->SetLogicalScale(arg2,arg3);
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 resultobj = SWIG_Py_Void();
21827 return resultobj;
21828 fail:
21829 return NULL;
21830 }
21831
21832
21833 SWIGINTERN PyObject *_wrap_DC_GetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21834 PyObject *resultobj = 0;
21835 wxDC *arg1 = (wxDC *) 0 ;
21836 wxPoint result;
21837 void *argp1 = 0 ;
21838 int res1 = 0 ;
21839 PyObject *swig_obj[1] ;
21840
21841 if (!args) SWIG_fail;
21842 swig_obj[0] = args;
21843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21844 if (!SWIG_IsOK(res1)) {
21845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
21846 }
21847 arg1 = reinterpret_cast< wxDC * >(argp1);
21848 {
21849 PyThreadState* __tstate = wxPyBeginAllowThreads();
21850 result = ((wxDC const *)arg1)->GetLogicalOrigin();
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 SWIGINTERN PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21862 PyObject *resultobj = 0;
21863 wxDC *arg1 = (wxDC *) 0 ;
21864 int *arg2 = (int *) 0 ;
21865 int *arg3 = (int *) 0 ;
21866 void *argp1 = 0 ;
21867 int res1 = 0 ;
21868 int temp2 ;
21869 int res2 = SWIG_TMPOBJ ;
21870 int temp3 ;
21871 int res3 = SWIG_TMPOBJ ;
21872 PyObject *swig_obj[1] ;
21873
21874 arg2 = &temp2;
21875 arg3 = &temp3;
21876 if (!args) SWIG_fail;
21877 swig_obj[0] = args;
21878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
21881 }
21882 arg1 = reinterpret_cast< wxDC * >(argp1);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 resultobj = SWIG_Py_Void();
21890 if (SWIG_IsTmpObj(res2)) {
21891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
21892 } else {
21893 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
21895 }
21896 if (SWIG_IsTmpObj(res3)) {
21897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21898 } else {
21899 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *_wrap_DC_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21909 PyObject *resultobj = 0;
21910 wxDC *arg1 = (wxDC *) 0 ;
21911 int arg2 ;
21912 int arg3 ;
21913 void *argp1 = 0 ;
21914 int res1 = 0 ;
21915 int val2 ;
21916 int ecode2 = 0 ;
21917 int val3 ;
21918 int ecode3 = 0 ;
21919 PyObject * obj0 = 0 ;
21920 PyObject * obj1 = 0 ;
21921 PyObject * obj2 = 0 ;
21922 char * kwnames[] = {
21923 (char *) "self",(char *) "x",(char *) "y", NULL
21924 };
21925
21926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21928 if (!SWIG_IsOK(res1)) {
21929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
21930 }
21931 arg1 = reinterpret_cast< wxDC * >(argp1);
21932 ecode2 = SWIG_AsVal_int(obj1, &val2);
21933 if (!SWIG_IsOK(ecode2)) {
21934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
21935 }
21936 arg2 = static_cast< int >(val2);
21937 ecode3 = SWIG_AsVal_int(obj2, &val3);
21938 if (!SWIG_IsOK(ecode3)) {
21939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
21940 }
21941 arg3 = static_cast< int >(val3);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 (arg1)->SetLogicalOrigin(arg2,arg3);
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 resultobj = SWIG_Py_Void();
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21956 PyObject *resultobj = 0;
21957 wxDC *arg1 = (wxDC *) 0 ;
21958 wxPoint *arg2 = 0 ;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 wxPoint temp2 ;
21962 PyObject * obj0 = 0 ;
21963 PyObject * obj1 = 0 ;
21964 char * kwnames[] = {
21965 (char *) "self",(char *) "point", NULL
21966 };
21967
21968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
21969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21970 if (!SWIG_IsOK(res1)) {
21971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
21972 }
21973 arg1 = reinterpret_cast< wxDC * >(argp1);
21974 {
21975 arg2 = &temp2;
21976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21977 }
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 resultobj = SWIG_Py_Void();
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_DC_GetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21992 PyObject *resultobj = 0;
21993 wxDC *arg1 = (wxDC *) 0 ;
21994 wxPoint result;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 PyObject *swig_obj[1] ;
21998
21999 if (!args) SWIG_fail;
22000 swig_obj[0] = args;
22001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22002 if (!SWIG_IsOK(res1)) {
22003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
22004 }
22005 arg1 = reinterpret_cast< wxDC * >(argp1);
22006 {
22007 PyThreadState* __tstate = wxPyBeginAllowThreads();
22008 result = ((wxDC const *)arg1)->GetDeviceOrigin();
22009 wxPyEndAllowThreads(__tstate);
22010 if (PyErr_Occurred()) SWIG_fail;
22011 }
22012 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22013 return resultobj;
22014 fail:
22015 return NULL;
22016 }
22017
22018
22019 SWIGINTERN PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22020 PyObject *resultobj = 0;
22021 wxDC *arg1 = (wxDC *) 0 ;
22022 int *arg2 = (int *) 0 ;
22023 int *arg3 = (int *) 0 ;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 int temp2 ;
22027 int res2 = SWIG_TMPOBJ ;
22028 int temp3 ;
22029 int res3 = SWIG_TMPOBJ ;
22030 PyObject *swig_obj[1] ;
22031
22032 arg2 = &temp2;
22033 arg3 = &temp3;
22034 if (!args) SWIG_fail;
22035 swig_obj[0] = args;
22036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22037 if (!SWIG_IsOK(res1)) {
22038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
22039 }
22040 arg1 = reinterpret_cast< wxDC * >(argp1);
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 resultobj = SWIG_Py_Void();
22048 if (SWIG_IsTmpObj(res2)) {
22049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22050 } else {
22051 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22053 }
22054 if (SWIG_IsTmpObj(res3)) {
22055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22056 } else {
22057 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_DC_SetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22067 PyObject *resultobj = 0;
22068 wxDC *arg1 = (wxDC *) 0 ;
22069 int arg2 ;
22070 int arg3 ;
22071 void *argp1 = 0 ;
22072 int res1 = 0 ;
22073 int val2 ;
22074 int ecode2 = 0 ;
22075 int val3 ;
22076 int ecode3 = 0 ;
22077 PyObject * obj0 = 0 ;
22078 PyObject * obj1 = 0 ;
22079 PyObject * obj2 = 0 ;
22080 char * kwnames[] = {
22081 (char *) "self",(char *) "x",(char *) "y", NULL
22082 };
22083
22084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22086 if (!SWIG_IsOK(res1)) {
22087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22088 }
22089 arg1 = reinterpret_cast< wxDC * >(argp1);
22090 ecode2 = SWIG_AsVal_int(obj1, &val2);
22091 if (!SWIG_IsOK(ecode2)) {
22092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetDeviceOrigin" "', expected argument " "2"" of type '" "int""'");
22093 }
22094 arg2 = static_cast< int >(val2);
22095 ecode3 = SWIG_AsVal_int(obj2, &val3);
22096 if (!SWIG_IsOK(ecode3)) {
22097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetDeviceOrigin" "', expected argument " "3"" of type '" "int""'");
22098 }
22099 arg3 = static_cast< int >(val3);
22100 {
22101 PyThreadState* __tstate = wxPyBeginAllowThreads();
22102 (arg1)->SetDeviceOrigin(arg2,arg3);
22103 wxPyEndAllowThreads(__tstate);
22104 if (PyErr_Occurred()) SWIG_fail;
22105 }
22106 resultobj = SWIG_Py_Void();
22107 return resultobj;
22108 fail:
22109 return NULL;
22110 }
22111
22112
22113 SWIGINTERN PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22114 PyObject *resultobj = 0;
22115 wxDC *arg1 = (wxDC *) 0 ;
22116 wxPoint *arg2 = 0 ;
22117 void *argp1 = 0 ;
22118 int res1 = 0 ;
22119 wxPoint temp2 ;
22120 PyObject * obj0 = 0 ;
22121 PyObject * obj1 = 0 ;
22122 char * kwnames[] = {
22123 (char *) "self",(char *) "point", NULL
22124 };
22125
22126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22130 }
22131 arg1 = reinterpret_cast< wxDC * >(argp1);
22132 {
22133 arg2 = &temp2;
22134 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22135 }
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 resultobj = SWIG_Py_Void();
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 SWIGINTERN PyObject *_wrap_DC_SetAxisOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22150 PyObject *resultobj = 0;
22151 wxDC *arg1 = (wxDC *) 0 ;
22152 bool arg2 ;
22153 bool arg3 ;
22154 void *argp1 = 0 ;
22155 int res1 = 0 ;
22156 bool val2 ;
22157 int ecode2 = 0 ;
22158 bool val3 ;
22159 int ecode3 = 0 ;
22160 PyObject * obj0 = 0 ;
22161 PyObject * obj1 = 0 ;
22162 PyObject * obj2 = 0 ;
22163 char * kwnames[] = {
22164 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
22165 };
22166
22167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22169 if (!SWIG_IsOK(res1)) {
22170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetAxisOrientation" "', expected argument " "1"" of type '" "wxDC *""'");
22171 }
22172 arg1 = reinterpret_cast< wxDC * >(argp1);
22173 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22174 if (!SWIG_IsOK(ecode2)) {
22175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetAxisOrientation" "', expected argument " "2"" of type '" "bool""'");
22176 }
22177 arg2 = static_cast< bool >(val2);
22178 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22179 if (!SWIG_IsOK(ecode3)) {
22180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetAxisOrientation" "', expected argument " "3"" of type '" "bool""'");
22181 }
22182 arg3 = static_cast< bool >(val3);
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 (arg1)->SetAxisOrientation(arg2,arg3);
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 resultobj = SWIG_Py_Void();
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_DC_GetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxDC *arg1 = (wxDC *) 0 ;
22199 int result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 PyObject *swig_obj[1] ;
22203
22204 if (!args) SWIG_fail;
22205 swig_obj[0] = args;
22206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalFunction" "', expected argument " "1"" of type '" "wxDC const *""'");
22209 }
22210 arg1 = reinterpret_cast< wxDC * >(argp1);
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_From_int(static_cast< int >(result));
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_DC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22225 PyObject *resultobj = 0;
22226 wxDC *arg1 = (wxDC *) 0 ;
22227 int arg2 ;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 int val2 ;
22231 int ecode2 = 0 ;
22232 PyObject * obj0 = 0 ;
22233 PyObject * obj1 = 0 ;
22234 char * kwnames[] = {
22235 (char *) "self",(char *) "function", NULL
22236 };
22237
22238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
22239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22240 if (!SWIG_IsOK(res1)) {
22241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxDC *""'");
22242 }
22243 arg1 = reinterpret_cast< wxDC * >(argp1);
22244 ecode2 = SWIG_AsVal_int(obj1, &val2);
22245 if (!SWIG_IsOK(ecode2)) {
22246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
22247 }
22248 arg2 = static_cast< int >(val2);
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 (arg1)->SetLogicalFunction(arg2);
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_Py_Void();
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22263 PyObject *resultobj = 0;
22264 wxDC *arg1 = (wxDC *) 0 ;
22265 void *argp1 = 0 ;
22266 int res1 = 0 ;
22267 PyObject *swig_obj[1] ;
22268
22269 if (!args) SWIG_fail;
22270 swig_obj[0] = args;
22271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22272 if (!SWIG_IsOK(res1)) {
22273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ComputeScaleAndOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22274 }
22275 arg1 = reinterpret_cast< wxDC * >(argp1);
22276 {
22277 PyThreadState* __tstate = wxPyBeginAllowThreads();
22278 (arg1)->ComputeScaleAndOrigin();
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = SWIG_Py_Void();
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22290 PyObject *resultobj = 0;
22291 wxDC *arg1 = (wxDC *) 0 ;
22292 int arg2 ;
22293 int arg3 ;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 int val2 ;
22297 int ecode2 = 0 ;
22298 int val3 ;
22299 int ecode3 = 0 ;
22300 PyObject * obj0 = 0 ;
22301 PyObject * obj1 = 0 ;
22302 PyObject * obj2 = 0 ;
22303 char * kwnames[] = {
22304 (char *) "self",(char *) "x",(char *) "y", NULL
22305 };
22306
22307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22309 if (!SWIG_IsOK(res1)) {
22310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22311 }
22312 arg1 = reinterpret_cast< wxDC * >(argp1);
22313 ecode2 = SWIG_AsVal_int(obj1, &val2);
22314 if (!SWIG_IsOK(ecode2)) {
22315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CalcBoundingBox" "', expected argument " "2"" of type '" "int""'");
22316 }
22317 arg2 = static_cast< int >(val2);
22318 ecode3 = SWIG_AsVal_int(obj2, &val3);
22319 if (!SWIG_IsOK(ecode3)) {
22320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CalcBoundingBox" "', expected argument " "3"" of type '" "int""'");
22321 }
22322 arg3 = static_cast< int >(val3);
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 (arg1)->CalcBoundingBox(arg2,arg3);
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 resultobj = SWIG_Py_Void();
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj = 0;
22338 wxDC *arg1 = (wxDC *) 0 ;
22339 wxPoint *arg2 = 0 ;
22340 void *argp1 = 0 ;
22341 int res1 = 0 ;
22342 wxPoint temp2 ;
22343 PyObject * obj0 = 0 ;
22344 PyObject * obj1 = 0 ;
22345 char * kwnames[] = {
22346 (char *) "self",(char *) "point", NULL
22347 };
22348
22349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22351 if (!SWIG_IsOK(res1)) {
22352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBoxPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22353 }
22354 arg1 = reinterpret_cast< wxDC * >(argp1);
22355 {
22356 arg2 = &temp2;
22357 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22358 }
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_Py_Void();
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 SWIGINTERN PyObject *_wrap_DC_ResetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22373 PyObject *resultobj = 0;
22374 wxDC *arg1 = (wxDC *) 0 ;
22375 void *argp1 = 0 ;
22376 int res1 = 0 ;
22377 PyObject *swig_obj[1] ;
22378
22379 if (!args) SWIG_fail;
22380 swig_obj[0] = args;
22381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22382 if (!SWIG_IsOK(res1)) {
22383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ResetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22384 }
22385 arg1 = reinterpret_cast< wxDC * >(argp1);
22386 {
22387 PyThreadState* __tstate = wxPyBeginAllowThreads();
22388 (arg1)->ResetBoundingBox();
22389 wxPyEndAllowThreads(__tstate);
22390 if (PyErr_Occurred()) SWIG_fail;
22391 }
22392 resultobj = SWIG_Py_Void();
22393 return resultobj;
22394 fail:
22395 return NULL;
22396 }
22397
22398
22399 SWIGINTERN PyObject *_wrap_DC_MinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22400 PyObject *resultobj = 0;
22401 wxDC *arg1 = (wxDC *) 0 ;
22402 int result;
22403 void *argp1 = 0 ;
22404 int res1 = 0 ;
22405 PyObject *swig_obj[1] ;
22406
22407 if (!args) SWIG_fail;
22408 swig_obj[0] = args;
22409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22410 if (!SWIG_IsOK(res1)) {
22411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinX" "', expected argument " "1"" of type '" "wxDC const *""'");
22412 }
22413 arg1 = reinterpret_cast< wxDC * >(argp1);
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 result = (int)((wxDC const *)arg1)->MinX();
22417 wxPyEndAllowThreads(__tstate);
22418 if (PyErr_Occurred()) SWIG_fail;
22419 }
22420 resultobj = SWIG_From_int(static_cast< int >(result));
22421 return resultobj;
22422 fail:
22423 return NULL;
22424 }
22425
22426
22427 SWIGINTERN PyObject *_wrap_DC_MaxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22428 PyObject *resultobj = 0;
22429 wxDC *arg1 = (wxDC *) 0 ;
22430 int result;
22431 void *argp1 = 0 ;
22432 int res1 = 0 ;
22433 PyObject *swig_obj[1] ;
22434
22435 if (!args) SWIG_fail;
22436 swig_obj[0] = args;
22437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22438 if (!SWIG_IsOK(res1)) {
22439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxX" "', expected argument " "1"" of type '" "wxDC const *""'");
22440 }
22441 arg1 = reinterpret_cast< wxDC * >(argp1);
22442 {
22443 PyThreadState* __tstate = wxPyBeginAllowThreads();
22444 result = (int)((wxDC const *)arg1)->MaxX();
22445 wxPyEndAllowThreads(__tstate);
22446 if (PyErr_Occurred()) SWIG_fail;
22447 }
22448 resultobj = SWIG_From_int(static_cast< int >(result));
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 SWIGINTERN PyObject *_wrap_DC_MinY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22456 PyObject *resultobj = 0;
22457 wxDC *arg1 = (wxDC *) 0 ;
22458 int result;
22459 void *argp1 = 0 ;
22460 int res1 = 0 ;
22461 PyObject *swig_obj[1] ;
22462
22463 if (!args) SWIG_fail;
22464 swig_obj[0] = args;
22465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinY" "', expected argument " "1"" of type '" "wxDC const *""'");
22468 }
22469 arg1 = reinterpret_cast< wxDC * >(argp1);
22470 {
22471 PyThreadState* __tstate = wxPyBeginAllowThreads();
22472 result = (int)((wxDC const *)arg1)->MinY();
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 resultobj = SWIG_From_int(static_cast< int >(result));
22477 return resultobj;
22478 fail:
22479 return NULL;
22480 }
22481
22482
22483 SWIGINTERN PyObject *_wrap_DC_MaxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22484 PyObject *resultobj = 0;
22485 wxDC *arg1 = (wxDC *) 0 ;
22486 int result;
22487 void *argp1 = 0 ;
22488 int res1 = 0 ;
22489 PyObject *swig_obj[1] ;
22490
22491 if (!args) SWIG_fail;
22492 swig_obj[0] = args;
22493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22494 if (!SWIG_IsOK(res1)) {
22495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxY" "', expected argument " "1"" of type '" "wxDC const *""'");
22496 }
22497 arg1 = reinterpret_cast< wxDC * >(argp1);
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 result = (int)((wxDC const *)arg1)->MaxY();
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 resultobj = SWIG_From_int(static_cast< int >(result));
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_DC_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22512 PyObject *resultobj = 0;
22513 wxDC *arg1 = (wxDC *) 0 ;
22514 int *arg2 = (int *) 0 ;
22515 int *arg3 = (int *) 0 ;
22516 int *arg4 = (int *) 0 ;
22517 int *arg5 = (int *) 0 ;
22518 void *argp1 = 0 ;
22519 int res1 = 0 ;
22520 int temp2 ;
22521 int res2 = SWIG_TMPOBJ ;
22522 int temp3 ;
22523 int res3 = SWIG_TMPOBJ ;
22524 int temp4 ;
22525 int res4 = SWIG_TMPOBJ ;
22526 int temp5 ;
22527 int res5 = SWIG_TMPOBJ ;
22528 PyObject *swig_obj[1] ;
22529
22530 arg2 = &temp2;
22531 arg3 = &temp3;
22532 arg4 = &temp4;
22533 arg5 = &temp5;
22534 if (!args) SWIG_fail;
22535 swig_obj[0] = args;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22539 }
22540 arg1 = reinterpret_cast< wxDC * >(argp1);
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 resultobj = SWIG_Py_Void();
22548 if (SWIG_IsTmpObj(res2)) {
22549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22550 } else {
22551 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22553 }
22554 if (SWIG_IsTmpObj(res3)) {
22555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22556 } else {
22557 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22559 }
22560 if (SWIG_IsTmpObj(res4)) {
22561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
22562 } else {
22563 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
22565 }
22566 if (SWIG_IsTmpObj(res5)) {
22567 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
22568 } else {
22569 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22570 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
22571 }
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_DC__DrawPointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj = 0;
22580 wxDC *arg1 = (wxDC *) 0 ;
22581 PyObject *arg2 = (PyObject *) 0 ;
22582 PyObject *arg3 = (PyObject *) 0 ;
22583 PyObject *arg4 = (PyObject *) 0 ;
22584 PyObject *result = 0 ;
22585 void *argp1 = 0 ;
22586 int res1 = 0 ;
22587 PyObject * obj0 = 0 ;
22588 PyObject * obj1 = 0 ;
22589 PyObject * obj2 = 0 ;
22590 PyObject * obj3 = 0 ;
22591 char * kwnames[] = {
22592 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22593 };
22594
22595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22597 if (!SWIG_IsOK(res1)) {
22598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPointList" "', expected argument " "1"" of type '" "wxDC *""'");
22599 }
22600 arg1 = reinterpret_cast< wxDC * >(argp1);
22601 arg2 = obj1;
22602 arg3 = obj2;
22603 arg4 = obj3;
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 resultobj = result;
22611 return resultobj;
22612 fail:
22613 return NULL;
22614 }
22615
22616
22617 SWIGINTERN PyObject *_wrap_DC__DrawLineList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22618 PyObject *resultobj = 0;
22619 wxDC *arg1 = (wxDC *) 0 ;
22620 PyObject *arg2 = (PyObject *) 0 ;
22621 PyObject *arg3 = (PyObject *) 0 ;
22622 PyObject *arg4 = (PyObject *) 0 ;
22623 PyObject *result = 0 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 PyObject * obj0 = 0 ;
22627 PyObject * obj1 = 0 ;
22628 PyObject * obj2 = 0 ;
22629 PyObject * obj3 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawLineList" "', expected argument " "1"" of type '" "wxDC *""'");
22638 }
22639 arg1 = reinterpret_cast< wxDC * >(argp1);
22640 arg2 = obj1;
22641 arg3 = obj2;
22642 arg4 = obj3;
22643 {
22644 PyThreadState* __tstate = wxPyBeginAllowThreads();
22645 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = result;
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 SWIGINTERN PyObject *_wrap_DC__DrawRectangleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22657 PyObject *resultobj = 0;
22658 wxDC *arg1 = (wxDC *) 0 ;
22659 PyObject *arg2 = (PyObject *) 0 ;
22660 PyObject *arg3 = (PyObject *) 0 ;
22661 PyObject *arg4 = (PyObject *) 0 ;
22662 PyObject *result = 0 ;
22663 void *argp1 = 0 ;
22664 int res1 = 0 ;
22665 PyObject * obj0 = 0 ;
22666 PyObject * obj1 = 0 ;
22667 PyObject * obj2 = 0 ;
22668 PyObject * obj3 = 0 ;
22669 char * kwnames[] = {
22670 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22671 };
22672
22673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawRectangleList" "', expected argument " "1"" of type '" "wxDC *""'");
22677 }
22678 arg1 = reinterpret_cast< wxDC * >(argp1);
22679 arg2 = obj1;
22680 arg3 = obj2;
22681 arg4 = obj3;
22682 {
22683 PyThreadState* __tstate = wxPyBeginAllowThreads();
22684 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
22685 wxPyEndAllowThreads(__tstate);
22686 if (PyErr_Occurred()) SWIG_fail;
22687 }
22688 resultobj = result;
22689 return resultobj;
22690 fail:
22691 return NULL;
22692 }
22693
22694
22695 SWIGINTERN PyObject *_wrap_DC__DrawEllipseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22696 PyObject *resultobj = 0;
22697 wxDC *arg1 = (wxDC *) 0 ;
22698 PyObject *arg2 = (PyObject *) 0 ;
22699 PyObject *arg3 = (PyObject *) 0 ;
22700 PyObject *arg4 = (PyObject *) 0 ;
22701 PyObject *result = 0 ;
22702 void *argp1 = 0 ;
22703 int res1 = 0 ;
22704 PyObject * obj0 = 0 ;
22705 PyObject * obj1 = 0 ;
22706 PyObject * obj2 = 0 ;
22707 PyObject * obj3 = 0 ;
22708 char * kwnames[] = {
22709 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22710 };
22711
22712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawEllipseList" "', expected argument " "1"" of type '" "wxDC *""'");
22716 }
22717 arg1 = reinterpret_cast< wxDC * >(argp1);
22718 arg2 = obj1;
22719 arg3 = obj2;
22720 arg4 = obj3;
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
22724 wxPyEndAllowThreads(__tstate);
22725 if (PyErr_Occurred()) SWIG_fail;
22726 }
22727 resultobj = result;
22728 return resultobj;
22729 fail:
22730 return NULL;
22731 }
22732
22733
22734 SWIGINTERN PyObject *_wrap_DC__DrawPolygonList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22735 PyObject *resultobj = 0;
22736 wxDC *arg1 = (wxDC *) 0 ;
22737 PyObject *arg2 = (PyObject *) 0 ;
22738 PyObject *arg3 = (PyObject *) 0 ;
22739 PyObject *arg4 = (PyObject *) 0 ;
22740 PyObject *result = 0 ;
22741 void *argp1 = 0 ;
22742 int res1 = 0 ;
22743 PyObject * obj0 = 0 ;
22744 PyObject * obj1 = 0 ;
22745 PyObject * obj2 = 0 ;
22746 PyObject * obj3 = 0 ;
22747 char * kwnames[] = {
22748 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
22749 };
22750
22751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22753 if (!SWIG_IsOK(res1)) {
22754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPolygonList" "', expected argument " "1"" of type '" "wxDC *""'");
22755 }
22756 arg1 = reinterpret_cast< wxDC * >(argp1);
22757 arg2 = obj1;
22758 arg3 = obj2;
22759 arg4 = obj3;
22760 {
22761 PyThreadState* __tstate = wxPyBeginAllowThreads();
22762 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = result;
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *_wrap_DC__DrawTextList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22774 PyObject *resultobj = 0;
22775 wxDC *arg1 = (wxDC *) 0 ;
22776 PyObject *arg2 = (PyObject *) 0 ;
22777 PyObject *arg3 = (PyObject *) 0 ;
22778 PyObject *arg4 = (PyObject *) 0 ;
22779 PyObject *arg5 = (PyObject *) 0 ;
22780 PyObject *result = 0 ;
22781 void *argp1 = 0 ;
22782 int res1 = 0 ;
22783 PyObject * obj0 = 0 ;
22784 PyObject * obj1 = 0 ;
22785 PyObject * obj2 = 0 ;
22786 PyObject * obj3 = 0 ;
22787 PyObject * obj4 = 0 ;
22788 char * kwnames[] = {
22789 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
22790 };
22791
22792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22794 if (!SWIG_IsOK(res1)) {
22795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawTextList" "', expected argument " "1"" of type '" "wxDC *""'");
22796 }
22797 arg1 = reinterpret_cast< wxDC * >(argp1);
22798 arg2 = obj1;
22799 arg3 = obj2;
22800 arg4 = obj3;
22801 arg5 = obj4;
22802 {
22803 PyThreadState* __tstate = wxPyBeginAllowThreads();
22804 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
22805 wxPyEndAllowThreads(__tstate);
22806 if (PyErr_Occurred()) SWIG_fail;
22807 }
22808 resultobj = result;
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 SWIGINTERN PyObject *DC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22816 PyObject *obj;
22817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22818 SWIG_TypeNewClientData(SWIGTYPE_p_wxDC, SWIG_NewClientData(obj));
22819 return SWIG_Py_Void();
22820 }
22821
22822 SWIGINTERN PyObject *_wrap_new_MemoryDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22823 PyObject *resultobj = 0;
22824 wxMemoryDC *result = 0 ;
22825
22826 if (!SWIG_Python_UnpackTuple(args,"new_MemoryDC",0,0,0)) SWIG_fail;
22827 {
22828 if (!wxPyCheckForApp()) SWIG_fail;
22829 PyThreadState* __tstate = wxPyBeginAllowThreads();
22830 result = (wxMemoryDC *)new wxMemoryDC();
22831 wxPyEndAllowThreads(__tstate);
22832 if (PyErr_Occurred()) SWIG_fail;
22833 }
22834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_NEW | 0 );
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_new_MemoryDCFromDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxDC *arg1 = (wxDC *) 0 ;
22844 wxMemoryDC *result = 0 ;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 PyObject * obj0 = 0 ;
22848 char * kwnames[] = {
22849 (char *) "oldDC", NULL
22850 };
22851
22852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) SWIG_fail;
22853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryDCFromDC" "', expected argument " "1"" of type '" "wxDC *""'");
22856 }
22857 arg1 = reinterpret_cast< wxDC * >(argp1);
22858 {
22859 if (!wxPyCheckForApp()) SWIG_fail;
22860 PyThreadState* __tstate = wxPyBeginAllowThreads();
22861 result = (wxMemoryDC *)new wxMemoryDC(arg1);
22862 wxPyEndAllowThreads(__tstate);
22863 if (PyErr_Occurred()) SWIG_fail;
22864 }
22865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_OWN | 0 );
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 SWIGINTERN PyObject *_wrap_MemoryDC_SelectObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj = 0;
22874 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
22875 wxBitmap *arg2 = 0 ;
22876 void *argp1 = 0 ;
22877 int res1 = 0 ;
22878 void *argp2 = 0 ;
22879 int res2 = 0 ;
22880 PyObject * obj0 = 0 ;
22881 PyObject * obj1 = 0 ;
22882 char * kwnames[] = {
22883 (char *) "self",(char *) "bitmap", NULL
22884 };
22885
22886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) SWIG_fail;
22887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryDC, 0 | 0 );
22888 if (!SWIG_IsOK(res1)) {
22889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryDC_SelectObject" "', expected argument " "1"" of type '" "wxMemoryDC *""'");
22890 }
22891 arg1 = reinterpret_cast< wxMemoryDC * >(argp1);
22892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
22893 if (!SWIG_IsOK(res2)) {
22894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22895 }
22896 if (!argp2) {
22897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22898 }
22899 arg2 = reinterpret_cast< wxBitmap * >(argp2);
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 (arg1)->SelectObject((wxBitmap const &)*arg2);
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 resultobj = SWIG_Py_Void();
22907 return resultobj;
22908 fail:
22909 return NULL;
22910 }
22911
22912
22913 SWIGINTERN PyObject *MemoryDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22914 PyObject *obj;
22915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22916 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryDC, SWIG_NewClientData(obj));
22917 return SWIG_Py_Void();
22918 }
22919
22920 SWIGINTERN PyObject *MemoryDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22921 return SWIG_Python_InitShadowInstance(args);
22922 }
22923
22924 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
22925 PyObject *resultobj = 0;
22926 wxDC *arg1 = (wxDC *) 0 ;
22927 wxBitmap const &arg2_defvalue = wxNullBitmap ;
22928 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
22929 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
22930 wxBufferedDC *result = 0 ;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 void *argp2 = 0 ;
22934 int res2 = 0 ;
22935 int val3 ;
22936 int ecode3 = 0 ;
22937
22938 if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
22942 }
22943 arg1 = reinterpret_cast< wxDC * >(argp1);
22944 if (swig_obj[1]) {
22945 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
22946 if (!SWIG_IsOK(res2)) {
22947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22948 }
22949 if (!argp2) {
22950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
22951 }
22952 arg2 = reinterpret_cast< wxBitmap * >(argp2);
22953 }
22954 if (swig_obj[2]) {
22955 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
22956 if (!SWIG_IsOK(ecode3)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
22958 }
22959 arg3 = static_cast< int >(val3);
22960 }
22961 {
22962 if (!wxPyCheckForApp()) SWIG_fail;
22963 PyThreadState* __tstate = wxPyBeginAllowThreads();
22964 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
22965 wxPyEndAllowThreads(__tstate);
22966 if (PyErr_Occurred()) SWIG_fail;
22967 }
22968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
22976 PyObject *resultobj = 0;
22977 wxDC *arg1 = (wxDC *) 0 ;
22978 wxSize *arg2 = 0 ;
22979 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
22980 wxBufferedDC *result = 0 ;
22981 void *argp1 = 0 ;
22982 int res1 = 0 ;
22983 wxSize temp2 ;
22984 int val3 ;
22985 int ecode3 = 0 ;
22986
22987 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
22988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22989 if (!SWIG_IsOK(res1)) {
22990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
22991 }
22992 arg1 = reinterpret_cast< wxDC * >(argp1);
22993 {
22994 arg2 = &temp2;
22995 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
22996 }
22997 if (swig_obj[2]) {
22998 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
22999 if (!SWIG_IsOK(ecode3)) {
23000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
23001 }
23002 arg3 = static_cast< int >(val3);
23003 }
23004 {
23005 if (!wxPyCheckForApp()) SWIG_fail;
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
23019 int argc;
23020 PyObject *argv[4];
23021
23022 if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferedDC",0,3,argv))) SWIG_fail;
23023 --argc;
23024 if ((argc >= 1) && (argc <= 3)) {
23025 int _v = 0;
23026 if (argc > 1) {
23027 {
23028 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxBitmap, 0);
23029 _v = SWIG_CheckState(res);
23030 }
23031 if (!_v) goto check_1;
23032 }
23033 return _wrap_new_BufferedDC__SWIG_0(self, argc, argv);
23034 }
23035 check_1:
23036
23037 if ((argc >= 2) && (argc <= 3)) {
23038 return _wrap_new_BufferedDC__SWIG_1(self, argc, argv);
23039 }
23040
23041 fail:
23042 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
23043 return NULL;
23044 }
23045
23046
23047 SWIGINTERN PyObject *_wrap_delete_BufferedDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23048 PyObject *resultobj = 0;
23049 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23050 void *argp1 = 0 ;
23051 int res1 = 0 ;
23052 PyObject *swig_obj[1] ;
23053
23054 if (!args) SWIG_fail;
23055 swig_obj[0] = args;
23056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_DISOWN | 0 );
23057 if (!SWIG_IsOK(res1)) {
23058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferedDC" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23059 }
23060 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 delete arg1;
23064
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 resultobj = SWIG_Py_Void();
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *_wrap_BufferedDC_UnMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23076 PyObject *resultobj = 0;
23077 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23078 void *argp1 = 0 ;
23079 int res1 = 0 ;
23080 PyObject *swig_obj[1] ;
23081
23082 if (!args) SWIG_fail;
23083 swig_obj[0] = args;
23084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, 0 | 0 );
23085 if (!SWIG_IsOK(res1)) {
23086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferedDC_UnMask" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23087 }
23088 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23089 {
23090 PyThreadState* __tstate = wxPyBeginAllowThreads();
23091 (arg1)->UnMask();
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 resultobj = SWIG_Py_Void();
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 SWIGINTERN PyObject *BufferedDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23103 PyObject *obj;
23104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23105 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedDC, SWIG_NewClientData(obj));
23106 return SWIG_Py_Void();
23107 }
23108
23109 SWIGINTERN PyObject *BufferedDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 return SWIG_Python_InitShadowInstance(args);
23111 }
23112
23113 SWIGINTERN PyObject *_wrap_new_BufferedPaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23114 PyObject *resultobj = 0;
23115 wxWindow *arg1 = (wxWindow *) 0 ;
23116 wxBitmap const &arg2_defvalue = wxNullBitmap ;
23117 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
23118 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
23119 wxBufferedPaintDC *result = 0 ;
23120 void *argp1 = 0 ;
23121 int res1 = 0 ;
23122 void *argp2 = 0 ;
23123 int res2 = 0 ;
23124 int val3 ;
23125 int ecode3 = 0 ;
23126 PyObject * obj0 = 0 ;
23127 PyObject * obj1 = 0 ;
23128 PyObject * obj2 = 0 ;
23129 char * kwnames[] = {
23130 (char *) "window",(char *) "buffer",(char *) "style", NULL
23131 };
23132
23133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23135 if (!SWIG_IsOK(res1)) {
23136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedPaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23137 }
23138 arg1 = reinterpret_cast< wxWindow * >(argp1);
23139 if (obj1) {
23140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23141 if (!SWIG_IsOK(res2)) {
23142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23143 }
23144 if (!argp2) {
23145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23146 }
23147 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23148 }
23149 if (obj2) {
23150 ecode3 = SWIG_AsVal_int(obj2, &val3);
23151 if (!SWIG_IsOK(ecode3)) {
23152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedPaintDC" "', expected argument " "3"" of type '" "int""'");
23153 }
23154 arg3 = static_cast< int >(val3);
23155 }
23156 {
23157 if (!wxPyCheckForApp()) SWIG_fail;
23158 PyThreadState* __tstate = wxPyBeginAllowThreads();
23159 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
23160 wxPyEndAllowThreads(__tstate);
23161 if (PyErr_Occurred()) SWIG_fail;
23162 }
23163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedPaintDC, SWIG_POINTER_NEW | 0 );
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 SWIGINTERN PyObject *BufferedPaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23171 PyObject *obj;
23172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23173 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedPaintDC, SWIG_NewClientData(obj));
23174 return SWIG_Py_Void();
23175 }
23176
23177 SWIGINTERN PyObject *BufferedPaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23178 return SWIG_Python_InitShadowInstance(args);
23179 }
23180
23181 SWIGINTERN PyObject *_wrap_new_ScreenDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23182 PyObject *resultobj = 0;
23183 wxScreenDC *result = 0 ;
23184
23185 if (!SWIG_Python_UnpackTuple(args,"new_ScreenDC",0,0,0)) SWIG_fail;
23186 {
23187 if (!wxPyCheckForApp()) SWIG_fail;
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 result = (wxScreenDC *)new wxScreenDC();
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScreenDC, SWIG_POINTER_NEW | 0 );
23194 return resultobj;
23195 fail:
23196 return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23201 PyObject *resultobj = 0;
23202 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23203 wxWindow *arg2 = (wxWindow *) 0 ;
23204 bool result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 void *argp2 = 0 ;
23208 int res2 = 0 ;
23209 PyObject * obj0 = 0 ;
23210 PyObject * obj1 = 0 ;
23211 char * kwnames[] = {
23212 (char *) "self",(char *) "window", NULL
23213 };
23214
23215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) SWIG_fail;
23216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23217 if (!SWIG_IsOK(res1)) {
23218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23219 }
23220 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23222 if (!SWIG_IsOK(res2)) {
23223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "2"" of type '" "wxWindow *""'");
23224 }
23225 arg2 = reinterpret_cast< wxWindow * >(argp2);
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 {
23233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23234 }
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23244 wxRect *arg2 = (wxRect *) NULL ;
23245 bool result;
23246 void *argp1 = 0 ;
23247 int res1 = 0 ;
23248 void *argp2 = 0 ;
23249 int res2 = 0 ;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 char * kwnames[] = {
23253 (char *) "self",(char *) "rect", NULL
23254 };
23255
23256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) SWIG_fail;
23257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23260 }
23261 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23262 if (obj1) {
23263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23264 if (!SWIG_IsOK(res2)) {
23265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "2"" of type '" "wxRect *""'");
23266 }
23267 arg2 = reinterpret_cast< wxRect * >(argp2);
23268 }
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 {
23276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23277 }
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23285 PyObject *resultobj = 0;
23286 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23287 bool result;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 PyObject *swig_obj[1] ;
23291
23292 if (!args) SWIG_fail;
23293 swig_obj[0] = args;
23294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_EndDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23297 }
23298 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)(arg1)->EndDrawingOnTop();
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *ScreenDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *obj;
23316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23317 SWIG_TypeNewClientData(SWIGTYPE_p_wxScreenDC, SWIG_NewClientData(obj));
23318 return SWIG_Py_Void();
23319 }
23320
23321 SWIGINTERN PyObject *ScreenDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 return SWIG_Python_InitShadowInstance(args);
23323 }
23324
23325 SWIGINTERN PyObject *_wrap_new_ClientDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj = 0;
23327 wxWindow *arg1 = (wxWindow *) 0 ;
23328 wxClientDC *result = 0 ;
23329 void *argp1 = 0 ;
23330 int res1 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "win", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) SWIG_fail;
23337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23338 if (!SWIG_IsOK(res1)) {
23339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23340 }
23341 arg1 = reinterpret_cast< wxWindow * >(argp1);
23342 {
23343 if (!wxPyCheckForApp()) SWIG_fail;
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxClientDC *)new wxClientDC(arg1);
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClientDC, SWIG_POINTER_NEW | 0 );
23350 return resultobj;
23351 fail:
23352 return NULL;
23353 }
23354
23355
23356 SWIGINTERN PyObject *ClientDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23357 PyObject *obj;
23358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23359 SWIG_TypeNewClientData(SWIGTYPE_p_wxClientDC, SWIG_NewClientData(obj));
23360 return SWIG_Py_Void();
23361 }
23362
23363 SWIGINTERN PyObject *ClientDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23364 return SWIG_Python_InitShadowInstance(args);
23365 }
23366
23367 SWIGINTERN PyObject *_wrap_new_PaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj = 0;
23369 wxWindow *arg1 = (wxWindow *) 0 ;
23370 wxPaintDC *result = 0 ;
23371 void *argp1 = 0 ;
23372 int res1 = 0 ;
23373 PyObject * obj0 = 0 ;
23374 char * kwnames[] = {
23375 (char *) "win", NULL
23376 };
23377
23378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) SWIG_fail;
23379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23380 if (!SWIG_IsOK(res1)) {
23381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23382 }
23383 arg1 = reinterpret_cast< wxWindow * >(argp1);
23384 {
23385 if (!wxPyCheckForApp()) SWIG_fail;
23386 PyThreadState* __tstate = wxPyBeginAllowThreads();
23387 result = (wxPaintDC *)new wxPaintDC(arg1);
23388 wxPyEndAllowThreads(__tstate);
23389 if (PyErr_Occurred()) SWIG_fail;
23390 }
23391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintDC, SWIG_POINTER_NEW | 0 );
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 SWIGINTERN PyObject *PaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399 PyObject *obj;
23400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23401 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintDC, SWIG_NewClientData(obj));
23402 return SWIG_Py_Void();
23403 }
23404
23405 SWIGINTERN PyObject *PaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23406 return SWIG_Python_InitShadowInstance(args);
23407 }
23408
23409 SWIGINTERN PyObject *_wrap_new_WindowDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23410 PyObject *resultobj = 0;
23411 wxWindow *arg1 = (wxWindow *) 0 ;
23412 wxWindowDC *result = 0 ;
23413 void *argp1 = 0 ;
23414 int res1 = 0 ;
23415 PyObject * obj0 = 0 ;
23416 char * kwnames[] = {
23417 (char *) "win", NULL
23418 };
23419
23420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) SWIG_fail;
23421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23424 }
23425 arg1 = reinterpret_cast< wxWindow * >(argp1);
23426 {
23427 if (!wxPyCheckForApp()) SWIG_fail;
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 result = (wxWindowDC *)new wxWindowDC(arg1);
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDC, SWIG_POINTER_NEW | 0 );
23434 return resultobj;
23435 fail:
23436 return NULL;
23437 }
23438
23439
23440 SWIGINTERN PyObject *WindowDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23441 PyObject *obj;
23442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23443 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDC, SWIG_NewClientData(obj));
23444 return SWIG_Py_Void();
23445 }
23446
23447 SWIGINTERN PyObject *WindowDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23448 return SWIG_Python_InitShadowInstance(args);
23449 }
23450
23451 SWIGINTERN PyObject *_wrap_new_MirrorDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23452 PyObject *resultobj = 0;
23453 wxDC *arg1 = 0 ;
23454 bool arg2 ;
23455 wxMirrorDC *result = 0 ;
23456 void *argp1 = 0 ;
23457 int res1 = 0 ;
23458 bool val2 ;
23459 int ecode2 = 0 ;
23460 PyObject * obj0 = 0 ;
23461 PyObject * obj1 = 0 ;
23462 char * kwnames[] = {
23463 (char *) "dc",(char *) "mirror", NULL
23464 };
23465
23466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) SWIG_fail;
23467 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDC, 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
23470 }
23471 if (!argp1) {
23472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
23473 }
23474 arg1 = reinterpret_cast< wxDC * >(argp1);
23475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23476 if (!SWIG_IsOK(ecode2)) {
23477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MirrorDC" "', expected argument " "2"" of type '" "bool""'");
23478 }
23479 arg2 = static_cast< bool >(val2);
23480 {
23481 if (!wxPyCheckForApp()) SWIG_fail;
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
23484 wxPyEndAllowThreads(__tstate);
23485 if (PyErr_Occurred()) SWIG_fail;
23486 }
23487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMirrorDC, SWIG_POINTER_NEW | 0 );
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *MirrorDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *obj;
23496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23497 SWIG_TypeNewClientData(SWIGTYPE_p_wxMirrorDC, SWIG_NewClientData(obj));
23498 return SWIG_Py_Void();
23499 }
23500
23501 SWIGINTERN PyObject *MirrorDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 return SWIG_Python_InitShadowInstance(args);
23503 }
23504
23505 SWIGINTERN PyObject *_wrap_new_PostScriptDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23506 PyObject *resultobj = 0;
23507 wxPrintData *arg1 = 0 ;
23508 wxPostScriptDC *result = 0 ;
23509 void *argp1 = 0 ;
23510 int res1 = 0 ;
23511 PyObject * obj0 = 0 ;
23512 char * kwnames[] = {
23513 (char *) "printData", NULL
23514 };
23515
23516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) SWIG_fail;
23517 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
23518 if (!SWIG_IsOK(res1)) {
23519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23520 }
23521 if (!argp1) {
23522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23523 }
23524 arg1 = reinterpret_cast< wxPrintData * >(argp1);
23525 {
23526 if (!wxPyCheckForApp()) SWIG_fail;
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_NEW | 0 );
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540 PyObject *resultobj = 0;
23541 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
23542 wxPrintData *result = 0 ;
23543 void *argp1 = 0 ;
23544 int res1 = 0 ;
23545 PyObject *swig_obj[1] ;
23546
23547 if (!args) SWIG_fail;
23548 swig_obj[0] = args;
23549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
23550 if (!SWIG_IsOK(res1)) {
23551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_GetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
23552 }
23553 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
23554 {
23555 PyThreadState* __tstate = wxPyBeginAllowThreads();
23556 {
23557 wxPrintData &_result_ref = (arg1)->GetPrintData();
23558 result = (wxPrintData *) &_result_ref;
23559 }
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 SWIGINTERN PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj = 0;
23572 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
23573 wxPrintData *arg2 = 0 ;
23574 void *argp1 = 0 ;
23575 int res1 = 0 ;
23576 void *argp2 = 0 ;
23577 int res2 = 0 ;
23578 PyObject * obj0 = 0 ;
23579 PyObject * obj1 = 0 ;
23580 char * kwnames[] = {
23581 (char *) "self",(char *) "data", NULL
23582 };
23583
23584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;
23585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
23586 if (!SWIG_IsOK(res1)) {
23587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
23588 }
23589 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
23590 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);
23591 if (!SWIG_IsOK(res2)) {
23592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
23593 }
23594 if (!argp2) {
23595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
23596 }
23597 arg2 = reinterpret_cast< wxPrintData * >(argp2);
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 (arg1)->SetPrintData((wxPrintData const &)*arg2);
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 resultobj = SWIG_Py_Void();
23605 return resultobj;
23606 fail:
23607 return NULL;
23608 }
23609
23610
23611 SWIGINTERN PyObject *_wrap_PostScriptDC_SetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23612 PyObject *resultobj = 0;
23613 int arg1 ;
23614 int val1 ;
23615 int ecode1 = 0 ;
23616 PyObject * obj0 = 0 ;
23617 char * kwnames[] = {
23618 (char *) "ppi", NULL
23619 };
23620
23621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) SWIG_fail;
23622 ecode1 = SWIG_AsVal_int(obj0, &val1);
23623 if (!SWIG_IsOK(ecode1)) {
23624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PostScriptDC_SetResolution" "', expected argument " "1"" of type '" "int""'");
23625 }
23626 arg1 = static_cast< int >(val1);
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 wxPostScriptDC::SetResolution(arg1);
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_Py_Void();
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *_wrap_PostScriptDC_GetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641 PyObject *resultobj = 0;
23642 int result;
23643
23644 if (!SWIG_Python_UnpackTuple(args,"PostScriptDC_GetResolution",0,0,0)) SWIG_fail;
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 result = (int)wxPostScriptDC::GetResolution();
23648 wxPyEndAllowThreads(__tstate);
23649 if (PyErr_Occurred()) SWIG_fail;
23650 }
23651 resultobj = SWIG_From_int(static_cast< int >(result));
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 SWIGINTERN PyObject *PostScriptDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23659 PyObject *obj;
23660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23661 SWIG_TypeNewClientData(SWIGTYPE_p_wxPostScriptDC, SWIG_NewClientData(obj));
23662 return SWIG_Py_Void();
23663 }
23664
23665 SWIGINTERN PyObject *PostScriptDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 return SWIG_Python_InitShadowInstance(args);
23667 }
23668
23669 SWIGINTERN PyObject *_wrap_new_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj = 0;
23671 wxString const &arg1_defvalue = wxPyEmptyString ;
23672 wxString *arg1 = (wxString *) &arg1_defvalue ;
23673 wxMetaFile *result = 0 ;
23674 bool temp1 = false ;
23675 PyObject * obj0 = 0 ;
23676 char * kwnames[] = {
23677 (char *) "filename", NULL
23678 };
23679
23680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) SWIG_fail;
23681 if (obj0) {
23682 {
23683 arg1 = wxString_in_helper(obj0);
23684 if (arg1 == NULL) SWIG_fail;
23685 temp1 = true;
23686 }
23687 }
23688 {
23689 if (!wxPyCheckForApp()) SWIG_fail;
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, SWIG_POINTER_NEW | 0 );
23696 {
23697 if (temp1)
23698 delete arg1;
23699 }
23700 return resultobj;
23701 fail:
23702 {
23703 if (temp1)
23704 delete arg1;
23705 }
23706 return NULL;
23707 }
23708
23709
23710 SWIGINTERN PyObject *MetaFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23711 PyObject *obj;
23712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23713 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFile, SWIG_NewClientData(obj));
23714 return SWIG_Py_Void();
23715 }
23716
23717 SWIGINTERN PyObject *MetaFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23718 return SWIG_Python_InitShadowInstance(args);
23719 }
23720
23721 SWIGINTERN PyObject *_wrap_new_MetaFileDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23722 PyObject *resultobj = 0;
23723 wxString const &arg1_defvalue = wxPyEmptyString ;
23724 wxString *arg1 = (wxString *) &arg1_defvalue ;
23725 int arg2 = (int) 0 ;
23726 int arg3 = (int) 0 ;
23727 wxString const &arg4_defvalue = wxPyEmptyString ;
23728 wxString *arg4 = (wxString *) &arg4_defvalue ;
23729 wxMetaFileDC *result = 0 ;
23730 bool temp1 = false ;
23731 int val2 ;
23732 int ecode2 = 0 ;
23733 int val3 ;
23734 int ecode3 = 0 ;
23735 bool temp4 = false ;
23736 PyObject * obj0 = 0 ;
23737 PyObject * obj1 = 0 ;
23738 PyObject * obj2 = 0 ;
23739 PyObject * obj3 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23745 if (obj0) {
23746 {
23747 arg1 = wxString_in_helper(obj0);
23748 if (arg1 == NULL) SWIG_fail;
23749 temp1 = true;
23750 }
23751 }
23752 if (obj1) {
23753 ecode2 = SWIG_AsVal_int(obj1, &val2);
23754 if (!SWIG_IsOK(ecode2)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MetaFileDC" "', expected argument " "2"" of type '" "int""'");
23756 }
23757 arg2 = static_cast< int >(val2);
23758 }
23759 if (obj2) {
23760 ecode3 = SWIG_AsVal_int(obj2, &val3);
23761 if (!SWIG_IsOK(ecode3)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MetaFileDC" "', expected argument " "3"" of type '" "int""'");
23763 }
23764 arg3 = static_cast< int >(val3);
23765 }
23766 if (obj3) {
23767 {
23768 arg4 = wxString_in_helper(obj3);
23769 if (arg4 == NULL) SWIG_fail;
23770 temp4 = true;
23771 }
23772 }
23773 {
23774 if (!wxPyCheckForApp()) SWIG_fail;
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_NEW | 0 );
23781 {
23782 if (temp1)
23783 delete arg1;
23784 }
23785 {
23786 if (temp4)
23787 delete arg4;
23788 }
23789 return resultobj;
23790 fail:
23791 {
23792 if (temp1)
23793 delete arg1;
23794 }
23795 {
23796 if (temp4)
23797 delete arg4;
23798 }
23799 return NULL;
23800 }
23801
23802
23803 SWIGINTERN PyObject *MetaFileDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23804 PyObject *obj;
23805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23806 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFileDC, SWIG_NewClientData(obj));
23807 return SWIG_Py_Void();
23808 }
23809
23810 SWIGINTERN PyObject *MetaFileDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23811 return SWIG_Python_InitShadowInstance(args);
23812 }
23813
23814 SWIGINTERN PyObject *_wrap_new_PrinterDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23815 PyObject *resultobj = 0;
23816 wxPrintData *arg1 = 0 ;
23817 wxPrinterDC *result = 0 ;
23818 void *argp1 = 0 ;
23819 int res1 = 0 ;
23820 PyObject * obj0 = 0 ;
23821 char * kwnames[] = {
23822 (char *) "printData", NULL
23823 };
23824
23825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) SWIG_fail;
23826 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
23827 if (!SWIG_IsOK(res1)) {
23828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23829 }
23830 if (!argp1) {
23831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
23832 }
23833 arg1 = reinterpret_cast< wxPrintData * >(argp1);
23834 {
23835 if (!wxPyCheckForApp()) SWIG_fail;
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
23838 wxPyEndAllowThreads(__tstate);
23839 if (PyErr_Occurred()) SWIG_fail;
23840 }
23841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrinterDC, SWIG_POINTER_NEW | 0 );
23842 return resultobj;
23843 fail:
23844 return NULL;
23845 }
23846
23847
23848 SWIGINTERN PyObject *PrinterDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23849 PyObject *obj;
23850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23851 SWIG_TypeNewClientData(SWIGTYPE_p_wxPrinterDC, SWIG_NewClientData(obj));
23852 return SWIG_Py_Void();
23853 }
23854
23855 SWIGINTERN PyObject *PrinterDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 return SWIG_Python_InitShadowInstance(args);
23857 }
23858
23859 SWIGINTERN PyObject *_wrap_new_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj = 0;
23861 int arg1 ;
23862 int arg2 ;
23863 int arg3 = (int) true ;
23864 int arg4 = (int) 1 ;
23865 wxImageList *result = 0 ;
23866 int val1 ;
23867 int ecode1 = 0 ;
23868 int val2 ;
23869 int ecode2 = 0 ;
23870 int val3 ;
23871 int ecode3 = 0 ;
23872 int val4 ;
23873 int ecode4 = 0 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 PyObject * obj2 = 0 ;
23877 PyObject * obj3 = 0 ;
23878 char * kwnames[] = {
23879 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
23880 };
23881
23882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23883 ecode1 = SWIG_AsVal_int(obj0, &val1);
23884 if (!SWIG_IsOK(ecode1)) {
23885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageList" "', expected argument " "1"" of type '" "int""'");
23886 }
23887 arg1 = static_cast< int >(val1);
23888 ecode2 = SWIG_AsVal_int(obj1, &val2);
23889 if (!SWIG_IsOK(ecode2)) {
23890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageList" "', expected argument " "2"" of type '" "int""'");
23891 }
23892 arg2 = static_cast< int >(val2);
23893 if (obj2) {
23894 ecode3 = SWIG_AsVal_int(obj2, &val3);
23895 if (!SWIG_IsOK(ecode3)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageList" "', expected argument " "3"" of type '" "int""'");
23897 }
23898 arg3 = static_cast< int >(val3);
23899 }
23900 if (obj3) {
23901 ecode4 = SWIG_AsVal_int(obj3, &val4);
23902 if (!SWIG_IsOK(ecode4)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImageList" "', expected argument " "4"" of type '" "int""'");
23904 }
23905 arg4 = static_cast< int >(val4);
23906 }
23907 {
23908 if (!wxPyCheckForApp()) SWIG_fail;
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_delete_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxImageList *arg1 = (wxImageList *) 0 ;
23926 void *argp1 = 0 ;
23927 int res1 = 0 ;
23928 PyObject *swig_obj[1] ;
23929
23930 if (!args) SWIG_fail;
23931 swig_obj[0] = args;
23932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageList" "', expected argument " "1"" of type '" "wxImageList *""'");
23935 }
23936 arg1 = reinterpret_cast< wxImageList * >(argp1);
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 delete arg1;
23940
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_Py_Void();
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_ImageList_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = 0;
23953 wxImageList *arg1 = (wxImageList *) 0 ;
23954 wxBitmap *arg2 = 0 ;
23955 wxBitmap const &arg3_defvalue = wxNullBitmap ;
23956 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
23957 int result;
23958 void *argp1 = 0 ;
23959 int res1 = 0 ;
23960 void *argp2 = 0 ;
23961 int res2 = 0 ;
23962 void *argp3 = 0 ;
23963 int res3 = 0 ;
23964 PyObject * obj0 = 0 ;
23965 PyObject * obj1 = 0 ;
23966 PyObject * obj2 = 0 ;
23967 char * kwnames[] = {
23968 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
23969 };
23970
23971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Add" "', expected argument " "1"" of type '" "wxImageList *""'");
23975 }
23976 arg1 = reinterpret_cast< wxImageList * >(argp1);
23977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23978 if (!SWIG_IsOK(res2)) {
23979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23980 }
23981 if (!argp2) {
23982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23983 }
23984 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23985 if (obj2) {
23986 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
23987 if (!SWIG_IsOK(res3)) {
23988 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
23989 }
23990 if (!argp3) {
23991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
23992 }
23993 arg3 = reinterpret_cast< wxBitmap * >(argp3);
23994 }
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 resultobj = SWIG_From_int(static_cast< int >(result));
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 SWIGINTERN PyObject *_wrap_ImageList_AddWithColourMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24009 PyObject *resultobj = 0;
24010 wxImageList *arg1 = (wxImageList *) 0 ;
24011 wxBitmap *arg2 = 0 ;
24012 wxColour *arg3 = 0 ;
24013 int result;
24014 void *argp1 = 0 ;
24015 int res1 = 0 ;
24016 void *argp2 = 0 ;
24017 int res2 = 0 ;
24018 wxColour temp3 ;
24019 PyObject * obj0 = 0 ;
24020 PyObject * obj1 = 0 ;
24021 PyObject * obj2 = 0 ;
24022 char * kwnames[] = {
24023 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
24024 };
24025
24026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24028 if (!SWIG_IsOK(res1)) {
24029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddWithColourMask" "', expected argument " "1"" of type '" "wxImageList *""'");
24030 }
24031 arg1 = reinterpret_cast< wxImageList * >(argp1);
24032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
24033 if (!SWIG_IsOK(res2)) {
24034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24035 }
24036 if (!argp2) {
24037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24038 }
24039 arg2 = reinterpret_cast< wxBitmap * >(argp2);
24040 {
24041 arg3 = &temp3;
24042 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
24043 }
24044 {
24045 PyThreadState* __tstate = wxPyBeginAllowThreads();
24046 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
24047 wxPyEndAllowThreads(__tstate);
24048 if (PyErr_Occurred()) SWIG_fail;
24049 }
24050 resultobj = SWIG_From_int(static_cast< int >(result));
24051 return resultobj;
24052 fail:
24053 return NULL;
24054 }
24055
24056
24057 SWIGINTERN PyObject *_wrap_ImageList_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj = 0;
24059 wxImageList *arg1 = (wxImageList *) 0 ;
24060 wxIcon *arg2 = 0 ;
24061 int result;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 void *argp2 = 0 ;
24065 int res2 = 0 ;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 char * kwnames[] = {
24069 (char *) "self",(char *) "icon", NULL
24070 };
24071
24072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
24073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddIcon" "', expected argument " "1"" of type '" "wxImageList *""'");
24076 }
24077 arg1 = reinterpret_cast< wxImageList * >(argp1);
24078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
24079 if (!SWIG_IsOK(res2)) {
24080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
24081 }
24082 if (!argp2) {
24083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
24084 }
24085 arg2 = reinterpret_cast< wxIcon * >(argp2);
24086 {
24087 PyThreadState* __tstate = wxPyBeginAllowThreads();
24088 result = (int)(arg1)->Add((wxIcon const &)*arg2);
24089 wxPyEndAllowThreads(__tstate);
24090 if (PyErr_Occurred()) SWIG_fail;
24091 }
24092 resultobj = SWIG_From_int(static_cast< int >(result));
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *_wrap_ImageList_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24100 PyObject *resultobj = 0;
24101 wxImageList *arg1 = (wxImageList *) 0 ;
24102 int arg2 ;
24103 SwigValueWrapper<wxBitmap > result;
24104 void *argp1 = 0 ;
24105 int res1 = 0 ;
24106 int val2 ;
24107 int ecode2 = 0 ;
24108 PyObject * obj0 = 0 ;
24109 PyObject * obj1 = 0 ;
24110 char * kwnames[] = {
24111 (char *) "self",(char *) "index", NULL
24112 };
24113
24114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
24115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24116 if (!SWIG_IsOK(res1)) {
24117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetBitmap" "', expected argument " "1"" of type '" "wxImageList const *""'");
24118 }
24119 arg1 = reinterpret_cast< wxImageList * >(argp1);
24120 ecode2 = SWIG_AsVal_int(obj1, &val2);
24121 if (!SWIG_IsOK(ecode2)) {
24122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetBitmap" "', expected argument " "2"" of type '" "int""'");
24123 }
24124 arg2 = static_cast< int >(val2);
24125 {
24126 PyThreadState* __tstate = wxPyBeginAllowThreads();
24127 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 SWIGINTERN PyObject *_wrap_ImageList_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj = 0;
24140 wxImageList *arg1 = (wxImageList *) 0 ;
24141 int arg2 ;
24142 wxIcon result;
24143 void *argp1 = 0 ;
24144 int res1 = 0 ;
24145 int val2 ;
24146 int ecode2 = 0 ;
24147 PyObject * obj0 = 0 ;
24148 PyObject * obj1 = 0 ;
24149 char * kwnames[] = {
24150 (char *) "self",(char *) "index", NULL
24151 };
24152
24153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
24154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetIcon" "', expected argument " "1"" of type '" "wxImageList const *""'");
24157 }
24158 arg1 = reinterpret_cast< wxImageList * >(argp1);
24159 ecode2 = SWIG_AsVal_int(obj1, &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetIcon" "', expected argument " "2"" of type '" "int""'");
24162 }
24163 arg2 = static_cast< int >(val2);
24164 {
24165 PyThreadState* __tstate = wxPyBeginAllowThreads();
24166 result = ((wxImageList const *)arg1)->GetIcon(arg2);
24167 wxPyEndAllowThreads(__tstate);
24168 if (PyErr_Occurred()) SWIG_fail;
24169 }
24170 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
24171 return resultobj;
24172 fail:
24173 return NULL;
24174 }
24175
24176
24177 SWIGINTERN PyObject *_wrap_ImageList_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24178 PyObject *resultobj = 0;
24179 wxImageList *arg1 = (wxImageList *) 0 ;
24180 int arg2 ;
24181 wxBitmap *arg3 = 0 ;
24182 wxBitmap const &arg4_defvalue = wxNullBitmap ;
24183 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
24184 bool result;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 int val2 ;
24188 int ecode2 = 0 ;
24189 void *argp3 = 0 ;
24190 int res3 = 0 ;
24191 void *argp4 = 0 ;
24192 int res4 = 0 ;
24193 PyObject * obj0 = 0 ;
24194 PyObject * obj1 = 0 ;
24195 PyObject * obj2 = 0 ;
24196 PyObject * obj3 = 0 ;
24197 char * kwnames[] = {
24198 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
24199 };
24200
24201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24203 if (!SWIG_IsOK(res1)) {
24204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Replace" "', expected argument " "1"" of type '" "wxImageList *""'");
24205 }
24206 arg1 = reinterpret_cast< wxImageList * >(argp1);
24207 ecode2 = SWIG_AsVal_int(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Replace" "', expected argument " "2"" of type '" "int""'");
24210 }
24211 arg2 = static_cast< int >(val2);
24212 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
24213 if (!SWIG_IsOK(res3)) {
24214 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24215 }
24216 if (!argp3) {
24217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24218 }
24219 arg3 = reinterpret_cast< wxBitmap * >(argp3);
24220 if (obj3) {
24221 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 | 0);
24222 if (!SWIG_IsOK(res4)) {
24223 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
24224 }
24225 if (!argp4) {
24226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
24227 }
24228 arg4 = reinterpret_cast< wxBitmap * >(argp4);
24229 }
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 {
24237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24238 }
24239 return resultobj;
24240 fail:
24241 return NULL;
24242 }
24243
24244
24245 SWIGINTERN PyObject *_wrap_ImageList_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24246 PyObject *resultobj = 0;
24247 wxImageList *arg1 = (wxImageList *) 0 ;
24248 int arg2 ;
24249 wxDC *arg3 = 0 ;
24250 int arg4 ;
24251 int arg5 ;
24252 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
24253 bool arg7 = (bool) (bool)false ;
24254 bool result;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 int val2 ;
24258 int ecode2 = 0 ;
24259 void *argp3 = 0 ;
24260 int res3 = 0 ;
24261 int val4 ;
24262 int ecode4 = 0 ;
24263 int val5 ;
24264 int ecode5 = 0 ;
24265 int val6 ;
24266 int ecode6 = 0 ;
24267 bool val7 ;
24268 int ecode7 = 0 ;
24269 PyObject * obj0 = 0 ;
24270 PyObject * obj1 = 0 ;
24271 PyObject * obj2 = 0 ;
24272 PyObject * obj3 = 0 ;
24273 PyObject * obj4 = 0 ;
24274 PyObject * obj5 = 0 ;
24275 PyObject * obj6 = 0 ;
24276 char * kwnames[] = {
24277 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
24278 };
24279
24280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Draw" "', expected argument " "1"" of type '" "wxImageList *""'");
24284 }
24285 arg1 = reinterpret_cast< wxImageList * >(argp1);
24286 ecode2 = SWIG_AsVal_int(obj1, &val2);
24287 if (!SWIG_IsOK(ecode2)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Draw" "', expected argument " "2"" of type '" "int""'");
24289 }
24290 arg2 = static_cast< int >(val2);
24291 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
24292 if (!SWIG_IsOK(res3)) {
24293 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
24294 }
24295 if (!argp3) {
24296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
24297 }
24298 arg3 = reinterpret_cast< wxDC * >(argp3);
24299 ecode4 = SWIG_AsVal_int(obj3, &val4);
24300 if (!SWIG_IsOK(ecode4)) {
24301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageList_Draw" "', expected argument " "4"" of type '" "int""'");
24302 }
24303 arg4 = static_cast< int >(val4);
24304 ecode5 = SWIG_AsVal_int(obj4, &val5);
24305 if (!SWIG_IsOK(ecode5)) {
24306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageList_Draw" "', expected argument " "5"" of type '" "int""'");
24307 }
24308 arg5 = static_cast< int >(val5);
24309 if (obj5) {
24310 ecode6 = SWIG_AsVal_int(obj5, &val6);
24311 if (!SWIG_IsOK(ecode6)) {
24312 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageList_Draw" "', expected argument " "6"" of type '" "int""'");
24313 }
24314 arg6 = static_cast< int >(val6);
24315 }
24316 if (obj6) {
24317 ecode7 = SWIG_AsVal_bool(obj6, &val7);
24318 if (!SWIG_IsOK(ecode7)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageList_Draw" "', expected argument " "7"" of type '" "bool""'");
24320 }
24321 arg7 = static_cast< bool >(val7);
24322 }
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 {
24330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24331 }
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_ImageList_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *resultobj = 0;
24340 wxImageList *arg1 = (wxImageList *) 0 ;
24341 int result;
24342 void *argp1 = 0 ;
24343 int res1 = 0 ;
24344 PyObject *swig_obj[1] ;
24345
24346 if (!args) SWIG_fail;
24347 swig_obj[0] = args;
24348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetImageCount" "', expected argument " "1"" of type '" "wxImageList *""'");
24351 }
24352 arg1 = reinterpret_cast< wxImageList * >(argp1);
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (int)(arg1)->GetImageCount();
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 resultobj = SWIG_From_int(static_cast< int >(result));
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 SWIGINTERN PyObject *_wrap_ImageList_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24367 PyObject *resultobj = 0;
24368 wxImageList *arg1 = (wxImageList *) 0 ;
24369 int arg2 ;
24370 bool result;
24371 void *argp1 = 0 ;
24372 int res1 = 0 ;
24373 int val2 ;
24374 int ecode2 = 0 ;
24375 PyObject * obj0 = 0 ;
24376 PyObject * obj1 = 0 ;
24377 char * kwnames[] = {
24378 (char *) "self",(char *) "index", NULL
24379 };
24380
24381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
24382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24383 if (!SWIG_IsOK(res1)) {
24384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Remove" "', expected argument " "1"" of type '" "wxImageList *""'");
24385 }
24386 arg1 = reinterpret_cast< wxImageList * >(argp1);
24387 ecode2 = SWIG_AsVal_int(obj1, &val2);
24388 if (!SWIG_IsOK(ecode2)) {
24389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Remove" "', expected argument " "2"" of type '" "int""'");
24390 }
24391 arg2 = static_cast< int >(val2);
24392 {
24393 PyThreadState* __tstate = wxPyBeginAllowThreads();
24394 result = (bool)(arg1)->Remove(arg2);
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 {
24399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24400 }
24401 return resultobj;
24402 fail:
24403 return NULL;
24404 }
24405
24406
24407 SWIGINTERN PyObject *_wrap_ImageList_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24408 PyObject *resultobj = 0;
24409 wxImageList *arg1 = (wxImageList *) 0 ;
24410 bool result;
24411 void *argp1 = 0 ;
24412 int res1 = 0 ;
24413 PyObject *swig_obj[1] ;
24414
24415 if (!args) SWIG_fail;
24416 swig_obj[0] = args;
24417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24418 if (!SWIG_IsOK(res1)) {
24419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_RemoveAll" "', expected argument " "1"" of type '" "wxImageList *""'");
24420 }
24421 arg1 = reinterpret_cast< wxImageList * >(argp1);
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 result = (bool)(arg1)->RemoveAll();
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 {
24429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24430 }
24431 return resultobj;
24432 fail:
24433 return NULL;
24434 }
24435
24436
24437 SWIGINTERN PyObject *_wrap_ImageList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24438 PyObject *resultobj = 0;
24439 wxImageList *arg1 = (wxImageList *) 0 ;
24440 int arg2 ;
24441 int *arg3 = 0 ;
24442 int *arg4 = 0 ;
24443 void *argp1 = 0 ;
24444 int res1 = 0 ;
24445 int val2 ;
24446 int ecode2 = 0 ;
24447 int temp3 ;
24448 int res3 = SWIG_TMPOBJ ;
24449 int temp4 ;
24450 int res4 = SWIG_TMPOBJ ;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "self",(char *) "index", NULL
24455 };
24456
24457 arg3 = &temp3;
24458 arg4 = &temp4;
24459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
24460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24461 if (!SWIG_IsOK(res1)) {
24462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetSize" "', expected argument " "1"" of type '" "wxImageList *""'");
24463 }
24464 arg1 = reinterpret_cast< wxImageList * >(argp1);
24465 ecode2 = SWIG_AsVal_int(obj1, &val2);
24466 if (!SWIG_IsOK(ecode2)) {
24467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetSize" "', expected argument " "2"" of type '" "int""'");
24468 }
24469 arg2 = static_cast< int >(val2);
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 (arg1)->GetSize(arg2,*arg3,*arg4);
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 resultobj = SWIG_Py_Void();
24477 if (SWIG_IsTmpObj(res3)) {
24478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
24479 } else {
24480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
24482 }
24483 if (SWIG_IsTmpObj(res4)) {
24484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
24485 } else {
24486 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
24488 }
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 SWIGINTERN PyObject *ImageList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24496 PyObject *obj;
24497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24498 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageList, SWIG_NewClientData(obj));
24499 return SWIG_Py_Void();
24500 }
24501
24502 SWIGINTERN PyObject *ImageList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24503 return SWIG_Python_InitShadowInstance(args);
24504 }
24505
24506 SWIGINTERN PyObject *_wrap_new_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24507 PyObject *resultobj = 0;
24508 wxStockGDI *result = 0 ;
24509
24510 if (!SWIG_Python_UnpackTuple(args,"new_StockGDI",0,0,0)) SWIG_fail;
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 result = (wxStockGDI *)new wxStockGDI();
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, SWIG_POINTER_NEW | 0 );
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_delete_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 PyObject *swig_obj[1] ;
24530
24531 if (!args) SWIG_fail;
24532 swig_obj[0] = args;
24533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStockGDI, SWIG_POINTER_DISOWN | 0 );
24534 if (!SWIG_IsOK(res1)) {
24535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StockGDI" "', expected argument " "1"" of type '" "wxStockGDI *""'");
24536 }
24537 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 delete arg1;
24541
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 resultobj = SWIG_Py_Void();
24546 return resultobj;
24547 fail:
24548 return NULL;
24549 }
24550
24551
24552 SWIGINTERN PyObject *_wrap_StockGDI_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24553 PyObject *resultobj = 0;
24554
24555 if (!SWIG_Python_UnpackTuple(args,"StockGDI_DeleteAll",0,0,0)) SWIG_fail;
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 wxStockGDI::DeleteAll();
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_Py_Void();
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 SWIGINTERN PyObject *_wrap_StockGDI_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24570 PyObject *resultobj = 0;
24571 wxStockGDI *result = 0 ;
24572
24573 if (!SWIG_Python_UnpackTuple(args,"StockGDI_instance",0,0,0)) SWIG_fail;
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 {
24577 wxStockGDI &_result_ref = wxStockGDI::instance();
24578 result = (wxStockGDI *) &_result_ref;
24579 }
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, 0 | 0 );
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *_wrap_StockGDI_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24591 PyObject *resultobj = 0;
24592 wxStockGDI::Item arg1 ;
24593 wxBrush *result = 0 ;
24594 int val1 ;
24595 int ecode1 = 0 ;
24596 PyObject * obj0 = 0 ;
24597 char * kwnames[] = {
24598 (char *) "item", NULL
24599 };
24600
24601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetBrush",kwnames,&obj0)) SWIG_fail;
24602 ecode1 = SWIG_AsVal_int(obj0, &val1);
24603 if (!SWIG_IsOK(ecode1)) {
24604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetBrush" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24605 }
24606 arg1 = static_cast< wxStockGDI::Item >(val1);
24607 {
24608 PyThreadState* __tstate = wxPyBeginAllowThreads();
24609 result = (wxBrush *)wxStockGDI::GetBrush(arg1);
24610 wxPyEndAllowThreads(__tstate);
24611 if (PyErr_Occurred()) SWIG_fail;
24612 }
24613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
24614 return resultobj;
24615 fail:
24616 return NULL;
24617 }
24618
24619
24620 SWIGINTERN PyObject *_wrap_StockGDI_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24621 PyObject *resultobj = 0;
24622 wxStockGDI::Item arg1 ;
24623 wxColour *result = 0 ;
24624 int val1 ;
24625 int ecode1 = 0 ;
24626 PyObject * obj0 = 0 ;
24627 char * kwnames[] = {
24628 (char *) "item", NULL
24629 };
24630
24631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetColour",kwnames,&obj0)) SWIG_fail;
24632 ecode1 = SWIG_AsVal_int(obj0, &val1);
24633 if (!SWIG_IsOK(ecode1)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetColour" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24635 }
24636 arg1 = static_cast< wxStockGDI::Item >(val1);
24637 {
24638 PyThreadState* __tstate = wxPyBeginAllowThreads();
24639 result = (wxColour *)wxStockGDI::GetColour(arg1);
24640 wxPyEndAllowThreads(__tstate);
24641 if (PyErr_Occurred()) SWIG_fail;
24642 }
24643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_StockGDI_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj = 0;
24652 wxStockGDI::Item arg1 ;
24653 wxCursor *result = 0 ;
24654 int val1 ;
24655 int ecode1 = 0 ;
24656 PyObject * obj0 = 0 ;
24657 char * kwnames[] = {
24658 (char *) "item", NULL
24659 };
24660
24661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetCursor",kwnames,&obj0)) SWIG_fail;
24662 ecode1 = SWIG_AsVal_int(obj0, &val1);
24663 if (!SWIG_IsOK(ecode1)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetCursor" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24665 }
24666 arg1 = static_cast< wxStockGDI::Item >(val1);
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (wxCursor *)wxStockGDI::GetCursor(arg1);
24670 wxPyEndAllowThreads(__tstate);
24671 if (PyErr_Occurred()) SWIG_fail;
24672 }
24673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, 0 | 0 );
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_StockGDI_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24681 PyObject *resultobj = 0;
24682 wxStockGDI::Item arg1 ;
24683 wxPen *result = 0 ;
24684 int val1 ;
24685 int ecode1 = 0 ;
24686 PyObject * obj0 = 0 ;
24687 char * kwnames[] = {
24688 (char *) "item", NULL
24689 };
24690
24691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetPen",kwnames,&obj0)) SWIG_fail;
24692 ecode1 = SWIG_AsVal_int(obj0, &val1);
24693 if (!SWIG_IsOK(ecode1)) {
24694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetPen" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
24695 }
24696 arg1 = static_cast< wxStockGDI::Item >(val1);
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 result = (wxPen *)wxStockGDI::GetPen(arg1);
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_StockGDI_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24711 PyObject *resultobj = 0;
24712 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
24713 wxStockGDI::Item arg2 ;
24714 wxFont *result = 0 ;
24715 void *argp1 = 0 ;
24716 int res1 = 0 ;
24717 int val2 ;
24718 int ecode2 = 0 ;
24719 PyObject * obj0 = 0 ;
24720 PyObject * obj1 = 0 ;
24721 char * kwnames[] = {
24722 (char *) "self",(char *) "item", NULL
24723 };
24724
24725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StockGDI_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
24726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStockGDI, 0 | 0 );
24727 if (!SWIG_IsOK(res1)) {
24728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StockGDI_GetFont" "', expected argument " "1"" of type '" "wxStockGDI *""'");
24729 }
24730 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
24731 ecode2 = SWIG_AsVal_int(obj1, &val2);
24732 if (!SWIG_IsOK(ecode2)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StockGDI_GetFont" "', expected argument " "2"" of type '" "wxStockGDI::Item""'");
24734 }
24735 arg2 = static_cast< wxStockGDI::Item >(val2);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (wxFont *)(arg1)->GetFont(arg2);
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
24743 return resultobj;
24744 fail:
24745 return NULL;
24746 }
24747
24748
24749 SWIGINTERN PyObject *StockGDI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24750 PyObject *obj;
24751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24752 SWIG_TypeNewClientData(SWIGTYPE_p_wxStockGDI, SWIG_NewClientData(obj));
24753 return SWIG_Py_Void();
24754 }
24755
24756 SWIGINTERN PyObject *StockGDI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 return SWIG_Python_InitShadowInstance(args);
24758 }
24759
24760 SWIGINTERN int NullBitmap_set(PyObject *) {
24761 SWIG_Error(SWIG_AttributeError,"Variable NullBitmap is read-only.");
24762 return 1;
24763 }
24764
24765
24766 SWIGINTERN PyObject *NullBitmap_get(void) {
24767 PyObject *pyobj = 0;
24768
24769 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0 );
24770 return pyobj;
24771 }
24772
24773
24774 SWIGINTERN int NullIcon_set(PyObject *) {
24775 SWIG_Error(SWIG_AttributeError,"Variable NullIcon is read-only.");
24776 return 1;
24777 }
24778
24779
24780 SWIGINTERN PyObject *NullIcon_get(void) {
24781 PyObject *pyobj = 0;
24782
24783 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullIcon), SWIGTYPE_p_wxIcon, 0 );
24784 return pyobj;
24785 }
24786
24787
24788 SWIGINTERN int NullCursor_set(PyObject *) {
24789 SWIG_Error(SWIG_AttributeError,"Variable NullCursor is read-only.");
24790 return 1;
24791 }
24792
24793
24794 SWIGINTERN PyObject *NullCursor_get(void) {
24795 PyObject *pyobj = 0;
24796
24797 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullCursor), SWIGTYPE_p_wxCursor, 0 );
24798 return pyobj;
24799 }
24800
24801
24802 SWIGINTERN int NullPen_set(PyObject *) {
24803 SWIG_Error(SWIG_AttributeError,"Variable NullPen is read-only.");
24804 return 1;
24805 }
24806
24807
24808 SWIGINTERN PyObject *NullPen_get(void) {
24809 PyObject *pyobj = 0;
24810
24811 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPen), SWIGTYPE_p_wxPen, 0 );
24812 return pyobj;
24813 }
24814
24815
24816 SWIGINTERN int NullBrush_set(PyObject *) {
24817 SWIG_Error(SWIG_AttributeError,"Variable NullBrush is read-only.");
24818 return 1;
24819 }
24820
24821
24822 SWIGINTERN PyObject *NullBrush_get(void) {
24823 PyObject *pyobj = 0;
24824
24825 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBrush), SWIGTYPE_p_wxBrush, 0 );
24826 return pyobj;
24827 }
24828
24829
24830 SWIGINTERN int NullPalette_set(PyObject *) {
24831 SWIG_Error(SWIG_AttributeError,"Variable NullPalette is read-only.");
24832 return 1;
24833 }
24834
24835
24836 SWIGINTERN PyObject *NullPalette_get(void) {
24837 PyObject *pyobj = 0;
24838
24839 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPalette), SWIGTYPE_p_wxPalette, 0 );
24840 return pyobj;
24841 }
24842
24843
24844 SWIGINTERN int NullFont_set(PyObject *) {
24845 SWIG_Error(SWIG_AttributeError,"Variable NullFont is read-only.");
24846 return 1;
24847 }
24848
24849
24850 SWIGINTERN PyObject *NullFont_get(void) {
24851 PyObject *pyobj = 0;
24852
24853 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullFont), SWIGTYPE_p_wxFont, 0 );
24854 return pyobj;
24855 }
24856
24857
24858 SWIGINTERN int NullColour_set(PyObject *) {
24859 SWIG_Error(SWIG_AttributeError,"Variable NullColour is read-only.");
24860 return 1;
24861 }
24862
24863
24864 SWIGINTERN PyObject *NullColour_get(void) {
24865 PyObject *pyobj = 0;
24866
24867 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullColour), SWIGTYPE_p_wxColour, 0 );
24868 return pyobj;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_new_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxGDIObjListBase *result = 0 ;
24875
24876 if (!SWIG_Python_UnpackTuple(args,"new_GDIObjListBase",0,0,0)) SWIG_fail;
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (wxGDIObjListBase *)new wxGDIObjListBase();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_NEW | 0 );
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_delete_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxGDIObjListBase *arg1 = (wxGDIObjListBase *) 0 ;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_DISOWN | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObjListBase" "', expected argument " "1"" of type '" "wxGDIObjListBase *""'");
24902 }
24903 arg1 = reinterpret_cast< wxGDIObjListBase * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 delete arg1;
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 resultobj = SWIG_Py_Void();
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *GDIObjListBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *obj;
24920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24921 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObjListBase, SWIG_NewClientData(obj));
24922 return SWIG_Py_Void();
24923 }
24924
24925 SWIGINTERN PyObject *GDIObjListBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 return SWIG_Python_InitShadowInstance(args);
24927 }
24928
24929 SWIGINTERN PyObject *_wrap_PenList_FindOrCreatePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxPenList *arg1 = (wxPenList *) 0 ;
24932 wxColour *arg2 = 0 ;
24933 int arg3 ;
24934 int arg4 ;
24935 wxPen *result = 0 ;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 wxColour temp2 ;
24939 int val3 ;
24940 int ecode3 = 0 ;
24941 int val4 ;
24942 int ecode4 = 0 ;
24943 PyObject * obj0 = 0 ;
24944 PyObject * obj1 = 0 ;
24945 PyObject * obj2 = 0 ;
24946 PyObject * obj3 = 0 ;
24947 char * kwnames[] = {
24948 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
24949 };
24950
24951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
24953 if (!SWIG_IsOK(res1)) {
24954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_FindOrCreatePen" "', expected argument " "1"" of type '" "wxPenList *""'");
24955 }
24956 arg1 = reinterpret_cast< wxPenList * >(argp1);
24957 {
24958 arg2 = &temp2;
24959 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
24960 }
24961 ecode3 = SWIG_AsVal_int(obj2, &val3);
24962 if (!SWIG_IsOK(ecode3)) {
24963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PenList_FindOrCreatePen" "', expected argument " "3"" of type '" "int""'");
24964 }
24965 arg3 = static_cast< int >(val3);
24966 ecode4 = SWIG_AsVal_int(obj3, &val4);
24967 if (!SWIG_IsOK(ecode4)) {
24968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PenList_FindOrCreatePen" "', expected argument " "4"" of type '" "int""'");
24969 }
24970 arg4 = static_cast< int >(val4);
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
24974 wxPyEndAllowThreads(__tstate);
24975 if (PyErr_Occurred()) SWIG_fail;
24976 }
24977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_PenList_AddPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj = 0;
24986 wxPenList *arg1 = (wxPenList *) 0 ;
24987 wxPen *arg2 = (wxPen *) 0 ;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 void *argp2 = 0 ;
24991 int res2 = 0 ;
24992 PyObject * obj0 = 0 ;
24993 PyObject * obj1 = 0 ;
24994 char * kwnames[] = {
24995 (char *) "self",(char *) "pen", NULL
24996 };
24997
24998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) SWIG_fail;
24999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_AddPen" "', expected argument " "1"" of type '" "wxPenList *""'");
25002 }
25003 arg1 = reinterpret_cast< wxPenList * >(argp1);
25004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25005 if (!SWIG_IsOK(res2)) {
25006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_AddPen" "', expected argument " "2"" of type '" "wxPen *""'");
25007 }
25008 arg2 = reinterpret_cast< wxPen * >(argp2);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 (arg1)->AddPen(arg2);
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 resultobj = SWIG_Py_Void();
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_PenList_RemovePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxPenList *arg1 = (wxPenList *) 0 ;
25025 wxPen *arg2 = (wxPen *) 0 ;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 void *argp2 = 0 ;
25029 int res2 = 0 ;
25030 PyObject * obj0 = 0 ;
25031 PyObject * obj1 = 0 ;
25032 char * kwnames[] = {
25033 (char *) "self",(char *) "pen", NULL
25034 };
25035
25036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_RemovePen" "', expected argument " "1"" of type '" "wxPenList *""'");
25040 }
25041 arg1 = reinterpret_cast< wxPenList * >(argp1);
25042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25043 if (!SWIG_IsOK(res2)) {
25044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_RemovePen" "', expected argument " "2"" of type '" "wxPen *""'");
25045 }
25046 arg2 = reinterpret_cast< wxPen * >(argp2);
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 (arg1)->RemovePen(arg2);
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 resultobj = SWIG_Py_Void();
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 SWIGINTERN PyObject *PenList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25061 PyObject *obj;
25062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPenList, SWIG_NewClientData(obj));
25064 return SWIG_Py_Void();
25065 }
25066
25067 SWIGINTERN PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25068 PyObject *resultobj = 0;
25069 wxBrushList *arg1 = (wxBrushList *) 0 ;
25070 wxColour *arg2 = 0 ;
25071 int arg3 = (int) wxSOLID ;
25072 wxBrush *result = 0 ;
25073 void *argp1 = 0 ;
25074 int res1 = 0 ;
25075 wxColour temp2 ;
25076 int val3 ;
25077 int ecode3 = 0 ;
25078 PyObject * obj0 = 0 ;
25079 PyObject * obj1 = 0 ;
25080 PyObject * obj2 = 0 ;
25081 char * kwnames[] = {
25082 (char *) "self",(char *) "colour",(char *) "style", NULL
25083 };
25084
25085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25087 if (!SWIG_IsOK(res1)) {
25088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25089 }
25090 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25091 {
25092 arg2 = &temp2;
25093 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25094 }
25095 if (obj2) {
25096 ecode3 = SWIG_AsVal_int(obj2, &val3);
25097 if (!SWIG_IsOK(ecode3)) {
25098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "3"" of type '" "int""'");
25099 }
25100 arg3 = static_cast< int >(val3);
25101 }
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_BrushList_AddBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxBrushList *arg1 = (wxBrushList *) 0 ;
25118 wxBrush *arg2 = (wxBrush *) 0 ;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 void *argp2 = 0 ;
25122 int res2 = 0 ;
25123 PyObject * obj0 = 0 ;
25124 PyObject * obj1 = 0 ;
25125 char * kwnames[] = {
25126 (char *) "self",(char *) "brush", NULL
25127 };
25128
25129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) SWIG_fail;
25130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25131 if (!SWIG_IsOK(res1)) {
25132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_AddBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25133 }
25134 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
25136 if (!SWIG_IsOK(res2)) {
25137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_AddBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
25138 }
25139 arg2 = reinterpret_cast< wxBrush * >(argp2);
25140 {
25141 PyThreadState* __tstate = wxPyBeginAllowThreads();
25142 (arg1)->AddBrush(arg2);
25143 wxPyEndAllowThreads(__tstate);
25144 if (PyErr_Occurred()) SWIG_fail;
25145 }
25146 resultobj = SWIG_Py_Void();
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 SWIGINTERN PyObject *_wrap_BrushList_RemoveBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj = 0;
25155 wxBrushList *arg1 = (wxBrushList *) 0 ;
25156 wxBrush *arg2 = (wxBrush *) 0 ;
25157 void *argp1 = 0 ;
25158 int res1 = 0 ;
25159 void *argp2 = 0 ;
25160 int res2 = 0 ;
25161 PyObject * obj0 = 0 ;
25162 PyObject * obj1 = 0 ;
25163 char * kwnames[] = {
25164 (char *) "self",(char *) "brush", NULL
25165 };
25166
25167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) SWIG_fail;
25168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
25169 if (!SWIG_IsOK(res1)) {
25170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_RemoveBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
25171 }
25172 arg1 = reinterpret_cast< wxBrushList * >(argp1);
25173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
25174 if (!SWIG_IsOK(res2)) {
25175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_RemoveBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
25176 }
25177 arg2 = reinterpret_cast< wxBrush * >(argp2);
25178 {
25179 PyThreadState* __tstate = wxPyBeginAllowThreads();
25180 (arg1)->RemoveBrush(arg2);
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 resultobj = SWIG_Py_Void();
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 SWIGINTERN PyObject *BrushList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25192 PyObject *obj;
25193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25194 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrushList, SWIG_NewClientData(obj));
25195 return SWIG_Py_Void();
25196 }
25197
25198 SWIGINTERN PyObject *_wrap_FontList_FindOrCreateFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = 0;
25200 wxFontList *arg1 = (wxFontList *) 0 ;
25201 int arg2 ;
25202 int arg3 ;
25203 int arg4 ;
25204 int arg5 ;
25205 bool arg6 = (bool) false ;
25206 wxString const &arg7_defvalue = wxPyEmptyString ;
25207 wxString *arg7 = (wxString *) &arg7_defvalue ;
25208 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
25209 wxFont *result = 0 ;
25210 void *argp1 = 0 ;
25211 int res1 = 0 ;
25212 int val2 ;
25213 int ecode2 = 0 ;
25214 int val3 ;
25215 int ecode3 = 0 ;
25216 int val4 ;
25217 int ecode4 = 0 ;
25218 int val5 ;
25219 int ecode5 = 0 ;
25220 bool val6 ;
25221 int ecode6 = 0 ;
25222 bool temp7 = false ;
25223 int val8 ;
25224 int ecode8 = 0 ;
25225 PyObject * obj0 = 0 ;
25226 PyObject * obj1 = 0 ;
25227 PyObject * obj2 = 0 ;
25228 PyObject * obj3 = 0 ;
25229 PyObject * obj4 = 0 ;
25230 PyObject * obj5 = 0 ;
25231 PyObject * obj6 = 0 ;
25232 PyObject * obj7 = 0 ;
25233 char * kwnames[] = {
25234 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
25235 };
25236
25237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
25238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25239 if (!SWIG_IsOK(res1)) {
25240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_FindOrCreateFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25241 }
25242 arg1 = reinterpret_cast< wxFontList * >(argp1);
25243 ecode2 = SWIG_AsVal_int(obj1, &val2);
25244 if (!SWIG_IsOK(ecode2)) {
25245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontList_FindOrCreateFont" "', expected argument " "2"" of type '" "int""'");
25246 }
25247 arg2 = static_cast< int >(val2);
25248 ecode3 = SWIG_AsVal_int(obj2, &val3);
25249 if (!SWIG_IsOK(ecode3)) {
25250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontList_FindOrCreateFont" "', expected argument " "3"" of type '" "int""'");
25251 }
25252 arg3 = static_cast< int >(val3);
25253 ecode4 = SWIG_AsVal_int(obj3, &val4);
25254 if (!SWIG_IsOK(ecode4)) {
25255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontList_FindOrCreateFont" "', expected argument " "4"" of type '" "int""'");
25256 }
25257 arg4 = static_cast< int >(val4);
25258 ecode5 = SWIG_AsVal_int(obj4, &val5);
25259 if (!SWIG_IsOK(ecode5)) {
25260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FontList_FindOrCreateFont" "', expected argument " "5"" of type '" "int""'");
25261 }
25262 arg5 = static_cast< int >(val5);
25263 if (obj5) {
25264 ecode6 = SWIG_AsVal_bool(obj5, &val6);
25265 if (!SWIG_IsOK(ecode6)) {
25266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FontList_FindOrCreateFont" "', expected argument " "6"" of type '" "bool""'");
25267 }
25268 arg6 = static_cast< bool >(val6);
25269 }
25270 if (obj6) {
25271 {
25272 arg7 = wxString_in_helper(obj6);
25273 if (arg7 == NULL) SWIG_fail;
25274 temp7 = true;
25275 }
25276 }
25277 if (obj7) {
25278 ecode8 = SWIG_AsVal_int(obj7, &val8);
25279 if (!SWIG_IsOK(ecode8)) {
25280 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FontList_FindOrCreateFont" "', expected argument " "8"" of type '" "wxFontEncoding""'");
25281 }
25282 arg8 = static_cast< wxFontEncoding >(val8);
25283 }
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,arg8);
25287 wxPyEndAllowThreads(__tstate);
25288 if (PyErr_Occurred()) SWIG_fail;
25289 }
25290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
25291 {
25292 if (temp7)
25293 delete arg7;
25294 }
25295 return resultobj;
25296 fail:
25297 {
25298 if (temp7)
25299 delete arg7;
25300 }
25301 return NULL;
25302 }
25303
25304
25305 SWIGINTERN PyObject *_wrap_FontList_AddFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25306 PyObject *resultobj = 0;
25307 wxFontList *arg1 = (wxFontList *) 0 ;
25308 wxFont *arg2 = (wxFont *) 0 ;
25309 void *argp1 = 0 ;
25310 int res1 = 0 ;
25311 void *argp2 = 0 ;
25312 int res2 = 0 ;
25313 PyObject * obj0 = 0 ;
25314 PyObject * obj1 = 0 ;
25315 char * kwnames[] = {
25316 (char *) "self",(char *) "font", NULL
25317 };
25318
25319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) SWIG_fail;
25320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25321 if (!SWIG_IsOK(res1)) {
25322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_AddFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25323 }
25324 arg1 = reinterpret_cast< wxFontList * >(argp1);
25325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
25326 if (!SWIG_IsOK(res2)) {
25327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_AddFont" "', expected argument " "2"" of type '" "wxFont *""'");
25328 }
25329 arg2 = reinterpret_cast< wxFont * >(argp2);
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 (arg1)->AddFont(arg2);
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_Py_Void();
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *_wrap_FontList_RemoveFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj = 0;
25345 wxFontList *arg1 = (wxFontList *) 0 ;
25346 wxFont *arg2 = (wxFont *) 0 ;
25347 void *argp1 = 0 ;
25348 int res1 = 0 ;
25349 void *argp2 = 0 ;
25350 int res2 = 0 ;
25351 PyObject * obj0 = 0 ;
25352 PyObject * obj1 = 0 ;
25353 char * kwnames[] = {
25354 (char *) "self",(char *) "font", NULL
25355 };
25356
25357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) SWIG_fail;
25358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
25359 if (!SWIG_IsOK(res1)) {
25360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_RemoveFont" "', expected argument " "1"" of type '" "wxFontList *""'");
25361 }
25362 arg1 = reinterpret_cast< wxFontList * >(argp1);
25363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
25364 if (!SWIG_IsOK(res2)) {
25365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_RemoveFont" "', expected argument " "2"" of type '" "wxFont *""'");
25366 }
25367 arg2 = reinterpret_cast< wxFont * >(argp2);
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 (arg1)->RemoveFont(arg2);
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 *FontList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *obj;
25383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25384 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontList, SWIG_NewClientData(obj));
25385 return SWIG_Py_Void();
25386 }
25387
25388 SWIGINTERN PyObject *_wrap_new_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxColourDatabase *result = 0 ;
25391
25392 if (!SWIG_Python_UnpackTuple(args,"new_ColourDatabase",0,0,0)) SWIG_fail;
25393 {
25394 if (!wxPyCheckForApp()) SWIG_fail;
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = (wxColourDatabase *)new wxColourDatabase();
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_NEW | 0 );
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 SWIGINTERN PyObject *_wrap_delete_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25408 PyObject *resultobj = 0;
25409 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25410 void *argp1 = 0 ;
25411 int res1 = 0 ;
25412 PyObject *swig_obj[1] ;
25413
25414 if (!args) SWIG_fail;
25415 swig_obj[0] = args;
25416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_DISOWN | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDatabase" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25419 }
25420 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 delete arg1;
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_ColourDatabase_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj = 0;
25437 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25438 wxString *arg2 = 0 ;
25439 wxColour result;
25440 void *argp1 = 0 ;
25441 int res1 = 0 ;
25442 bool temp2 = false ;
25443 PyObject * obj0 = 0 ;
25444 PyObject * obj1 = 0 ;
25445 char * kwnames[] = {
25446 (char *) "self",(char *) "name", NULL
25447 };
25448
25449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) SWIG_fail;
25450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25451 if (!SWIG_IsOK(res1)) {
25452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Find" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
25453 }
25454 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25455 {
25456 arg2 = wxString_in_helper(obj1);
25457 if (arg2 == NULL) SWIG_fail;
25458 temp2 = true;
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25467 {
25468 if (temp2)
25469 delete arg2;
25470 }
25471 return resultobj;
25472 fail:
25473 {
25474 if (temp2)
25475 delete arg2;
25476 }
25477 return NULL;
25478 }
25479
25480
25481 SWIGINTERN PyObject *_wrap_ColourDatabase_FindName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj = 0;
25483 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25484 wxColour *arg2 = 0 ;
25485 wxString result;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 wxColour temp2 ;
25489 PyObject * obj0 = 0 ;
25490 PyObject * obj1 = 0 ;
25491 char * kwnames[] = {
25492 (char *) "self",(char *) "colour", NULL
25493 };
25494
25495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) SWIG_fail;
25496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_FindName" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
25499 }
25500 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25501 {
25502 arg2 = &temp2;
25503 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25504 }
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 {
25512 #if wxUSE_UNICODE
25513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25514 #else
25515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25516 #endif
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_ColourDatabase_AddColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = 0;
25526 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25527 wxString *arg2 = 0 ;
25528 wxColour *arg3 = 0 ;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 bool temp2 = false ;
25532 wxColour temp3 ;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 PyObject * obj2 = 0 ;
25536 char * kwnames[] = {
25537 (char *) "self",(char *) "name",(char *) "colour", NULL
25538 };
25539
25540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25542 if (!SWIG_IsOK(res1)) {
25543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_AddColour" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25544 }
25545 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25546 {
25547 arg2 = wxString_in_helper(obj1);
25548 if (arg2 == NULL) SWIG_fail;
25549 temp2 = true;
25550 }
25551 {
25552 arg3 = &temp3;
25553 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
25554 }
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 resultobj = SWIG_Py_Void();
25562 {
25563 if (temp2)
25564 delete arg2;
25565 }
25566 return resultobj;
25567 fail:
25568 {
25569 if (temp2)
25570 delete arg2;
25571 }
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *_wrap_ColourDatabase_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj = 0;
25578 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
25579 wxString *arg2 = 0 ;
25580 int arg3 ;
25581 int arg4 ;
25582 int arg5 ;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 bool temp2 = false ;
25586 int val3 ;
25587 int ecode3 = 0 ;
25588 int val4 ;
25589 int ecode4 = 0 ;
25590 int val5 ;
25591 int ecode5 = 0 ;
25592 PyObject * obj0 = 0 ;
25593 PyObject * obj1 = 0 ;
25594 PyObject * obj2 = 0 ;
25595 PyObject * obj3 = 0 ;
25596 PyObject * obj4 = 0 ;
25597 char * kwnames[] = {
25598 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
25599 };
25600
25601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25603 if (!SWIG_IsOK(res1)) {
25604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Append" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
25605 }
25606 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
25607 {
25608 arg2 = wxString_in_helper(obj1);
25609 if (arg2 == NULL) SWIG_fail;
25610 temp2 = true;
25611 }
25612 ecode3 = SWIG_AsVal_int(obj2, &val3);
25613 if (!SWIG_IsOK(ecode3)) {
25614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourDatabase_Append" "', expected argument " "3"" of type '" "int""'");
25615 }
25616 arg3 = static_cast< int >(val3);
25617 ecode4 = SWIG_AsVal_int(obj3, &val4);
25618 if (!SWIG_IsOK(ecode4)) {
25619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourDatabase_Append" "', expected argument " "4"" of type '" "int""'");
25620 }
25621 arg4 = static_cast< int >(val4);
25622 ecode5 = SWIG_AsVal_int(obj4, &val5);
25623 if (!SWIG_IsOK(ecode5)) {
25624 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourDatabase_Append" "', expected argument " "5"" of type '" "int""'");
25625 }
25626 arg5 = static_cast< int >(val5);
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 resultobj = SWIG_Py_Void();
25634 {
25635 if (temp2)
25636 delete arg2;
25637 }
25638 return resultobj;
25639 fail:
25640 {
25641 if (temp2)
25642 delete arg2;
25643 }
25644 return NULL;
25645 }
25646
25647
25648 SWIGINTERN PyObject *ColourDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 PyObject *obj;
25650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25651 SWIG_TypeNewClientData(SWIGTYPE_p_wxColourDatabase, SWIG_NewClientData(obj));
25652 return SWIG_Py_Void();
25653 }
25654
25655 SWIGINTERN PyObject *ColourDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656 return SWIG_Python_InitShadowInstance(args);
25657 }
25658
25659 SWIGINTERN PyObject *_wrap__wxPyInitTheFontList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxFontList *result = 0 ;
25662
25663 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheFontList",0,0,0)) SWIG_fail;
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (wxFontList *)_wxPyInitTheFontList();
25667 wxPyEndAllowThreads(__tstate);
25668 if (PyErr_Occurred()) SWIG_fail;
25669 }
25670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontList, 0 | 0 );
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *_wrap__wxPyInitThePenList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 PyObject *resultobj = 0;
25679 wxPenList *result = 0 ;
25680
25681 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitThePenList",0,0,0)) SWIG_fail;
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 result = (wxPenList *)_wxPyInitThePenList();
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPenList, 0 | 0 );
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap__wxPyInitTheBrushList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25696 PyObject *resultobj = 0;
25697 wxBrushList *result = 0 ;
25698
25699 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheBrushList",0,0,0)) SWIG_fail;
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (wxBrushList *)_wxPyInitTheBrushList();
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrushList, 0 | 0 );
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap__wxPyInitTheColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25714 PyObject *resultobj = 0;
25715 wxColourDatabase *result = 0 ;
25716
25717 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheColourDatabase",0,0,0)) SWIG_fail;
25718 {
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 result = (wxColourDatabase *)_wxPyInitTheColourDatabase();
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, 0 | 0 );
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 SWIGINTERN PyObject *_wrap_new_Effects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25732 PyObject *resultobj = 0;
25733 wxEffects *result = 0 ;
25734
25735 if (!SWIG_Python_UnpackTuple(args,"new_Effects",0,0,0)) SWIG_fail;
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (wxEffects *)new wxEffects();
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEffects, SWIG_POINTER_NEW | 0 );
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_Effects_GetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxEffects *arg1 = (wxEffects *) 0 ;
25752 wxColour result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetHighlightColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
25762 }
25763 arg1 = reinterpret_cast< wxEffects * >(argp1);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = ((wxEffects const *)arg1)->GetHighlightColour();
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 SWIGINTERN PyObject *_wrap_Effects_GetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25778 PyObject *resultobj = 0;
25779 wxEffects *arg1 = (wxEffects *) 0 ;
25780 wxColour result;
25781 void *argp1 = 0 ;
25782 int res1 = 0 ;
25783 PyObject *swig_obj[1] ;
25784
25785 if (!args) SWIG_fail;
25786 swig_obj[0] = args;
25787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25788 if (!SWIG_IsOK(res1)) {
25789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetLightShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
25790 }
25791 arg1 = reinterpret_cast< wxEffects * >(argp1);
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 result = ((wxEffects const *)arg1)->GetLightShadow();
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_Effects_GetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25806 PyObject *resultobj = 0;
25807 wxEffects *arg1 = (wxEffects *) 0 ;
25808 wxColour result;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 PyObject *swig_obj[1] ;
25812
25813 if (!args) SWIG_fail;
25814 swig_obj[0] = args;
25815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25816 if (!SWIG_IsOK(res1)) {
25817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetFaceColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
25818 }
25819 arg1 = reinterpret_cast< wxEffects * >(argp1);
25820 {
25821 PyThreadState* __tstate = wxPyBeginAllowThreads();
25822 result = ((wxEffects const *)arg1)->GetFaceColour();
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25827 return resultobj;
25828 fail:
25829 return NULL;
25830 }
25831
25832
25833 SWIGINTERN PyObject *_wrap_Effects_GetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25834 PyObject *resultobj = 0;
25835 wxEffects *arg1 = (wxEffects *) 0 ;
25836 wxColour result;
25837 void *argp1 = 0 ;
25838 int res1 = 0 ;
25839 PyObject *swig_obj[1] ;
25840
25841 if (!args) SWIG_fail;
25842 swig_obj[0] = args;
25843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetMediumShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
25846 }
25847 arg1 = reinterpret_cast< wxEffects * >(argp1);
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 result = ((wxEffects const *)arg1)->GetMediumShadow();
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_Effects_GetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25862 PyObject *resultobj = 0;
25863 wxEffects *arg1 = (wxEffects *) 0 ;
25864 wxColour result;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 PyObject *swig_obj[1] ;
25868
25869 if (!args) SWIG_fail;
25870 swig_obj[0] = args;
25871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25872 if (!SWIG_IsOK(res1)) {
25873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetDarkShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
25874 }
25875 arg1 = reinterpret_cast< wxEffects * >(argp1);
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = ((wxEffects const *)arg1)->GetDarkShadow();
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *_wrap_Effects_SetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25890 PyObject *resultobj = 0;
25891 wxEffects *arg1 = (wxEffects *) 0 ;
25892 wxColour *arg2 = 0 ;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 wxColour temp2 ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char * kwnames[] = {
25899 (char *) "self",(char *) "c", NULL
25900 };
25901
25902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
25903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25904 if (!SWIG_IsOK(res1)) {
25905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetHighlightColour" "', expected argument " "1"" of type '" "wxEffects *""'");
25906 }
25907 arg1 = reinterpret_cast< wxEffects * >(argp1);
25908 {
25909 arg2 = &temp2;
25910 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25911 }
25912 {
25913 PyThreadState* __tstate = wxPyBeginAllowThreads();
25914 (arg1)->SetHighlightColour((wxColour const &)*arg2);
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 resultobj = SWIG_Py_Void();
25919 return resultobj;
25920 fail:
25921 return NULL;
25922 }
25923
25924
25925 SWIGINTERN PyObject *_wrap_Effects_SetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj = 0;
25927 wxEffects *arg1 = (wxEffects *) 0 ;
25928 wxColour *arg2 = 0 ;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 wxColour temp2 ;
25932 PyObject * obj0 = 0 ;
25933 PyObject * obj1 = 0 ;
25934 char * kwnames[] = {
25935 (char *) "self",(char *) "c", NULL
25936 };
25937
25938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) SWIG_fail;
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetLightShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
25942 }
25943 arg1 = reinterpret_cast< wxEffects * >(argp1);
25944 {
25945 arg2 = &temp2;
25946 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25947 }
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 (arg1)->SetLightShadow((wxColour const &)*arg2);
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 resultobj = SWIG_Py_Void();
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 SWIGINTERN PyObject *_wrap_Effects_SetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj = 0;
25963 wxEffects *arg1 = (wxEffects *) 0 ;
25964 wxColour *arg2 = 0 ;
25965 void *argp1 = 0 ;
25966 int res1 = 0 ;
25967 wxColour temp2 ;
25968 PyObject * obj0 = 0 ;
25969 PyObject * obj1 = 0 ;
25970 char * kwnames[] = {
25971 (char *) "self",(char *) "c", NULL
25972 };
25973
25974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) SWIG_fail;
25975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
25976 if (!SWIG_IsOK(res1)) {
25977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetFaceColour" "', expected argument " "1"" of type '" "wxEffects *""'");
25978 }
25979 arg1 = reinterpret_cast< wxEffects * >(argp1);
25980 {
25981 arg2 = &temp2;
25982 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25983 }
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->SetFaceColour((wxColour const &)*arg2);
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_Py_Void();
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_Effects_SetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = 0;
25999 wxEffects *arg1 = (wxEffects *) 0 ;
26000 wxColour *arg2 = 0 ;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 wxColour temp2 ;
26004 PyObject * obj0 = 0 ;
26005 PyObject * obj1 = 0 ;
26006 char * kwnames[] = {
26007 (char *) "self",(char *) "c", NULL
26008 };
26009
26010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetMediumShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26014 }
26015 arg1 = reinterpret_cast< wxEffects * >(argp1);
26016 {
26017 arg2 = &temp2;
26018 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26019 }
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 (arg1)->SetMediumShadow((wxColour const &)*arg2);
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 resultobj = SWIG_Py_Void();
26027 return resultobj;
26028 fail:
26029 return NULL;
26030 }
26031
26032
26033 SWIGINTERN PyObject *_wrap_Effects_SetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26034 PyObject *resultobj = 0;
26035 wxEffects *arg1 = (wxEffects *) 0 ;
26036 wxColour *arg2 = 0 ;
26037 void *argp1 = 0 ;
26038 int res1 = 0 ;
26039 wxColour temp2 ;
26040 PyObject * obj0 = 0 ;
26041 PyObject * obj1 = 0 ;
26042 char * kwnames[] = {
26043 (char *) "self",(char *) "c", NULL
26044 };
26045
26046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26048 if (!SWIG_IsOK(res1)) {
26049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetDarkShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26050 }
26051 arg1 = reinterpret_cast< wxEffects * >(argp1);
26052 {
26053 arg2 = &temp2;
26054 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26055 }
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 (arg1)->SetDarkShadow((wxColour const &)*arg2);
26059 wxPyEndAllowThreads(__tstate);
26060 if (PyErr_Occurred()) SWIG_fail;
26061 }
26062 resultobj = SWIG_Py_Void();
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_Effects_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxEffects *arg1 = (wxEffects *) 0 ;
26072 wxColour *arg2 = 0 ;
26073 wxColour *arg3 = 0 ;
26074 wxColour *arg4 = 0 ;
26075 wxColour *arg5 = 0 ;
26076 wxColour *arg6 = 0 ;
26077 void *argp1 = 0 ;
26078 int res1 = 0 ;
26079 wxColour temp2 ;
26080 wxColour temp3 ;
26081 wxColour temp4 ;
26082 wxColour temp5 ;
26083 wxColour temp6 ;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 PyObject * obj2 = 0 ;
26087 PyObject * obj3 = 0 ;
26088 PyObject * obj4 = 0 ;
26089 PyObject * obj5 = 0 ;
26090 char * kwnames[] = {
26091 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
26092 };
26093
26094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
26095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26096 if (!SWIG_IsOK(res1)) {
26097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_Set" "', expected argument " "1"" of type '" "wxEffects *""'");
26098 }
26099 arg1 = reinterpret_cast< wxEffects * >(argp1);
26100 {
26101 arg2 = &temp2;
26102 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26103 }
26104 {
26105 arg3 = &temp3;
26106 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26107 }
26108 {
26109 arg4 = &temp4;
26110 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
26111 }
26112 {
26113 arg5 = &temp5;
26114 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
26115 }
26116 {
26117 arg6 = &temp6;
26118 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
26119 }
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_Py_Void();
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 SWIGINTERN PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj = 0;
26135 wxEffects *arg1 = (wxEffects *) 0 ;
26136 wxDC *arg2 = 0 ;
26137 wxRect *arg3 = 0 ;
26138 int arg4 = (int) 1 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 void *argp2 = 0 ;
26142 int res2 = 0 ;
26143 wxRect temp3 ;
26144 int val4 ;
26145 int ecode4 = 0 ;
26146 PyObject * obj0 = 0 ;
26147 PyObject * obj1 = 0 ;
26148 PyObject * obj2 = 0 ;
26149 PyObject * obj3 = 0 ;
26150 char * kwnames[] = {
26151 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
26152 };
26153
26154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "1"" of type '" "wxEffects *""'");
26158 }
26159 arg1 = reinterpret_cast< wxEffects * >(argp1);
26160 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
26161 if (!SWIG_IsOK(res2)) {
26162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
26163 }
26164 if (!argp2) {
26165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
26166 }
26167 arg2 = reinterpret_cast< wxDC * >(argp2);
26168 {
26169 arg3 = &temp3;
26170 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
26171 }
26172 if (obj3) {
26173 ecode4 = SWIG_AsVal_int(obj3, &val4);
26174 if (!SWIG_IsOK(ecode4)) {
26175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "4"" of type '" "int""'");
26176 }
26177 arg4 = static_cast< int >(val4);
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 resultobj = SWIG_Py_Void();
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 SWIGINTERN PyObject *_wrap_Effects_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26193 PyObject *resultobj = 0;
26194 wxEffects *arg1 = (wxEffects *) 0 ;
26195 wxRect *arg2 = 0 ;
26196 wxDC *arg3 = 0 ;
26197 wxBitmap *arg4 = 0 ;
26198 bool result;
26199 void *argp1 = 0 ;
26200 int res1 = 0 ;
26201 wxRect temp2 ;
26202 void *argp3 = 0 ;
26203 int res3 = 0 ;
26204 void *argp4 = 0 ;
26205 int res4 = 0 ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 PyObject * obj2 = 0 ;
26209 PyObject * obj3 = 0 ;
26210 char * kwnames[] = {
26211 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
26212 };
26213
26214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26216 if (!SWIG_IsOK(res1)) {
26217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_TileBitmap" "', expected argument " "1"" of type '" "wxEffects *""'");
26218 }
26219 arg1 = reinterpret_cast< wxEffects * >(argp1);
26220 {
26221 arg2 = &temp2;
26222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26223 }
26224 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26225 if (!SWIG_IsOK(res3)) {
26226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
26227 }
26228 if (!argp3) {
26229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
26230 }
26231 arg3 = reinterpret_cast< wxDC * >(argp3);
26232 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 );
26233 if (!SWIG_IsOK(res4)) {
26234 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
26235 }
26236 if (!argp4) {
26237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
26238 }
26239 arg4 = reinterpret_cast< wxBitmap * >(argp4);
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 {
26247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26248 }
26249 return resultobj;
26250 fail:
26251 return NULL;
26252 }
26253
26254
26255 SWIGINTERN PyObject *Effects_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26256 PyObject *obj;
26257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26258 SWIG_TypeNewClientData(SWIGTYPE_p_wxEffects, SWIG_NewClientData(obj));
26259 return SWIG_Py_Void();
26260 }
26261
26262 SWIGINTERN PyObject *Effects_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26263 return SWIG_Python_InitShadowInstance(args);
26264 }
26265
26266 SWIGINTERN PyObject *_wrap_new_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26267 PyObject *resultobj = 0;
26268 int arg1 ;
26269 int arg2 ;
26270 bool arg3 ;
26271 wxSplitterRenderParams *result = 0 ;
26272 int val1 ;
26273 int ecode1 = 0 ;
26274 int val2 ;
26275 int ecode2 = 0 ;
26276 bool val3 ;
26277 int ecode3 = 0 ;
26278 PyObject * obj0 = 0 ;
26279 PyObject * obj1 = 0 ;
26280 PyObject * obj2 = 0 ;
26281 char * kwnames[] = {
26282 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
26283 };
26284
26285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26286 ecode1 = SWIG_AsVal_int(obj0, &val1);
26287 if (!SWIG_IsOK(ecode1)) {
26288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplitterRenderParams" "', expected argument " "1"" of type '" "int""'");
26289 }
26290 arg1 = static_cast< int >(val1);
26291 ecode2 = SWIG_AsVal_int(obj1, &val2);
26292 if (!SWIG_IsOK(ecode2)) {
26293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SplitterRenderParams" "', expected argument " "2"" of type '" "int""'");
26294 }
26295 arg2 = static_cast< int >(val2);
26296 ecode3 = SWIG_AsVal_bool(obj2, &val3);
26297 if (!SWIG_IsOK(ecode3)) {
26298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SplitterRenderParams" "', expected argument " "3"" of type '" "bool""'");
26299 }
26300 arg3 = static_cast< bool >(val3);
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_NEW | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *_wrap_delete_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26315 PyObject *resultobj = 0;
26316 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26317 void *argp1 = 0 ;
26318 int res1 = 0 ;
26319 PyObject *swig_obj[1] ;
26320
26321 if (!args) SWIG_fail;
26322 swig_obj[0] = args;
26323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_DISOWN | 0 );
26324 if (!SWIG_IsOK(res1)) {
26325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplitterRenderParams" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26326 }
26327 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 delete arg1;
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 resultobj = SWIG_Py_Void();
26336 return resultobj;
26337 fail:
26338 return NULL;
26339 }
26340
26341
26342 SWIGINTERN PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26343 PyObject *resultobj = 0;
26344 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26345 int result;
26346 void *argp1 = 0 ;
26347 int res1 = 0 ;
26348 PyObject *swig_obj[1] ;
26349
26350 if (!args) SWIG_fail;
26351 swig_obj[0] = args;
26352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26353 if (!SWIG_IsOK(res1)) {
26354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_widthSash_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26355 }
26356 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26357 result = (int)(int) ((arg1)->widthSash);
26358 resultobj = SWIG_From_int(static_cast< int >(result));
26359 return resultobj;
26360 fail:
26361 return NULL;
26362 }
26363
26364
26365 SWIGINTERN PyObject *_wrap_SplitterRenderParams_border_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26366 PyObject *resultobj = 0;
26367 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26368 int result;
26369 void *argp1 = 0 ;
26370 int res1 = 0 ;
26371 PyObject *swig_obj[1] ;
26372
26373 if (!args) SWIG_fail;
26374 swig_obj[0] = args;
26375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26376 if (!SWIG_IsOK(res1)) {
26377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_border_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26378 }
26379 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26380 result = (int)(int) ((arg1)->border);
26381 resultobj = SWIG_From_int(static_cast< int >(result));
26382 return resultobj;
26383 fail:
26384 return NULL;
26385 }
26386
26387
26388 SWIGINTERN PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26389 PyObject *resultobj = 0;
26390 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
26391 bool result;
26392 void *argp1 = 0 ;
26393 int res1 = 0 ;
26394 PyObject *swig_obj[1] ;
26395
26396 if (!args) SWIG_fail;
26397 swig_obj[0] = args;
26398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
26399 if (!SWIG_IsOK(res1)) {
26400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_isHotSensitive_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
26401 }
26402 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
26403 result = (bool)(bool) ((arg1)->isHotSensitive);
26404 resultobj = SWIG_From_bool(static_cast< bool >(result));
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *SplitterRenderParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26412 PyObject *obj;
26413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26414 SWIG_TypeNewClientData(SWIGTYPE_p_wxSplitterRenderParams, SWIG_NewClientData(obj));
26415 return SWIG_Py_Void();
26416 }
26417
26418 SWIGINTERN PyObject *SplitterRenderParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26419 return SWIG_Python_InitShadowInstance(args);
26420 }
26421
26422 SWIGINTERN PyObject *_wrap_new_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26423 PyObject *resultobj = 0;
26424 int arg1 ;
26425 int arg2 ;
26426 wxRendererVersion *result = 0 ;
26427 int val1 ;
26428 int ecode1 = 0 ;
26429 int val2 ;
26430 int ecode2 = 0 ;
26431 PyObject * obj0 = 0 ;
26432 PyObject * obj1 = 0 ;
26433 char * kwnames[] = {
26434 (char *) "version_",(char *) "age_", NULL
26435 };
26436
26437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) SWIG_fail;
26438 ecode1 = SWIG_AsVal_int(obj0, &val1);
26439 if (!SWIG_IsOK(ecode1)) {
26440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RendererVersion" "', expected argument " "1"" of type '" "int""'");
26441 }
26442 arg1 = static_cast< int >(val1);
26443 ecode2 = SWIG_AsVal_int(obj1, &val2);
26444 if (!SWIG_IsOK(ecode2)) {
26445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RendererVersion" "', expected argument " "2"" of type '" "int""'");
26446 }
26447 arg2 = static_cast< int >(val2);
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_NEW | 0 );
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_delete_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26462 PyObject *resultobj = 0;
26463 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26464 void *argp1 = 0 ;
26465 int res1 = 0 ;
26466 PyObject *swig_obj[1] ;
26467
26468 if (!args) SWIG_fail;
26469 swig_obj[0] = args;
26470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_DISOWN | 0 );
26471 if (!SWIG_IsOK(res1)) {
26472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RendererVersion" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26473 }
26474 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 delete arg1;
26478
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 resultobj = SWIG_Py_Void();
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 SWIGINTERN PyObject *_wrap_RendererVersion_IsCompatible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 wxRendererVersion *arg1 = 0 ;
26492 bool result;
26493 void *argp1 = 0 ;
26494 int res1 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 char * kwnames[] = {
26497 (char *) "ver", NULL
26498 };
26499
26500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) SWIG_fail;
26501 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRendererVersion, 0 | 0);
26502 if (!SWIG_IsOK(res1)) {
26503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
26504 }
26505 if (!argp1) {
26506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
26507 }
26508 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 {
26516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 SWIGINTERN PyObject *_wrap_RendererVersion_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26525 PyObject *resultobj = 0;
26526 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26527 int result;
26528 void *argp1 = 0 ;
26529 int res1 = 0 ;
26530 PyObject *swig_obj[1] ;
26531
26532 if (!args) SWIG_fail;
26533 swig_obj[0] = args;
26534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
26535 if (!SWIG_IsOK(res1)) {
26536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_version_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26537 }
26538 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26539 result = (int)(int) ((arg1)->version);
26540 resultobj = SWIG_From_int(static_cast< int >(result));
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_RendererVersion_age_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
26550 int result;
26551 void *argp1 = 0 ;
26552 int res1 = 0 ;
26553 PyObject *swig_obj[1] ;
26554
26555 if (!args) SWIG_fail;
26556 swig_obj[0] = args;
26557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
26558 if (!SWIG_IsOK(res1)) {
26559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_age_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
26560 }
26561 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
26562 result = (int)(int) ((arg1)->age);
26563 resultobj = SWIG_From_int(static_cast< int >(result));
26564 return resultobj;
26565 fail:
26566 return NULL;
26567 }
26568
26569
26570 SWIGINTERN PyObject *RendererVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 PyObject *obj;
26572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26573 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererVersion, SWIG_NewClientData(obj));
26574 return SWIG_Py_Void();
26575 }
26576
26577 SWIGINTERN PyObject *RendererVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 return SWIG_Python_InitShadowInstance(args);
26579 }
26580
26581 SWIGINTERN PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26582 PyObject *resultobj = 0;
26583 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26584 wxWindow *arg2 = (wxWindow *) 0 ;
26585 wxDC *arg3 = 0 ;
26586 wxRect *arg4 = 0 ;
26587 int arg5 = (int) 0 ;
26588 void *argp1 = 0 ;
26589 int res1 = 0 ;
26590 void *argp2 = 0 ;
26591 int res2 = 0 ;
26592 void *argp3 = 0 ;
26593 int res3 = 0 ;
26594 wxRect temp4 ;
26595 int val5 ;
26596 int ecode5 = 0 ;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599 PyObject * obj2 = 0 ;
26600 PyObject * obj3 = 0 ;
26601 PyObject * obj4 = 0 ;
26602 char * kwnames[] = {
26603 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26604 };
26605
26606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26608 if (!SWIG_IsOK(res1)) {
26609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26610 }
26611 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26613 if (!SWIG_IsOK(res2)) {
26614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "2"" of type '" "wxWindow *""'");
26615 }
26616 arg2 = reinterpret_cast< wxWindow * >(argp2);
26617 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26618 if (!SWIG_IsOK(res3)) {
26619 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
26620 }
26621 if (!argp3) {
26622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
26623 }
26624 arg3 = reinterpret_cast< wxDC * >(argp3);
26625 {
26626 arg4 = &temp4;
26627 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26628 }
26629 if (obj4) {
26630 ecode5 = SWIG_AsVal_int(obj4, &val5);
26631 if (!SWIG_IsOK(ecode5)) {
26632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "5"" of type '" "int""'");
26633 }
26634 arg5 = static_cast< int >(val5);
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 resultobj = SWIG_Py_Void();
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26650 PyObject *resultobj = 0;
26651 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26652 wxWindow *arg2 = (wxWindow *) 0 ;
26653 wxDC *arg3 = 0 ;
26654 wxRect *arg4 = 0 ;
26655 int arg5 = (int) 0 ;
26656 void *argp1 = 0 ;
26657 int res1 = 0 ;
26658 void *argp2 = 0 ;
26659 int res2 = 0 ;
26660 void *argp3 = 0 ;
26661 int res3 = 0 ;
26662 wxRect temp4 ;
26663 int val5 ;
26664 int ecode5 = 0 ;
26665 PyObject * obj0 = 0 ;
26666 PyObject * obj1 = 0 ;
26667 PyObject * obj2 = 0 ;
26668 PyObject * obj3 = 0 ;
26669 PyObject * obj4 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26676 if (!SWIG_IsOK(res1)) {
26677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26678 }
26679 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26681 if (!SWIG_IsOK(res2)) {
26682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "2"" of type '" "wxWindow *""'");
26683 }
26684 arg2 = reinterpret_cast< wxWindow * >(argp2);
26685 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26686 if (!SWIG_IsOK(res3)) {
26687 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
26688 }
26689 if (!argp3) {
26690 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
26691 }
26692 arg3 = reinterpret_cast< wxDC * >(argp3);
26693 {
26694 arg4 = &temp4;
26695 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26696 }
26697 if (obj4) {
26698 ecode5 = SWIG_AsVal_int(obj4, &val5);
26699 if (!SWIG_IsOK(ecode5)) {
26700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "5"" of type '" "int""'");
26701 }
26702 arg5 = static_cast< int >(val5);
26703 }
26704 {
26705 PyThreadState* __tstate = wxPyBeginAllowThreads();
26706 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 resultobj = SWIG_Py_Void();
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj = 0;
26719 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26720 wxWindow *arg2 = (wxWindow *) 0 ;
26721 wxDC *arg3 = 0 ;
26722 wxRect *arg4 = 0 ;
26723 int arg5 = (int) 0 ;
26724 void *argp1 = 0 ;
26725 int res1 = 0 ;
26726 void *argp2 = 0 ;
26727 int res2 = 0 ;
26728 void *argp3 = 0 ;
26729 int res3 = 0 ;
26730 wxRect temp4 ;
26731 int val5 ;
26732 int ecode5 = 0 ;
26733 PyObject * obj0 = 0 ;
26734 PyObject * obj1 = 0 ;
26735 PyObject * obj2 = 0 ;
26736 PyObject * obj3 = 0 ;
26737 PyObject * obj4 = 0 ;
26738 char * kwnames[] = {
26739 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26740 };
26741
26742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26744 if (!SWIG_IsOK(res1)) {
26745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26746 }
26747 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26749 if (!SWIG_IsOK(res2)) {
26750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "2"" of type '" "wxWindow *""'");
26751 }
26752 arg2 = reinterpret_cast< wxWindow * >(argp2);
26753 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26754 if (!SWIG_IsOK(res3)) {
26755 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
26756 }
26757 if (!argp3) {
26758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
26759 }
26760 arg3 = reinterpret_cast< wxDC * >(argp3);
26761 {
26762 arg4 = &temp4;
26763 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26764 }
26765 if (obj4) {
26766 ecode5 = SWIG_AsVal_int(obj4, &val5);
26767 if (!SWIG_IsOK(ecode5)) {
26768 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "5"" of type '" "int""'");
26769 }
26770 arg5 = static_cast< int >(val5);
26771 }
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 resultobj = SWIG_Py_Void();
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = 0;
26787 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26788 wxWindow *arg2 = (wxWindow *) 0 ;
26789 wxDC *arg3 = 0 ;
26790 wxSize *arg4 = 0 ;
26791 int arg5 ;
26792 wxOrientation arg6 ;
26793 int arg7 = (int) 0 ;
26794 void *argp1 = 0 ;
26795 int res1 = 0 ;
26796 void *argp2 = 0 ;
26797 int res2 = 0 ;
26798 void *argp3 = 0 ;
26799 int res3 = 0 ;
26800 wxSize temp4 ;
26801 int val5 ;
26802 int ecode5 = 0 ;
26803 int val6 ;
26804 int ecode6 = 0 ;
26805 int val7 ;
26806 int ecode7 = 0 ;
26807 PyObject * obj0 = 0 ;
26808 PyObject * obj1 = 0 ;
26809 PyObject * obj2 = 0 ;
26810 PyObject * obj3 = 0 ;
26811 PyObject * obj4 = 0 ;
26812 PyObject * obj5 = 0 ;
26813 PyObject * obj6 = 0 ;
26814 char * kwnames[] = {
26815 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
26816 };
26817
26818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26822 }
26823 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26825 if (!SWIG_IsOK(res2)) {
26826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "2"" of type '" "wxWindow *""'");
26827 }
26828 arg2 = reinterpret_cast< wxWindow * >(argp2);
26829 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26830 if (!SWIG_IsOK(res3)) {
26831 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
26832 }
26833 if (!argp3) {
26834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
26835 }
26836 arg3 = reinterpret_cast< wxDC * >(argp3);
26837 {
26838 arg4 = &temp4;
26839 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26840 }
26841 ecode5 = SWIG_AsVal_int(obj4, &val5);
26842 if (!SWIG_IsOK(ecode5)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "5"" of type '" "int""'");
26844 }
26845 arg5 = static_cast< int >(val5);
26846 ecode6 = SWIG_AsVal_int(obj5, &val6);
26847 if (!SWIG_IsOK(ecode6)) {
26848 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "6"" of type '" "wxOrientation""'");
26849 }
26850 arg6 = static_cast< wxOrientation >(val6);
26851 if (obj6) {
26852 ecode7 = SWIG_AsVal_int(obj6, &val7);
26853 if (!SWIG_IsOK(ecode7)) {
26854 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "7"" of type '" "int""'");
26855 }
26856 arg7 = static_cast< int >(val7);
26857 }
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,arg6,arg7);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_Py_Void();
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26872 PyObject *resultobj = 0;
26873 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26874 wxWindow *arg2 = (wxWindow *) 0 ;
26875 wxDC *arg3 = 0 ;
26876 wxRect *arg4 = 0 ;
26877 int arg5 = (int) 0 ;
26878 void *argp1 = 0 ;
26879 int res1 = 0 ;
26880 void *argp2 = 0 ;
26881 int res2 = 0 ;
26882 void *argp3 = 0 ;
26883 int res3 = 0 ;
26884 wxRect temp4 ;
26885 int val5 ;
26886 int ecode5 = 0 ;
26887 PyObject * obj0 = 0 ;
26888 PyObject * obj1 = 0 ;
26889 PyObject * obj2 = 0 ;
26890 PyObject * obj3 = 0 ;
26891 PyObject * obj4 = 0 ;
26892 char * kwnames[] = {
26893 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26894 };
26895
26896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26900 }
26901 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26903 if (!SWIG_IsOK(res2)) {
26904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "2"" of type '" "wxWindow *""'");
26905 }
26906 arg2 = reinterpret_cast< wxWindow * >(argp2);
26907 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26908 if (!SWIG_IsOK(res3)) {
26909 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
26910 }
26911 if (!argp3) {
26912 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
26913 }
26914 arg3 = reinterpret_cast< wxDC * >(argp3);
26915 {
26916 arg4 = &temp4;
26917 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26918 }
26919 if (obj4) {
26920 ecode5 = SWIG_AsVal_int(obj4, &val5);
26921 if (!SWIG_IsOK(ecode5)) {
26922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "5"" of type '" "int""'");
26923 }
26924 arg5 = static_cast< int >(val5);
26925 }
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 resultobj = SWIG_Py_Void();
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj = 0;
26941 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
26942 wxWindow *arg2 = (wxWindow *) 0 ;
26943 wxDC *arg3 = 0 ;
26944 wxRect *arg4 = 0 ;
26945 int arg5 = (int) 0 ;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 void *argp2 = 0 ;
26949 int res2 = 0 ;
26950 void *argp3 = 0 ;
26951 int res3 = 0 ;
26952 wxRect temp4 ;
26953 int val5 ;
26954 int ecode5 = 0 ;
26955 PyObject * obj0 = 0 ;
26956 PyObject * obj1 = 0 ;
26957 PyObject * obj2 = 0 ;
26958 PyObject * obj3 = 0 ;
26959 PyObject * obj4 = 0 ;
26960 char * kwnames[] = {
26961 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
26962 };
26963
26964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
26966 if (!SWIG_IsOK(res1)) {
26967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "1"" of type '" "wxRendererNative *""'");
26968 }
26969 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
26970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26971 if (!SWIG_IsOK(res2)) {
26972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "2"" of type '" "wxWindow *""'");
26973 }
26974 arg2 = reinterpret_cast< wxWindow * >(argp2);
26975 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
26976 if (!SWIG_IsOK(res3)) {
26977 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
26978 }
26979 if (!argp3) {
26980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
26981 }
26982 arg3 = reinterpret_cast< wxDC * >(argp3);
26983 {
26984 arg4 = &temp4;
26985 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
26986 }
26987 if (obj4) {
26988 ecode5 = SWIG_AsVal_int(obj4, &val5);
26989 if (!SWIG_IsOK(ecode5)) {
26990 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "5"" of type '" "int""'");
26991 }
26992 arg5 = static_cast< int >(val5);
26993 }
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 resultobj = SWIG_Py_Void();
27001 return resultobj;
27002 fail:
27003 return NULL;
27004 }
27005
27006
27007 SWIGINTERN PyObject *_wrap_RendererNative_DrawCheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27008 PyObject *resultobj = 0;
27009 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27010 wxWindow *arg2 = (wxWindow *) 0 ;
27011 wxDC *arg3 = 0 ;
27012 wxRect *arg4 = 0 ;
27013 int arg5 = (int) 0 ;
27014 void *argp1 = 0 ;
27015 int res1 = 0 ;
27016 void *argp2 = 0 ;
27017 int res2 = 0 ;
27018 void *argp3 = 0 ;
27019 int res3 = 0 ;
27020 wxRect temp4 ;
27021 int val5 ;
27022 int ecode5 = 0 ;
27023 PyObject * obj0 = 0 ;
27024 PyObject * obj1 = 0 ;
27025 PyObject * obj2 = 0 ;
27026 PyObject * obj3 = 0 ;
27027 PyObject * obj4 = 0 ;
27028 char * kwnames[] = {
27029 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27030 };
27031
27032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawCheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27034 if (!SWIG_IsOK(res1)) {
27035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27036 }
27037 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27039 if (!SWIG_IsOK(res2)) {
27040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "2"" of type '" "wxWindow *""'");
27041 }
27042 arg2 = reinterpret_cast< wxWindow * >(argp2);
27043 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27044 if (!SWIG_IsOK(res3)) {
27045 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27046 }
27047 if (!argp3) {
27048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27049 }
27050 arg3 = reinterpret_cast< wxDC * >(argp3);
27051 {
27052 arg4 = &temp4;
27053 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27054 }
27055 if (obj4) {
27056 ecode5 = SWIG_AsVal_int(obj4, &val5);
27057 if (!SWIG_IsOK(ecode5)) {
27058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "5"" of type '" "int""'");
27059 }
27060 arg5 = static_cast< int >(val5);
27061 }
27062 {
27063 PyThreadState* __tstate = wxPyBeginAllowThreads();
27064 (arg1)->DrawCheckBox(arg2,*arg3,(wxRect const &)*arg4,arg5);
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 resultobj = SWIG_Py_Void();
27069 return resultobj;
27070 fail:
27071 return NULL;
27072 }
27073
27074
27075 SWIGINTERN PyObject *_wrap_RendererNative_DrawPushButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27076 PyObject *resultobj = 0;
27077 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27078 wxWindow *arg2 = (wxWindow *) 0 ;
27079 wxDC *arg3 = 0 ;
27080 wxRect *arg4 = 0 ;
27081 int arg5 = (int) 0 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 void *argp2 = 0 ;
27085 int res2 = 0 ;
27086 void *argp3 = 0 ;
27087 int res3 = 0 ;
27088 wxRect temp4 ;
27089 int val5 ;
27090 int ecode5 = 0 ;
27091 PyObject * obj0 = 0 ;
27092 PyObject * obj1 = 0 ;
27093 PyObject * obj2 = 0 ;
27094 PyObject * obj3 = 0 ;
27095 PyObject * obj4 = 0 ;
27096 char * kwnames[] = {
27097 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27098 };
27099
27100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawPushButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27102 if (!SWIG_IsOK(res1)) {
27103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawPushButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27104 }
27105 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27107 if (!SWIG_IsOK(res2)) {
27108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawPushButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27109 }
27110 arg2 = reinterpret_cast< wxWindow * >(argp2);
27111 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27112 if (!SWIG_IsOK(res3)) {
27113 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
27114 }
27115 if (!argp3) {
27116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
27117 }
27118 arg3 = reinterpret_cast< wxDC * >(argp3);
27119 {
27120 arg4 = &temp4;
27121 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27122 }
27123 if (obj4) {
27124 ecode5 = SWIG_AsVal_int(obj4, &val5);
27125 if (!SWIG_IsOK(ecode5)) {
27126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawPushButton" "', expected argument " "5"" of type '" "int""'");
27127 }
27128 arg5 = static_cast< int >(val5);
27129 }
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 (arg1)->DrawPushButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = SWIG_Py_Void();
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 SWIGINTERN PyObject *_wrap_RendererNative_DrawItemSelectionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27144 PyObject *resultobj = 0;
27145 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27146 wxWindow *arg2 = (wxWindow *) 0 ;
27147 wxDC *arg3 = 0 ;
27148 wxRect *arg4 = 0 ;
27149 int arg5 = (int) 0 ;
27150 void *argp1 = 0 ;
27151 int res1 = 0 ;
27152 void *argp2 = 0 ;
27153 int res2 = 0 ;
27154 void *argp3 = 0 ;
27155 int res3 = 0 ;
27156 wxRect temp4 ;
27157 int val5 ;
27158 int ecode5 = 0 ;
27159 PyObject * obj0 = 0 ;
27160 PyObject * obj1 = 0 ;
27161 PyObject * obj2 = 0 ;
27162 PyObject * obj3 = 0 ;
27163 PyObject * obj4 = 0 ;
27164 char * kwnames[] = {
27165 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27166 };
27167
27168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawItemSelectionRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27170 if (!SWIG_IsOK(res1)) {
27171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27172 }
27173 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27175 if (!SWIG_IsOK(res2)) {
27176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "2"" of type '" "wxWindow *""'");
27177 }
27178 arg2 = reinterpret_cast< wxWindow * >(argp2);
27179 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27180 if (!SWIG_IsOK(res3)) {
27181 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
27182 }
27183 if (!argp3) {
27184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
27185 }
27186 arg3 = reinterpret_cast< wxDC * >(argp3);
27187 {
27188 arg4 = &temp4;
27189 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27190 }
27191 if (obj4) {
27192 ecode5 = SWIG_AsVal_int(obj4, &val5);
27193 if (!SWIG_IsOK(ecode5)) {
27194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "5"" of type '" "int""'");
27195 }
27196 arg5 = static_cast< int >(val5);
27197 }
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 (arg1)->DrawItemSelectionRect(arg2,*arg3,(wxRect const &)*arg4,arg5);
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = SWIG_Py_Void();
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = 0;
27213 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27214 wxWindow *arg2 = (wxWindow *) 0 ;
27215 SwigValueWrapper<wxSplitterRenderParams > result;
27216 void *argp1 = 0 ;
27217 int res1 = 0 ;
27218 void *argp2 = 0 ;
27219 int res2 = 0 ;
27220 PyObject * obj0 = 0 ;
27221 PyObject * obj1 = 0 ;
27222 char * kwnames[] = {
27223 (char *) "self",(char *) "win", NULL
27224 };
27225
27226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) SWIG_fail;
27227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27228 if (!SWIG_IsOK(res1)) {
27229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27230 }
27231 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27233 if (!SWIG_IsOK(res2)) {
27234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "2"" of type '" "wxWindow const *""'");
27235 }
27236 arg2 = reinterpret_cast< wxWindow * >(argp2);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 resultobj = SWIG_NewPointerObj((new wxSplitterRenderParams(static_cast< const wxSplitterRenderParams& >(result))), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_OWN | 0 );
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_RendererNative_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27251 PyObject *resultobj = 0;
27252 wxRendererNative *result = 0 ;
27253
27254 if (!SWIG_Python_UnpackTuple(args,"RendererNative_Get",0,0,0)) SWIG_fail;
27255 {
27256 if (!wxPyCheckForApp()) SWIG_fail;
27257 PyThreadState* __tstate = wxPyBeginAllowThreads();
27258 {
27259 wxRendererNative &_result_ref = wxRendererNative::Get();
27260 result = (wxRendererNative *) &_result_ref;
27261 }
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 SWIGINTERN PyObject *_wrap_RendererNative_GetGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27273 PyObject *resultobj = 0;
27274 wxRendererNative *result = 0 ;
27275
27276 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetGeneric",0,0,0)) SWIG_fail;
27277 {
27278 if (!wxPyCheckForApp()) SWIG_fail;
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 {
27281 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
27282 result = (wxRendererNative *) &_result_ref;
27283 }
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_RendererNative_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *resultobj = 0;
27296 wxRendererNative *result = 0 ;
27297
27298 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetDefault",0,0,0)) SWIG_fail;
27299 {
27300 if (!wxPyCheckForApp()) SWIG_fail;
27301 PyThreadState* __tstate = wxPyBeginAllowThreads();
27302 {
27303 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
27304 result = (wxRendererNative *) &_result_ref;
27305 }
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *_wrap_RendererNative_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27317 PyObject *resultobj = 0;
27318 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27319 wxRendererNative *result = 0 ;
27320 void *argp1 = 0 ;
27321 int res1 = 0 ;
27322 PyObject * obj0 = 0 ;
27323 char * kwnames[] = {
27324 (char *) "renderer", NULL
27325 };
27326
27327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) SWIG_fail;
27328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27329 if (!SWIG_IsOK(res1)) {
27330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_Set" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27331 }
27332 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27333 {
27334 if (!wxPyCheckForApp()) SWIG_fail;
27335 PyThreadState* __tstate = wxPyBeginAllowThreads();
27336 result = (wxRendererNative *)wxRendererNative::Set(arg1);
27337 wxPyEndAllowThreads(__tstate);
27338 if (PyErr_Occurred()) SWIG_fail;
27339 }
27340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 SWIGINTERN PyObject *_wrap_RendererNative_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27348 PyObject *resultobj = 0;
27349 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27350 SwigValueWrapper<wxRendererVersion > result;
27351 void *argp1 = 0 ;
27352 int res1 = 0 ;
27353 PyObject *swig_obj[1] ;
27354
27355 if (!args) SWIG_fail;
27356 swig_obj[0] = args;
27357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27358 if (!SWIG_IsOK(res1)) {
27359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetVersion" "', expected argument " "1"" of type '" "wxRendererNative const *""'");
27360 }
27361 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27362 {
27363 PyThreadState* __tstate = wxPyBeginAllowThreads();
27364 result = ((wxRendererNative const *)arg1)->GetVersion();
27365 wxPyEndAllowThreads(__tstate);
27366 if (PyErr_Occurred()) SWIG_fail;
27367 }
27368 resultobj = SWIG_NewPointerObj((new wxRendererVersion(static_cast< const wxRendererVersion& >(result))), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_OWN | 0 );
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 SWIGINTERN PyObject *RendererNative_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27376 PyObject *obj;
27377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27378 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererNative, SWIG_NewClientData(obj));
27379 return SWIG_Py_Void();
27380 }
27381
27382 SWIGINTERN PyObject *_wrap_new_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPseudoDC *result = 0 ;
27385
27386 if (!SWIG_Python_UnpackTuple(args,"new_PseudoDC",0,0,0)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxPseudoDC *)new wxPseudoDC();
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_NEW | 0 );
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *_wrap_PseudoDC_BeginDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27401 PyObject *resultobj = 0;
27402 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27403 void *argp1 = 0 ;
27404 int res1 = 0 ;
27405 PyObject *swig_obj[1] ;
27406
27407 if (!args) SWIG_fail;
27408 swig_obj[0] = args;
27409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27410 if (!SWIG_IsOK(res1)) {
27411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_BeginDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27412 }
27413 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 (arg1)->BeginDrawing();
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 resultobj = SWIG_Py_Void();
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_PseudoDC_EndDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27428 PyObject *resultobj = 0;
27429 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27430 void *argp1 = 0 ;
27431 int res1 = 0 ;
27432 PyObject *swig_obj[1] ;
27433
27434 if (!args) SWIG_fail;
27435 swig_obj[0] = args;
27436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27437 if (!SWIG_IsOK(res1)) {
27438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_EndDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27439 }
27440 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 (arg1)->EndDrawing();
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_Py_Void();
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_delete_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_DISOWN | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PseudoDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27466 }
27467 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 delete arg1;
27471
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27483 PyObject *resultobj = 0;
27484 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject *swig_obj[1] ;
27488
27489 if (!args) SWIG_fail;
27490 swig_obj[0] = args;
27491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveAll" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 (arg1)->RemoveAll();
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 resultobj = SWIG_Py_Void();
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 SWIGINTERN PyObject *_wrap_PseudoDC_GetLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27510 PyObject *resultobj = 0;
27511 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27512 int result;
27513 void *argp1 = 0 ;
27514 int res1 = 0 ;
27515 PyObject *swig_obj[1] ;
27516
27517 if (!args) SWIG_fail;
27518 swig_obj[0] = args;
27519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27520 if (!SWIG_IsOK(res1)) {
27521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetLen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27522 }
27523 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = (int)(arg1)->GetLen();
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = SWIG_From_int(static_cast< int >(result));
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_PseudoDC_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = 0;
27539 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27540 int arg2 ;
27541 void *argp1 = 0 ;
27542 int res1 = 0 ;
27543 int val2 ;
27544 int ecode2 = 0 ;
27545 PyObject * obj0 = 0 ;
27546 PyObject * obj1 = 0 ;
27547 char * kwnames[] = {
27548 (char *) "self",(char *) "id", NULL
27549 };
27550
27551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
27552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27553 if (!SWIG_IsOK(res1)) {
27554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27555 }
27556 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27557 ecode2 = SWIG_AsVal_int(obj1, &val2);
27558 if (!SWIG_IsOK(ecode2)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetId" "', expected argument " "2"" of type '" "int""'");
27560 }
27561 arg2 = static_cast< int >(val2);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->SetId(arg2);
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_Py_Void();
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 SWIGINTERN PyObject *_wrap_PseudoDC_ClearId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27576 PyObject *resultobj = 0;
27577 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27578 int arg2 ;
27579 void *argp1 = 0 ;
27580 int res1 = 0 ;
27581 int val2 ;
27582 int ecode2 = 0 ;
27583 PyObject * obj0 = 0 ;
27584 PyObject * obj1 = 0 ;
27585 char * kwnames[] = {
27586 (char *) "self",(char *) "id", NULL
27587 };
27588
27589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_ClearId",kwnames,&obj0,&obj1)) SWIG_fail;
27590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27591 if (!SWIG_IsOK(res1)) {
27592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_ClearId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27593 }
27594 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27595 ecode2 = SWIG_AsVal_int(obj1, &val2);
27596 if (!SWIG_IsOK(ecode2)) {
27597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_ClearId" "', expected argument " "2"" of type '" "int""'");
27598 }
27599 arg2 = static_cast< int >(val2);
27600 {
27601 PyThreadState* __tstate = wxPyBeginAllowThreads();
27602 (arg1)->ClearId(arg2);
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 resultobj = SWIG_Py_Void();
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27614 PyObject *resultobj = 0;
27615 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27616 int arg2 ;
27617 void *argp1 = 0 ;
27618 int res1 = 0 ;
27619 int val2 ;
27620 int ecode2 = 0 ;
27621 PyObject * obj0 = 0 ;
27622 PyObject * obj1 = 0 ;
27623 char * kwnames[] = {
27624 (char *) "self",(char *) "id", NULL
27625 };
27626
27627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_RemoveId",kwnames,&obj0,&obj1)) SWIG_fail;
27628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27633 ecode2 = SWIG_AsVal_int(obj1, &val2);
27634 if (!SWIG_IsOK(ecode2)) {
27635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_RemoveId" "', expected argument " "2"" of type '" "int""'");
27636 }
27637 arg2 = static_cast< int >(val2);
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 (arg1)->RemoveId(arg2);
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 resultobj = SWIG_Py_Void();
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PseudoDC_TranslateId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj = 0;
27653 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27654 int arg2 ;
27655 int arg3 ;
27656 int arg4 ;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 int val2 ;
27660 int ecode2 = 0 ;
27661 int val3 ;
27662 int ecode3 = 0 ;
27663 int val4 ;
27664 int ecode4 = 0 ;
27665 PyObject * obj0 = 0 ;
27666 PyObject * obj1 = 0 ;
27667 PyObject * obj2 = 0 ;
27668 PyObject * obj3 = 0 ;
27669 char * kwnames[] = {
27670 (char *) "self",(char *) "id",(char *) "dx",(char *) "dy", NULL
27671 };
27672
27673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_TranslateId",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27675 if (!SWIG_IsOK(res1)) {
27676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_TranslateId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27677 }
27678 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27679 ecode2 = SWIG_AsVal_int(obj1, &val2);
27680 if (!SWIG_IsOK(ecode2)) {
27681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_TranslateId" "', expected argument " "2"" of type '" "int""'");
27682 }
27683 arg2 = static_cast< int >(val2);
27684 ecode3 = SWIG_AsVal_int(obj2, &val3);
27685 if (!SWIG_IsOK(ecode3)) {
27686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_TranslateId" "', expected argument " "3"" of type '" "int""'");
27687 }
27688 arg3 = static_cast< int >(val3);
27689 ecode4 = SWIG_AsVal_int(obj3, &val4);
27690 if (!SWIG_IsOK(ecode4)) {
27691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_TranslateId" "', expected argument " "4"" of type '" "int""'");
27692 }
27693 arg4 = static_cast< int >(val4);
27694 {
27695 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 (arg1)->TranslateId(arg2,arg3,arg4);
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_Py_Void();
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIdToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27708 PyObject *resultobj = 0;
27709 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27710 int arg2 ;
27711 wxDC *arg3 = (wxDC *) 0 ;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 int val2 ;
27715 int ecode2 = 0 ;
27716 void *argp3 = 0 ;
27717 int res3 = 0 ;
27718 PyObject * obj0 = 0 ;
27719 PyObject * obj1 = 0 ;
27720 PyObject * obj2 = 0 ;
27721 char * kwnames[] = {
27722 (char *) "self",(char *) "id",(char *) "dc", NULL
27723 };
27724
27725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIdToDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27727 if (!SWIG_IsOK(res1)) {
27728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27729 }
27730 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27731 ecode2 = SWIG_AsVal_int(obj1, &val2);
27732 if (!SWIG_IsOK(ecode2)) {
27733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "2"" of type '" "int""'");
27734 }
27735 arg2 = static_cast< int >(val2);
27736 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxDC, 0 | 0 );
27737 if (!SWIG_IsOK(res3)) {
27738 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "3"" of type '" "wxDC *""'");
27739 }
27740 arg3 = reinterpret_cast< wxDC * >(argp3);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 (arg1)->DrawIdToDC(arg2,arg3);
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_Py_Void();
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PseudoDC_SetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27755 PyObject *resultobj = 0;
27756 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27757 int arg2 ;
27758 wxRect *arg3 = 0 ;
27759 void *argp1 = 0 ;
27760 int res1 = 0 ;
27761 int val2 ;
27762 int ecode2 = 0 ;
27763 wxRect temp3 ;
27764 PyObject * obj0 = 0 ;
27765 PyObject * obj1 = 0 ;
27766 PyObject * obj2 = 0 ;
27767 char * kwnames[] = {
27768 (char *) "self",(char *) "id",(char *) "rect", NULL
27769 };
27770
27771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_SetIdBounds",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27773 if (!SWIG_IsOK(res1)) {
27774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27775 }
27776 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27777 ecode2 = SWIG_AsVal_int(obj1, &val2);
27778 if (!SWIG_IsOK(ecode2)) {
27779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "2"" of type '" "int""'");
27780 }
27781 arg2 = static_cast< int >(val2);
27782 {
27783 arg3 = &temp3;
27784 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
27785 }
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->SetIdBounds(arg2,*arg3);
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 resultobj = SWIG_Py_Void();
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 SWIGINTERN PyObject *_wrap_PseudoDC_GetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27800 PyObject *resultobj = 0;
27801 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27802 int arg2 ;
27803 wxRect result;
27804 void *argp1 = 0 ;
27805 int res1 = 0 ;
27806 int val2 ;
27807 int ecode2 = 0 ;
27808 PyObject * obj0 = 0 ;
27809 PyObject * obj1 = 0 ;
27810 char * kwnames[] = {
27811 (char *) "self",(char *) "id", NULL
27812 };
27813
27814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_GetIdBounds",kwnames,&obj0,&obj1)) SWIG_fail;
27815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27816 if (!SWIG_IsOK(res1)) {
27817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27818 }
27819 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27820 ecode2 = SWIG_AsVal_int(obj1, &val2);
27821 if (!SWIG_IsOK(ecode2)) {
27822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "2"" of type '" "int""'");
27823 }
27824 arg2 = static_cast< int >(val2);
27825 {
27826 PyThreadState* __tstate = wxPyBeginAllowThreads();
27827 result = wxPseudoDC_GetIdBounds(arg1,arg2);
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27839 PyObject *resultobj = 0;
27840 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27841 wxDC *arg2 = (wxDC *) 0 ;
27842 wxRect *arg3 = 0 ;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 void *argp2 = 0 ;
27846 int res2 = 0 ;
27847 wxRect temp3 ;
27848 PyObject * obj0 = 0 ;
27849 PyObject * obj1 = 0 ;
27850 PyObject * obj2 = 0 ;
27851 char * kwnames[] = {
27852 (char *) "self",(char *) "dc",(char *) "rect", NULL
27853 };
27854
27855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClipped",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27859 }
27860 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27862 if (!SWIG_IsOK(res2)) {
27863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "2"" of type '" "wxDC *""'");
27864 }
27865 arg2 = reinterpret_cast< wxDC * >(argp2);
27866 {
27867 arg3 = &temp3;
27868 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
27869 }
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 (arg1)->DrawToDCClipped(arg2,(wxRect const &)*arg3);
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 resultobj = SWIG_Py_Void();
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClippedRgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27884 PyObject *resultobj = 0;
27885 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27886 wxDC *arg2 = (wxDC *) 0 ;
27887 wxRegion *arg3 = 0 ;
27888 void *argp1 = 0 ;
27889 int res1 = 0 ;
27890 void *argp2 = 0 ;
27891 int res2 = 0 ;
27892 void *argp3 = 0 ;
27893 int res3 = 0 ;
27894 PyObject * obj0 = 0 ;
27895 PyObject * obj1 = 0 ;
27896 PyObject * obj2 = 0 ;
27897 char * kwnames[] = {
27898 (char *) "self",(char *) "dc",(char *) "region", NULL
27899 };
27900
27901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClippedRgn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27905 }
27906 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27908 if (!SWIG_IsOK(res2)) {
27909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "2"" of type '" "wxDC *""'");
27910 }
27911 arg2 = reinterpret_cast< wxDC * >(argp2);
27912 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRegion, 0 | 0);
27913 if (!SWIG_IsOK(res3)) {
27914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
27915 }
27916 if (!argp3) {
27917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
27918 }
27919 arg3 = reinterpret_cast< wxRegion * >(argp3);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 (arg1)->DrawToDCClippedRgn(arg2,(wxRegion const &)*arg3);
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 resultobj = SWIG_Py_Void();
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj = 0;
27935 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27936 wxDC *arg2 = (wxDC *) 0 ;
27937 void *argp1 = 0 ;
27938 int res1 = 0 ;
27939 void *argp2 = 0 ;
27940 int res2 = 0 ;
27941 PyObject * obj0 = 0 ;
27942 PyObject * obj1 = 0 ;
27943 char * kwnames[] = {
27944 (char *) "self",(char *) "dc", NULL
27945 };
27946
27947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawToDC",kwnames,&obj0,&obj1)) SWIG_fail;
27948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27949 if (!SWIG_IsOK(res1)) {
27950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
27951 }
27952 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
27953 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27954 if (!SWIG_IsOK(res2)) {
27955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDC" "', expected argument " "2"" of type '" "wxDC *""'");
27956 }
27957 arg2 = reinterpret_cast< wxDC * >(argp2);
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 (arg1)->DrawToDC(arg2);
27961 wxPyEndAllowThreads(__tstate);
27962 if (PyErr_Occurred()) SWIG_fail;
27963 }
27964 resultobj = SWIG_Py_Void();
27965 return resultobj;
27966 fail:
27967 return NULL;
27968 }
27969
27970
27971 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27972 PyObject *resultobj = 0;
27973 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
27974 int arg2 ;
27975 int arg3 ;
27976 wxColour *arg4 = 0 ;
27977 int arg5 = (int) wxFLOOD_SURFACE ;
27978 void *argp1 = 0 ;
27979 int res1 = 0 ;
27980 int val2 ;
27981 int ecode2 = 0 ;
27982 int val3 ;
27983 int ecode3 = 0 ;
27984 wxColour temp4 ;
27985 int val5 ;
27986 int ecode5 = 0 ;
27987 PyObject * obj0 = 0 ;
27988 PyObject * obj1 = 0 ;
27989 PyObject * obj2 = 0 ;
27990 PyObject * obj3 = 0 ;
27991 PyObject * obj4 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFill" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28000 }
28001 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28002 ecode2 = SWIG_AsVal_int(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_FloodFill" "', expected argument " "2"" of type '" "int""'");
28005 }
28006 arg2 = static_cast< int >(val2);
28007 ecode3 = SWIG_AsVal_int(obj2, &val3);
28008 if (!SWIG_IsOK(ecode3)) {
28009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_FloodFill" "', expected argument " "3"" of type '" "int""'");
28010 }
28011 arg3 = static_cast< int >(val3);
28012 {
28013 arg4 = &temp4;
28014 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
28015 }
28016 if (obj4) {
28017 ecode5 = SWIG_AsVal_int(obj4, &val5);
28018 if (!SWIG_IsOK(ecode5)) {
28019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_FloodFill" "', expected argument " "5"" of type '" "int""'");
28020 }
28021 arg5 = static_cast< int >(val5);
28022 }
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 (arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 resultobj = SWIG_Py_Void();
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj = 0;
28038 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28039 wxPoint *arg2 = 0 ;
28040 wxColour *arg3 = 0 ;
28041 int arg4 = (int) wxFLOOD_SURFACE ;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 wxPoint temp2 ;
28045 wxColour temp3 ;
28046 int val4 ;
28047 int ecode4 = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 PyObject * obj2 = 0 ;
28051 PyObject * obj3 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28058 if (!SWIG_IsOK(res1)) {
28059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28060 }
28061 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28062 {
28063 arg2 = &temp2;
28064 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28065 }
28066 {
28067 arg3 = &temp3;
28068 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
28069 }
28070 if (obj3) {
28071 ecode4 = SWIG_AsVal_int(obj3, &val4);
28072 if (!SWIG_IsOK(ecode4)) {
28073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
28074 }
28075 arg4 = static_cast< int >(val4);
28076 }
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 (arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_Py_Void();
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28091 PyObject *resultobj = 0;
28092 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28093 int arg2 ;
28094 int arg3 ;
28095 int arg4 ;
28096 int arg5 ;
28097 void *argp1 = 0 ;
28098 int res1 = 0 ;
28099 int val2 ;
28100 int ecode2 = 0 ;
28101 int val3 ;
28102 int ecode3 = 0 ;
28103 int val4 ;
28104 int ecode4 = 0 ;
28105 int val5 ;
28106 int ecode5 = 0 ;
28107 PyObject * obj0 = 0 ;
28108 PyObject * obj1 = 0 ;
28109 PyObject * obj2 = 0 ;
28110 PyObject * obj3 = 0 ;
28111 PyObject * obj4 = 0 ;
28112 char * kwnames[] = {
28113 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
28114 };
28115
28116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28118 if (!SWIG_IsOK(res1)) {
28119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLine" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28120 }
28121 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28122 ecode2 = SWIG_AsVal_int(obj1, &val2);
28123 if (!SWIG_IsOK(ecode2)) {
28124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawLine" "', expected argument " "2"" of type '" "int""'");
28125 }
28126 arg2 = static_cast< int >(val2);
28127 ecode3 = SWIG_AsVal_int(obj2, &val3);
28128 if (!SWIG_IsOK(ecode3)) {
28129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawLine" "', expected argument " "3"" of type '" "int""'");
28130 }
28131 arg3 = static_cast< int >(val3);
28132 ecode4 = SWIG_AsVal_int(obj3, &val4);
28133 if (!SWIG_IsOK(ecode4)) {
28134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLine" "', expected argument " "4"" of type '" "int""'");
28135 }
28136 arg4 = static_cast< int >(val4);
28137 ecode5 = SWIG_AsVal_int(obj4, &val5);
28138 if (!SWIG_IsOK(ecode5)) {
28139 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLine" "', expected argument " "5"" of type '" "int""'");
28140 }
28141 arg5 = static_cast< int >(val5);
28142 {
28143 PyThreadState* __tstate = wxPyBeginAllowThreads();
28144 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
28145 wxPyEndAllowThreads(__tstate);
28146 if (PyErr_Occurred()) SWIG_fail;
28147 }
28148 resultobj = SWIG_Py_Void();
28149 return resultobj;
28150 fail:
28151 return NULL;
28152 }
28153
28154
28155 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28156 PyObject *resultobj = 0;
28157 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28158 wxPoint *arg2 = 0 ;
28159 wxPoint *arg3 = 0 ;
28160 void *argp1 = 0 ;
28161 int res1 = 0 ;
28162 wxPoint temp2 ;
28163 wxPoint temp3 ;
28164 PyObject * obj0 = 0 ;
28165 PyObject * obj1 = 0 ;
28166 PyObject * obj2 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28173 if (!SWIG_IsOK(res1)) {
28174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLinePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28175 }
28176 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28177 {
28178 arg2 = &temp2;
28179 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28180 }
28181 {
28182 arg3 = &temp3;
28183 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28184 }
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_Py_Void();
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj = 0;
28200 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28201 int arg2 ;
28202 int arg3 ;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 int val2 ;
28206 int ecode2 = 0 ;
28207 int val3 ;
28208 int ecode3 = 0 ;
28209 PyObject * obj0 = 0 ;
28210 PyObject * obj1 = 0 ;
28211 PyObject * obj2 = 0 ;
28212 char * kwnames[] = {
28213 (char *) "self",(char *) "x",(char *) "y", NULL
28214 };
28215
28216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28218 if (!SWIG_IsOK(res1)) {
28219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHair" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28220 }
28221 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28222 ecode2 = SWIG_AsVal_int(obj1, &val2);
28223 if (!SWIG_IsOK(ecode2)) {
28224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_CrossHair" "', expected argument " "2"" of type '" "int""'");
28225 }
28226 arg2 = static_cast< int >(val2);
28227 ecode3 = SWIG_AsVal_int(obj2, &val3);
28228 if (!SWIG_IsOK(ecode3)) {
28229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_CrossHair" "', expected argument " "3"" of type '" "int""'");
28230 }
28231 arg3 = static_cast< int >(val3);
28232 {
28233 PyThreadState* __tstate = wxPyBeginAllowThreads();
28234 (arg1)->CrossHair(arg2,arg3);
28235 wxPyEndAllowThreads(__tstate);
28236 if (PyErr_Occurred()) SWIG_fail;
28237 }
28238 resultobj = SWIG_Py_Void();
28239 return resultobj;
28240 fail:
28241 return NULL;
28242 }
28243
28244
28245 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28246 PyObject *resultobj = 0;
28247 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28248 wxPoint *arg2 = 0 ;
28249 void *argp1 = 0 ;
28250 int res1 = 0 ;
28251 wxPoint temp2 ;
28252 PyObject * obj0 = 0 ;
28253 PyObject * obj1 = 0 ;
28254 char * kwnames[] = {
28255 (char *) "self",(char *) "pt", NULL
28256 };
28257
28258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
28259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28260 if (!SWIG_IsOK(res1)) {
28261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHairPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28262 }
28263 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28264 {
28265 arg2 = &temp2;
28266 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28267 }
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 (arg1)->CrossHair((wxPoint const &)*arg2);
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_Py_Void();
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28284 int arg2 ;
28285 int arg3 ;
28286 int arg4 ;
28287 int arg5 ;
28288 int arg6 ;
28289 int arg7 ;
28290 void *argp1 = 0 ;
28291 int res1 = 0 ;
28292 int val2 ;
28293 int ecode2 = 0 ;
28294 int val3 ;
28295 int ecode3 = 0 ;
28296 int val4 ;
28297 int ecode4 = 0 ;
28298 int val5 ;
28299 int ecode5 = 0 ;
28300 int val6 ;
28301 int ecode6 = 0 ;
28302 int val7 ;
28303 int ecode7 = 0 ;
28304 PyObject * obj0 = 0 ;
28305 PyObject * obj1 = 0 ;
28306 PyObject * obj2 = 0 ;
28307 PyObject * obj3 = 0 ;
28308 PyObject * obj4 = 0 ;
28309 PyObject * obj5 = 0 ;
28310 PyObject * obj6 = 0 ;
28311 char * kwnames[] = {
28312 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
28313 };
28314
28315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28317 if (!SWIG_IsOK(res1)) {
28318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28319 }
28320 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28321 ecode2 = SWIG_AsVal_int(obj1, &val2);
28322 if (!SWIG_IsOK(ecode2)) {
28323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawArc" "', expected argument " "2"" of type '" "int""'");
28324 }
28325 arg2 = static_cast< int >(val2);
28326 ecode3 = SWIG_AsVal_int(obj2, &val3);
28327 if (!SWIG_IsOK(ecode3)) {
28328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawArc" "', expected argument " "3"" of type '" "int""'");
28329 }
28330 arg3 = static_cast< int >(val3);
28331 ecode4 = SWIG_AsVal_int(obj3, &val4);
28332 if (!SWIG_IsOK(ecode4)) {
28333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawArc" "', expected argument " "4"" of type '" "int""'");
28334 }
28335 arg4 = static_cast< int >(val4);
28336 ecode5 = SWIG_AsVal_int(obj4, &val5);
28337 if (!SWIG_IsOK(ecode5)) {
28338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawArc" "', expected argument " "5"" of type '" "int""'");
28339 }
28340 arg5 = static_cast< int >(val5);
28341 ecode6 = SWIG_AsVal_int(obj5, &val6);
28342 if (!SWIG_IsOK(ecode6)) {
28343 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawArc" "', expected argument " "6"" of type '" "int""'");
28344 }
28345 arg6 = static_cast< int >(val6);
28346 ecode7 = SWIG_AsVal_int(obj6, &val7);
28347 if (!SWIG_IsOK(ecode7)) {
28348 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawArc" "', expected argument " "7"" of type '" "int""'");
28349 }
28350 arg7 = static_cast< int >(val7);
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 resultobj = SWIG_Py_Void();
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28367 wxPoint *arg2 = 0 ;
28368 wxPoint *arg3 = 0 ;
28369 wxPoint *arg4 = 0 ;
28370 void *argp1 = 0 ;
28371 int res1 = 0 ;
28372 wxPoint temp2 ;
28373 wxPoint temp3 ;
28374 wxPoint temp4 ;
28375 PyObject * obj0 = 0 ;
28376 PyObject * obj1 = 0 ;
28377 PyObject * obj2 = 0 ;
28378 PyObject * obj3 = 0 ;
28379 char * kwnames[] = {
28380 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
28381 };
28382
28383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28385 if (!SWIG_IsOK(res1)) {
28386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArcPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28387 }
28388 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28389 {
28390 arg2 = &temp2;
28391 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28392 }
28393 {
28394 arg3 = &temp3;
28395 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
28396 }
28397 {
28398 arg4 = &temp4;
28399 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
28400 }
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_Py_Void();
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj = 0;
28416 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28417 int arg2 ;
28418 int arg3 ;
28419 int arg4 ;
28420 int arg5 ;
28421 void *argp1 = 0 ;
28422 int res1 = 0 ;
28423 int val2 ;
28424 int ecode2 = 0 ;
28425 int val3 ;
28426 int ecode3 = 0 ;
28427 int val4 ;
28428 int ecode4 = 0 ;
28429 int val5 ;
28430 int ecode5 = 0 ;
28431 PyObject * obj0 = 0 ;
28432 PyObject * obj1 = 0 ;
28433 PyObject * obj2 = 0 ;
28434 PyObject * obj3 = 0 ;
28435 PyObject * obj4 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28444 }
28445 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28446 ecode2 = SWIG_AsVal_int(obj1, &val2);
28447 if (!SWIG_IsOK(ecode2)) {
28448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
28449 }
28450 arg2 = static_cast< int >(val2);
28451 ecode3 = SWIG_AsVal_int(obj2, &val3);
28452 if (!SWIG_IsOK(ecode3)) {
28453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
28454 }
28455 arg3 = static_cast< int >(val3);
28456 ecode4 = SWIG_AsVal_int(obj3, &val4);
28457 if (!SWIG_IsOK(ecode4)) {
28458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
28459 }
28460 arg4 = static_cast< int >(val4);
28461 ecode5 = SWIG_AsVal_int(obj4, &val5);
28462 if (!SWIG_IsOK(ecode5)) {
28463 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
28464 }
28465 arg5 = static_cast< int >(val5);
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 resultobj = SWIG_Py_Void();
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28480 PyObject *resultobj = 0;
28481 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28482 wxRect *arg2 = 0 ;
28483 void *argp1 = 0 ;
28484 int res1 = 0 ;
28485 wxRect temp2 ;
28486 PyObject * obj0 = 0 ;
28487 PyObject * obj1 = 0 ;
28488 char * kwnames[] = {
28489 (char *) "self",(char *) "rect", NULL
28490 };
28491
28492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
28493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28494 if (!SWIG_IsOK(res1)) {
28495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28496 }
28497 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28498 {
28499 arg2 = &temp2;
28500 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28501 }
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 (arg1)->DrawCheckMark((wxRect const &)*arg2);
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 resultobj = SWIG_Py_Void();
28509 return resultobj;
28510 fail:
28511 return NULL;
28512 }
28513
28514
28515 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28516 PyObject *resultobj = 0;
28517 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28518 int arg2 ;
28519 int arg3 ;
28520 int arg4 ;
28521 int arg5 ;
28522 double arg6 ;
28523 double arg7 ;
28524 void *argp1 = 0 ;
28525 int res1 = 0 ;
28526 int val2 ;
28527 int ecode2 = 0 ;
28528 int val3 ;
28529 int ecode3 = 0 ;
28530 int val4 ;
28531 int ecode4 = 0 ;
28532 int val5 ;
28533 int ecode5 = 0 ;
28534 double val6 ;
28535 int ecode6 = 0 ;
28536 double val7 ;
28537 int ecode7 = 0 ;
28538 PyObject * obj0 = 0 ;
28539 PyObject * obj1 = 0 ;
28540 PyObject * obj2 = 0 ;
28541 PyObject * obj3 = 0 ;
28542 PyObject * obj4 = 0 ;
28543 PyObject * obj5 = 0 ;
28544 PyObject * obj6 = 0 ;
28545 char * kwnames[] = {
28546 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
28547 };
28548
28549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28551 if (!SWIG_IsOK(res1)) {
28552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28553 }
28554 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28555 ecode2 = SWIG_AsVal_int(obj1, &val2);
28556 if (!SWIG_IsOK(ecode2)) {
28557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
28558 }
28559 arg2 = static_cast< int >(val2);
28560 ecode3 = SWIG_AsVal_int(obj2, &val3);
28561 if (!SWIG_IsOK(ecode3)) {
28562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
28563 }
28564 arg3 = static_cast< int >(val3);
28565 ecode4 = SWIG_AsVal_int(obj3, &val4);
28566 if (!SWIG_IsOK(ecode4)) {
28567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
28568 }
28569 arg4 = static_cast< int >(val4);
28570 ecode5 = SWIG_AsVal_int(obj4, &val5);
28571 if (!SWIG_IsOK(ecode5)) {
28572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
28573 }
28574 arg5 = static_cast< int >(val5);
28575 ecode6 = SWIG_AsVal_double(obj5, &val6);
28576 if (!SWIG_IsOK(ecode6)) {
28577 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
28578 }
28579 arg6 = static_cast< double >(val6);
28580 ecode7 = SWIG_AsVal_double(obj6, &val7);
28581 if (!SWIG_IsOK(ecode7)) {
28582 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
28583 }
28584 arg7 = static_cast< double >(val7);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 resultobj = SWIG_Py_Void();
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28599 PyObject *resultobj = 0;
28600 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28601 wxPoint *arg2 = 0 ;
28602 wxSize *arg3 = 0 ;
28603 double arg4 ;
28604 double arg5 ;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 wxPoint temp2 ;
28608 wxSize temp3 ;
28609 double val4 ;
28610 int ecode4 = 0 ;
28611 double val5 ;
28612 int ecode5 = 0 ;
28613 PyObject * obj0 = 0 ;
28614 PyObject * obj1 = 0 ;
28615 PyObject * obj2 = 0 ;
28616 PyObject * obj3 = 0 ;
28617 PyObject * obj4 = 0 ;
28618 char * kwnames[] = {
28619 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
28620 };
28621
28622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28626 }
28627 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28628 {
28629 arg2 = &temp2;
28630 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28631 }
28632 {
28633 arg3 = &temp3;
28634 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
28635 }
28636 ecode4 = SWIG_AsVal_double(obj3, &val4);
28637 if (!SWIG_IsOK(ecode4)) {
28638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
28639 }
28640 arg4 = static_cast< double >(val4);
28641 ecode5 = SWIG_AsVal_double(obj4, &val5);
28642 if (!SWIG_IsOK(ecode5)) {
28643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
28644 }
28645 arg5 = static_cast< double >(val5);
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 resultobj = SWIG_Py_Void();
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28660 PyObject *resultobj = 0;
28661 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28662 int arg2 ;
28663 int arg3 ;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 int val2 ;
28667 int ecode2 = 0 ;
28668 int val3 ;
28669 int ecode3 = 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 PyObject * obj2 = 0 ;
28673 char * kwnames[] = {
28674 (char *) "self",(char *) "x",(char *) "y", NULL
28675 };
28676
28677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28679 if (!SWIG_IsOK(res1)) {
28680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28681 }
28682 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28683 ecode2 = SWIG_AsVal_int(obj1, &val2);
28684 if (!SWIG_IsOK(ecode2)) {
28685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
28686 }
28687 arg2 = static_cast< int >(val2);
28688 ecode3 = SWIG_AsVal_int(obj2, &val3);
28689 if (!SWIG_IsOK(ecode3)) {
28690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
28691 }
28692 arg3 = static_cast< int >(val3);
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 (arg1)->DrawPoint(arg2,arg3);
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_Py_Void();
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28707 PyObject *resultobj = 0;
28708 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28709 wxPoint *arg2 = 0 ;
28710 void *argp1 = 0 ;
28711 int res1 = 0 ;
28712 wxPoint temp2 ;
28713 PyObject * obj0 = 0 ;
28714 PyObject * obj1 = 0 ;
28715 char * kwnames[] = {
28716 (char *) "self",(char *) "pt", NULL
28717 };
28718
28719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
28720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28721 if (!SWIG_IsOK(res1)) {
28722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPointPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28723 }
28724 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28725 {
28726 arg2 = &temp2;
28727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28728 }
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 (arg1)->DrawPoint((wxPoint const &)*arg2);
28732 wxPyEndAllowThreads(__tstate);
28733 if (PyErr_Occurred()) SWIG_fail;
28734 }
28735 resultobj = SWIG_Py_Void();
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = 0;
28744 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28745 int arg2 ;
28746 int arg3 ;
28747 int arg4 ;
28748 int arg5 ;
28749 void *argp1 = 0 ;
28750 int res1 = 0 ;
28751 int val2 ;
28752 int ecode2 = 0 ;
28753 int val3 ;
28754 int ecode3 = 0 ;
28755 int val4 ;
28756 int ecode4 = 0 ;
28757 int val5 ;
28758 int ecode5 = 0 ;
28759 PyObject * obj0 = 0 ;
28760 PyObject * obj1 = 0 ;
28761 PyObject * obj2 = 0 ;
28762 PyObject * obj3 = 0 ;
28763 PyObject * obj4 = 0 ;
28764 char * kwnames[] = {
28765 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
28766 };
28767
28768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28770 if (!SWIG_IsOK(res1)) {
28771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28772 }
28773 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28774 ecode2 = SWIG_AsVal_int(obj1, &val2);
28775 if (!SWIG_IsOK(ecode2)) {
28776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
28777 }
28778 arg2 = static_cast< int >(val2);
28779 ecode3 = SWIG_AsVal_int(obj2, &val3);
28780 if (!SWIG_IsOK(ecode3)) {
28781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
28782 }
28783 arg3 = static_cast< int >(val3);
28784 ecode4 = SWIG_AsVal_int(obj3, &val4);
28785 if (!SWIG_IsOK(ecode4)) {
28786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
28787 }
28788 arg4 = static_cast< int >(val4);
28789 ecode5 = SWIG_AsVal_int(obj4, &val5);
28790 if (!SWIG_IsOK(ecode5)) {
28791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
28792 }
28793 arg5 = static_cast< int >(val5);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_Py_Void();
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj = 0;
28809 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28810 wxRect *arg2 = 0 ;
28811 void *argp1 = 0 ;
28812 int res1 = 0 ;
28813 wxRect temp2 ;
28814 PyObject * obj0 = 0 ;
28815 PyObject * obj1 = 0 ;
28816 char * kwnames[] = {
28817 (char *) "self",(char *) "rect", NULL
28818 };
28819
28820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
28821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28822 if (!SWIG_IsOK(res1)) {
28823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28824 }
28825 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28826 {
28827 arg2 = &temp2;
28828 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28829 }
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 (arg1)->DrawRectangle((wxRect const &)*arg2);
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_Py_Void();
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28846 wxPoint *arg2 = 0 ;
28847 wxSize *arg3 = 0 ;
28848 void *argp1 = 0 ;
28849 int res1 = 0 ;
28850 wxPoint temp2 ;
28851 wxSize temp3 ;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 PyObject * obj2 = 0 ;
28855 char * kwnames[] = {
28856 (char *) "self",(char *) "pt",(char *) "sz", NULL
28857 };
28858
28859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28861 if (!SWIG_IsOK(res1)) {
28862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28863 }
28864 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28865 {
28866 arg2 = &temp2;
28867 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28868 }
28869 {
28870 arg3 = &temp3;
28871 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_Py_Void();
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj = 0;
28888 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28889 int arg2 ;
28890 int arg3 ;
28891 int arg4 ;
28892 int arg5 ;
28893 double arg6 ;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 int val2 ;
28897 int ecode2 = 0 ;
28898 int val3 ;
28899 int ecode3 = 0 ;
28900 int val4 ;
28901 int ecode4 = 0 ;
28902 int val5 ;
28903 int ecode5 = 0 ;
28904 double val6 ;
28905 int ecode6 = 0 ;
28906 PyObject * obj0 = 0 ;
28907 PyObject * obj1 = 0 ;
28908 PyObject * obj2 = 0 ;
28909 PyObject * obj3 = 0 ;
28910 PyObject * obj4 = 0 ;
28911 PyObject * obj5 = 0 ;
28912 char * kwnames[] = {
28913 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
28914 };
28915
28916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:PseudoDC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
28917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28918 if (!SWIG_IsOK(res1)) {
28919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28920 }
28921 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28922 ecode2 = SWIG_AsVal_int(obj1, &val2);
28923 if (!SWIG_IsOK(ecode2)) {
28924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
28925 }
28926 arg2 = static_cast< int >(val2);
28927 ecode3 = SWIG_AsVal_int(obj2, &val3);
28928 if (!SWIG_IsOK(ecode3)) {
28929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
28930 }
28931 arg3 = static_cast< int >(val3);
28932 ecode4 = SWIG_AsVal_int(obj3, &val4);
28933 if (!SWIG_IsOK(ecode4)) {
28934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
28935 }
28936 arg4 = static_cast< int >(val4);
28937 ecode5 = SWIG_AsVal_int(obj4, &val5);
28938 if (!SWIG_IsOK(ecode5)) {
28939 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
28940 }
28941 arg5 = static_cast< int >(val5);
28942 ecode6 = SWIG_AsVal_double(obj5, &val6);
28943 if (!SWIG_IsOK(ecode6)) {
28944 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
28945 }
28946 arg6 = static_cast< double >(val6);
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 resultobj = SWIG_Py_Void();
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28961 PyObject *resultobj = 0;
28962 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28963 wxRect *arg2 = 0 ;
28964 double arg3 ;
28965 void *argp1 = 0 ;
28966 int res1 = 0 ;
28967 wxRect temp2 ;
28968 double val3 ;
28969 int ecode3 = 0 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 PyObject * obj2 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "self",(char *) "r",(char *) "radius", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28981 }
28982 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28983 {
28984 arg2 = &temp2;
28985 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28986 }
28987 ecode3 = SWIG_AsVal_double(obj2, &val3);
28988 if (!SWIG_IsOK(ecode3)) {
28989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
28990 }
28991 arg3 = static_cast< double >(val3);
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_Py_Void();
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj = 0;
29007 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29008 wxPoint *arg2 = 0 ;
29009 wxSize *arg3 = 0 ;
29010 double arg4 ;
29011 void *argp1 = 0 ;
29012 int res1 = 0 ;
29013 wxPoint temp2 ;
29014 wxSize temp3 ;
29015 double val4 ;
29016 int ecode4 = 0 ;
29017 PyObject * obj0 = 0 ;
29018 PyObject * obj1 = 0 ;
29019 PyObject * obj2 = 0 ;
29020 PyObject * obj3 = 0 ;
29021 char * kwnames[] = {
29022 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
29023 };
29024
29025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29027 if (!SWIG_IsOK(res1)) {
29028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29029 }
29030 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29031 {
29032 arg2 = &temp2;
29033 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29034 }
29035 {
29036 arg3 = &temp3;
29037 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29038 }
29039 ecode4 = SWIG_AsVal_double(obj3, &val4);
29040 if (!SWIG_IsOK(ecode4)) {
29041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
29042 }
29043 arg4 = static_cast< double >(val4);
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 resultobj = SWIG_Py_Void();
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj = 0;
29059 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29060 int arg2 ;
29061 int arg3 ;
29062 int arg4 ;
29063 void *argp1 = 0 ;
29064 int res1 = 0 ;
29065 int val2 ;
29066 int ecode2 = 0 ;
29067 int val3 ;
29068 int ecode3 = 0 ;
29069 int val4 ;
29070 int ecode4 = 0 ;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 PyObject * obj2 = 0 ;
29074 PyObject * obj3 = 0 ;
29075 char * kwnames[] = {
29076 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
29077 };
29078
29079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCircle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29083 }
29084 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29085 ecode2 = SWIG_AsVal_int(obj1, &val2);
29086 if (!SWIG_IsOK(ecode2)) {
29087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
29088 }
29089 arg2 = static_cast< int >(val2);
29090 ecode3 = SWIG_AsVal_int(obj2, &val3);
29091 if (!SWIG_IsOK(ecode3)) {
29092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
29093 }
29094 arg3 = static_cast< int >(val3);
29095 ecode4 = SWIG_AsVal_int(obj3, &val4);
29096 if (!SWIG_IsOK(ecode4)) {
29097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
29098 }
29099 arg4 = static_cast< int >(val4);
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 (arg1)->DrawCircle(arg2,arg3,arg4);
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 resultobj = SWIG_Py_Void();
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29114 PyObject *resultobj = 0;
29115 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29116 wxPoint *arg2 = 0 ;
29117 int arg3 ;
29118 void *argp1 = 0 ;
29119 int res1 = 0 ;
29120 wxPoint temp2 ;
29121 int val3 ;
29122 int ecode3 = 0 ;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 PyObject * obj2 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "self",(char *) "pt",(char *) "radius", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29132 if (!SWIG_IsOK(res1)) {
29133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29134 }
29135 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29136 {
29137 arg2 = &temp2;
29138 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29139 }
29140 ecode3 = SWIG_AsVal_int(obj2, &val3);
29141 if (!SWIG_IsOK(ecode3)) {
29142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
29143 }
29144 arg3 = static_cast< int >(val3);
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 resultobj = SWIG_Py_Void();
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj = 0;
29160 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29161 int arg2 ;
29162 int arg3 ;
29163 int arg4 ;
29164 int arg5 ;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 int val2 ;
29168 int ecode2 = 0 ;
29169 int val3 ;
29170 int ecode3 = 0 ;
29171 int val4 ;
29172 int ecode4 = 0 ;
29173 int val5 ;
29174 int ecode5 = 0 ;
29175 PyObject * obj0 = 0 ;
29176 PyObject * obj1 = 0 ;
29177 PyObject * obj2 = 0 ;
29178 PyObject * obj3 = 0 ;
29179 PyObject * obj4 = 0 ;
29180 char * kwnames[] = {
29181 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
29182 };
29183
29184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29186 if (!SWIG_IsOK(res1)) {
29187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29188 }
29189 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29190 ecode2 = SWIG_AsVal_int(obj1, &val2);
29191 if (!SWIG_IsOK(ecode2)) {
29192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
29193 }
29194 arg2 = static_cast< int >(val2);
29195 ecode3 = SWIG_AsVal_int(obj2, &val3);
29196 if (!SWIG_IsOK(ecode3)) {
29197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
29198 }
29199 arg3 = static_cast< int >(val3);
29200 ecode4 = SWIG_AsVal_int(obj3, &val4);
29201 if (!SWIG_IsOK(ecode4)) {
29202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
29203 }
29204 arg4 = static_cast< int >(val4);
29205 ecode5 = SWIG_AsVal_int(obj4, &val5);
29206 if (!SWIG_IsOK(ecode5)) {
29207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
29208 }
29209 arg5 = static_cast< int >(val5);
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_Py_Void();
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj = 0;
29225 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29226 wxRect *arg2 = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 wxRect temp2 ;
29230 PyObject * obj0 = 0 ;
29231 PyObject * obj1 = 0 ;
29232 char * kwnames[] = {
29233 (char *) "self",(char *) "rect", NULL
29234 };
29235
29236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
29237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29238 if (!SWIG_IsOK(res1)) {
29239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29240 }
29241 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29242 {
29243 arg2 = &temp2;
29244 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29245 }
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 (arg1)->DrawEllipse((wxRect const &)*arg2);
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_Py_Void();
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj = 0;
29261 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29262 wxPoint *arg2 = 0 ;
29263 wxSize *arg3 = 0 ;
29264 void *argp1 = 0 ;
29265 int res1 = 0 ;
29266 wxPoint temp2 ;
29267 wxSize temp3 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 PyObject * obj2 = 0 ;
29271 char * kwnames[] = {
29272 (char *) "self",(char *) "pt",(char *) "sz", NULL
29273 };
29274
29275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29277 if (!SWIG_IsOK(res1)) {
29278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29279 }
29280 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29281 {
29282 arg2 = &temp2;
29283 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29284 }
29285 {
29286 arg3 = &temp3;
29287 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29288 }
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 resultobj = SWIG_Py_Void();
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj = 0;
29304 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29305 wxIcon *arg2 = 0 ;
29306 int arg3 ;
29307 int arg4 ;
29308 void *argp1 = 0 ;
29309 int res1 = 0 ;
29310 void *argp2 = 0 ;
29311 int res2 = 0 ;
29312 int val3 ;
29313 int ecode3 = 0 ;
29314 int val4 ;
29315 int ecode4 = 0 ;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 PyObject * obj2 = 0 ;
29319 PyObject * obj3 = 0 ;
29320 char * kwnames[] = {
29321 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
29322 };
29323
29324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIcon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29328 }
29329 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29330 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
29331 if (!SWIG_IsOK(res2)) {
29332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
29333 }
29334 if (!argp2) {
29335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
29336 }
29337 arg2 = reinterpret_cast< wxIcon * >(argp2);
29338 ecode3 = SWIG_AsVal_int(obj2, &val3);
29339 if (!SWIG_IsOK(ecode3)) {
29340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
29341 }
29342 arg3 = static_cast< int >(val3);
29343 ecode4 = SWIG_AsVal_int(obj3, &val4);
29344 if (!SWIG_IsOK(ecode4)) {
29345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
29346 }
29347 arg4 = static_cast< int >(val4);
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 resultobj = SWIG_Py_Void();
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29362 PyObject *resultobj = 0;
29363 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29364 wxIcon *arg2 = 0 ;
29365 wxPoint *arg3 = 0 ;
29366 void *argp1 = 0 ;
29367 int res1 = 0 ;
29368 void *argp2 = 0 ;
29369 int res2 = 0 ;
29370 wxPoint temp3 ;
29371 PyObject * obj0 = 0 ;
29372 PyObject * obj1 = 0 ;
29373 PyObject * obj2 = 0 ;
29374 char * kwnames[] = {
29375 (char *) "self",(char *) "icon",(char *) "pt", NULL
29376 };
29377
29378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29380 if (!SWIG_IsOK(res1)) {
29381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29382 }
29383 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
29385 if (!SWIG_IsOK(res2)) {
29386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
29387 }
29388 if (!argp2) {
29389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
29390 }
29391 arg2 = reinterpret_cast< wxIcon * >(argp2);
29392 {
29393 arg3 = &temp3;
29394 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29395 }
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_Py_Void();
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj = 0;
29411 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29412 wxBitmap *arg2 = 0 ;
29413 int arg3 ;
29414 int arg4 ;
29415 bool arg5 = (bool) false ;
29416 void *argp1 = 0 ;
29417 int res1 = 0 ;
29418 void *argp2 = 0 ;
29419 int res2 = 0 ;
29420 int val3 ;
29421 int ecode3 = 0 ;
29422 int val4 ;
29423 int ecode4 = 0 ;
29424 bool val5 ;
29425 int ecode5 = 0 ;
29426 PyObject * obj0 = 0 ;
29427 PyObject * obj1 = 0 ;
29428 PyObject * obj2 = 0 ;
29429 PyObject * obj3 = 0 ;
29430 PyObject * obj4 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29439 }
29440 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29441 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
29442 if (!SWIG_IsOK(res2)) {
29443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29444 }
29445 if (!argp2) {
29446 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29447 }
29448 arg2 = reinterpret_cast< wxBitmap * >(argp2);
29449 ecode3 = SWIG_AsVal_int(obj2, &val3);
29450 if (!SWIG_IsOK(ecode3)) {
29451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
29452 }
29453 arg3 = static_cast< int >(val3);
29454 ecode4 = SWIG_AsVal_int(obj3, &val4);
29455 if (!SWIG_IsOK(ecode4)) {
29456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
29457 }
29458 arg4 = static_cast< int >(val4);
29459 if (obj4) {
29460 ecode5 = SWIG_AsVal_bool(obj4, &val5);
29461 if (!SWIG_IsOK(ecode5)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
29463 }
29464 arg5 = static_cast< bool >(val5);
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_Py_Void();
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29480 PyObject *resultobj = 0;
29481 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29482 wxBitmap *arg2 = 0 ;
29483 wxPoint *arg3 = 0 ;
29484 bool arg4 = (bool) false ;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 void *argp2 = 0 ;
29488 int res2 = 0 ;
29489 wxPoint temp3 ;
29490 bool val4 ;
29491 int ecode4 = 0 ;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 PyObject * obj2 = 0 ;
29495 PyObject * obj3 = 0 ;
29496 char * kwnames[] = {
29497 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
29498 };
29499
29500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29502 if (!SWIG_IsOK(res1)) {
29503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29504 }
29505 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29506 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
29507 if (!SWIG_IsOK(res2)) {
29508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29509 }
29510 if (!argp2) {
29511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
29512 }
29513 arg2 = reinterpret_cast< wxBitmap * >(argp2);
29514 {
29515 arg3 = &temp3;
29516 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29517 }
29518 if (obj3) {
29519 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29520 if (!SWIG_IsOK(ecode4)) {
29521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
29522 }
29523 arg4 = static_cast< bool >(val4);
29524 }
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 resultobj = SWIG_Py_Void();
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_PseudoDC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29539 PyObject *resultobj = 0;
29540 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29541 wxString *arg2 = 0 ;
29542 int arg3 ;
29543 int arg4 ;
29544 void *argp1 = 0 ;
29545 int res1 = 0 ;
29546 bool temp2 = false ;
29547 int val3 ;
29548 int ecode3 = 0 ;
29549 int val4 ;
29550 int ecode4 = 0 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 PyObject * obj2 = 0 ;
29554 PyObject * obj3 = 0 ;
29555 char * kwnames[] = {
29556 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
29557 };
29558
29559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29561 if (!SWIG_IsOK(res1)) {
29562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29563 }
29564 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29565 {
29566 arg2 = wxString_in_helper(obj1);
29567 if (arg2 == NULL) SWIG_fail;
29568 temp2 = true;
29569 }
29570 ecode3 = SWIG_AsVal_int(obj2, &val3);
29571 if (!SWIG_IsOK(ecode3)) {
29572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawText" "', expected argument " "3"" of type '" "int""'");
29573 }
29574 arg3 = static_cast< int >(val3);
29575 ecode4 = SWIG_AsVal_int(obj3, &val4);
29576 if (!SWIG_IsOK(ecode4)) {
29577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawText" "', expected argument " "4"" of type '" "int""'");
29578 }
29579 arg4 = static_cast< int >(val4);
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 resultobj = SWIG_Py_Void();
29587 {
29588 if (temp2)
29589 delete arg2;
29590 }
29591 return resultobj;
29592 fail:
29593 {
29594 if (temp2)
29595 delete arg2;
29596 }
29597 return NULL;
29598 }
29599
29600
29601 SWIGINTERN PyObject *_wrap_PseudoDC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29602 PyObject *resultobj = 0;
29603 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29604 wxString *arg2 = 0 ;
29605 wxPoint *arg3 = 0 ;
29606 void *argp1 = 0 ;
29607 int res1 = 0 ;
29608 bool temp2 = false ;
29609 wxPoint temp3 ;
29610 PyObject * obj0 = 0 ;
29611 PyObject * obj1 = 0 ;
29612 PyObject * obj2 = 0 ;
29613 char * kwnames[] = {
29614 (char *) "self",(char *) "text",(char *) "pt", NULL
29615 };
29616
29617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29619 if (!SWIG_IsOK(res1)) {
29620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29621 }
29622 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29623 {
29624 arg2 = wxString_in_helper(obj1);
29625 if (arg2 == NULL) SWIG_fail;
29626 temp2 = true;
29627 }
29628 {
29629 arg3 = &temp3;
29630 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29631 }
29632 {
29633 PyThreadState* __tstate = wxPyBeginAllowThreads();
29634 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 resultobj = SWIG_Py_Void();
29639 {
29640 if (temp2)
29641 delete arg2;
29642 }
29643 return resultobj;
29644 fail:
29645 {
29646 if (temp2)
29647 delete arg2;
29648 }
29649 return NULL;
29650 }
29651
29652
29653 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29654 PyObject *resultobj = 0;
29655 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29656 wxString *arg2 = 0 ;
29657 int arg3 ;
29658 int arg4 ;
29659 double arg5 ;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 bool temp2 = false ;
29663 int val3 ;
29664 int ecode3 = 0 ;
29665 int val4 ;
29666 int ecode4 = 0 ;
29667 double val5 ;
29668 int ecode5 = 0 ;
29669 PyObject * obj0 = 0 ;
29670 PyObject * obj1 = 0 ;
29671 PyObject * obj2 = 0 ;
29672 PyObject * obj3 = 0 ;
29673 PyObject * obj4 = 0 ;
29674 char * kwnames[] = {
29675 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
29676 };
29677
29678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29680 if (!SWIG_IsOK(res1)) {
29681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29682 }
29683 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29684 {
29685 arg2 = wxString_in_helper(obj1);
29686 if (arg2 == NULL) SWIG_fail;
29687 temp2 = true;
29688 }
29689 ecode3 = SWIG_AsVal_int(obj2, &val3);
29690 if (!SWIG_IsOK(ecode3)) {
29691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
29692 }
29693 arg3 = static_cast< int >(val3);
29694 ecode4 = SWIG_AsVal_int(obj3, &val4);
29695 if (!SWIG_IsOK(ecode4)) {
29696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
29697 }
29698 arg4 = static_cast< int >(val4);
29699 ecode5 = SWIG_AsVal_double(obj4, &val5);
29700 if (!SWIG_IsOK(ecode5)) {
29701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
29702 }
29703 arg5 = static_cast< double >(val5);
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 resultobj = SWIG_Py_Void();
29711 {
29712 if (temp2)
29713 delete arg2;
29714 }
29715 return resultobj;
29716 fail:
29717 {
29718 if (temp2)
29719 delete arg2;
29720 }
29721 return NULL;
29722 }
29723
29724
29725 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj = 0;
29727 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29728 wxString *arg2 = 0 ;
29729 wxPoint *arg3 = 0 ;
29730 double arg4 ;
29731 void *argp1 = 0 ;
29732 int res1 = 0 ;
29733 bool temp2 = false ;
29734 wxPoint temp3 ;
29735 double val4 ;
29736 int ecode4 = 0 ;
29737 PyObject * obj0 = 0 ;
29738 PyObject * obj1 = 0 ;
29739 PyObject * obj2 = 0 ;
29740 PyObject * obj3 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29747 if (!SWIG_IsOK(res1)) {
29748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29749 }
29750 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29751 {
29752 arg2 = wxString_in_helper(obj1);
29753 if (arg2 == NULL) SWIG_fail;
29754 temp2 = true;
29755 }
29756 {
29757 arg3 = &temp3;
29758 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29759 }
29760 ecode4 = SWIG_AsVal_double(obj3, &val4);
29761 if (!SWIG_IsOK(ecode4)) {
29762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
29763 }
29764 arg4 = static_cast< double >(val4);
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
29768 wxPyEndAllowThreads(__tstate);
29769 if (PyErr_Occurred()) SWIG_fail;
29770 }
29771 resultobj = SWIG_Py_Void();
29772 {
29773 if (temp2)
29774 delete arg2;
29775 }
29776 return resultobj;
29777 fail:
29778 {
29779 if (temp2)
29780 delete arg2;
29781 }
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj = 0;
29788 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29789 int arg2 ;
29790 wxPoint *arg3 = (wxPoint *) 0 ;
29791 int arg4 = (int) 0 ;
29792 int arg5 = (int) 0 ;
29793 void *argp1 = 0 ;
29794 int res1 = 0 ;
29795 int val4 ;
29796 int ecode4 = 0 ;
29797 int val5 ;
29798 int ecode5 = 0 ;
29799 PyObject * obj0 = 0 ;
29800 PyObject * obj1 = 0 ;
29801 PyObject * obj2 = 0 ;
29802 PyObject * obj3 = 0 ;
29803 char * kwnames[] = {
29804 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
29805 };
29806
29807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:PseudoDC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29809 if (!SWIG_IsOK(res1)) {
29810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLines" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29811 }
29812 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29813 {
29814 arg3 = wxPoint_LIST_helper(obj1, &arg2);
29815 if (arg3 == NULL) SWIG_fail;
29816 }
29817 if (obj2) {
29818 ecode4 = SWIG_AsVal_int(obj2, &val4);
29819 if (!SWIG_IsOK(ecode4)) {
29820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLines" "', expected argument " "4"" of type '" "int""'");
29821 }
29822 arg4 = static_cast< int >(val4);
29823 }
29824 if (obj3) {
29825 ecode5 = SWIG_AsVal_int(obj3, &val5);
29826 if (!SWIG_IsOK(ecode5)) {
29827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLines" "', expected argument " "5"" of type '" "int""'");
29828 }
29829 arg5 = static_cast< int >(val5);
29830 }
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 resultobj = SWIG_Py_Void();
29838 {
29839 if (arg3) delete [] arg3;
29840 }
29841 return resultobj;
29842 fail:
29843 {
29844 if (arg3) delete [] arg3;
29845 }
29846 return NULL;
29847 }
29848
29849
29850 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj = 0;
29852 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29853 int arg2 ;
29854 wxPoint *arg3 = (wxPoint *) 0 ;
29855 int arg4 = (int) 0 ;
29856 int arg5 = (int) 0 ;
29857 int arg6 = (int) wxODDEVEN_RULE ;
29858 void *argp1 = 0 ;
29859 int res1 = 0 ;
29860 int val4 ;
29861 int ecode4 = 0 ;
29862 int val5 ;
29863 int ecode5 = 0 ;
29864 int val6 ;
29865 int ecode6 = 0 ;
29866 PyObject * obj0 = 0 ;
29867 PyObject * obj1 = 0 ;
29868 PyObject * obj2 = 0 ;
29869 PyObject * obj3 = 0 ;
29870 PyObject * obj4 = 0 ;
29871 char * kwnames[] = {
29872 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
29873 };
29874
29875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:PseudoDC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29877 if (!SWIG_IsOK(res1)) {
29878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29879 }
29880 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29881 {
29882 arg3 = wxPoint_LIST_helper(obj1, &arg2);
29883 if (arg3 == NULL) SWIG_fail;
29884 }
29885 if (obj2) {
29886 ecode4 = SWIG_AsVal_int(obj2, &val4);
29887 if (!SWIG_IsOK(ecode4)) {
29888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
29889 }
29890 arg4 = static_cast< int >(val4);
29891 }
29892 if (obj3) {
29893 ecode5 = SWIG_AsVal_int(obj3, &val5);
29894 if (!SWIG_IsOK(ecode5)) {
29895 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
29896 }
29897 arg5 = static_cast< int >(val5);
29898 }
29899 if (obj4) {
29900 ecode6 = SWIG_AsVal_int(obj4, &val6);
29901 if (!SWIG_IsOK(ecode6)) {
29902 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
29903 }
29904 arg6 = static_cast< int >(val6);
29905 }
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 resultobj = SWIG_Py_Void();
29913 {
29914 if (arg3) delete [] arg3;
29915 }
29916 return resultobj;
29917 fail:
29918 {
29919 if (arg3) delete [] arg3;
29920 }
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29928 wxString *arg2 = 0 ;
29929 wxRect *arg3 = 0 ;
29930 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
29931 int arg5 = (int) -1 ;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 bool temp2 = false ;
29935 wxRect temp3 ;
29936 int val4 ;
29937 int ecode4 = 0 ;
29938 int val5 ;
29939 int ecode5 = 0 ;
29940 PyObject * obj0 = 0 ;
29941 PyObject * obj1 = 0 ;
29942 PyObject * obj2 = 0 ;
29943 PyObject * obj3 = 0 ;
29944 PyObject * obj4 = 0 ;
29945 char * kwnames[] = {
29946 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
29947 };
29948
29949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:PseudoDC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29951 if (!SWIG_IsOK(res1)) {
29952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29953 }
29954 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29955 {
29956 arg2 = wxString_in_helper(obj1);
29957 if (arg2 == NULL) SWIG_fail;
29958 temp2 = true;
29959 }
29960 {
29961 arg3 = &temp3;
29962 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
29963 }
29964 if (obj3) {
29965 ecode4 = SWIG_AsVal_int(obj3, &val4);
29966 if (!SWIG_IsOK(ecode4)) {
29967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
29968 }
29969 arg4 = static_cast< int >(val4);
29970 }
29971 if (obj4) {
29972 ecode5 = SWIG_AsVal_int(obj4, &val5);
29973 if (!SWIG_IsOK(ecode5)) {
29974 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
29975 }
29976 arg5 = static_cast< int >(val5);
29977 }
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 resultobj = SWIG_Py_Void();
29985 {
29986 if (temp2)
29987 delete arg2;
29988 }
29989 return resultobj;
29990 fail:
29991 {
29992 if (temp2)
29993 delete arg2;
29994 }
29995 return NULL;
29996 }
29997
29998
29999 SWIGINTERN PyObject *_wrap_PseudoDC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj = 0;
30001 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30002 wxString *arg2 = 0 ;
30003 wxBitmap *arg3 = 0 ;
30004 wxRect *arg4 = 0 ;
30005 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
30006 int arg6 = (int) -1 ;
30007 void *argp1 = 0 ;
30008 int res1 = 0 ;
30009 bool temp2 = false ;
30010 void *argp3 = 0 ;
30011 int res3 = 0 ;
30012 wxRect temp4 ;
30013 int val5 ;
30014 int ecode5 = 0 ;
30015 int val6 ;
30016 int ecode6 = 0 ;
30017 PyObject * obj0 = 0 ;
30018 PyObject * obj1 = 0 ;
30019 PyObject * obj2 = 0 ;
30020 PyObject * obj3 = 0 ;
30021 PyObject * obj4 = 0 ;
30022 PyObject * obj5 = 0 ;
30023 char * kwnames[] = {
30024 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
30025 };
30026
30027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:PseudoDC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30029 if (!SWIG_IsOK(res1)) {
30030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30031 }
30032 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30033 {
30034 arg2 = wxString_in_helper(obj1);
30035 if (arg2 == NULL) SWIG_fail;
30036 temp2 = true;
30037 }
30038 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
30039 if (!SWIG_IsOK(res3)) {
30040 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30041 }
30042 if (!argp3) {
30043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30044 }
30045 arg3 = reinterpret_cast< wxBitmap * >(argp3);
30046 {
30047 arg4 = &temp4;
30048 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
30049 }
30050 if (obj4) {
30051 ecode5 = SWIG_AsVal_int(obj4, &val5);
30052 if (!SWIG_IsOK(ecode5)) {
30053 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
30054 }
30055 arg5 = static_cast< int >(val5);
30056 }
30057 if (obj5) {
30058 ecode6 = SWIG_AsVal_int(obj5, &val6);
30059 if (!SWIG_IsOK(ecode6)) {
30060 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
30061 }
30062 arg6 = static_cast< int >(val6);
30063 }
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 (arg1)->DrawLabel((wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 resultobj = SWIG_Py_Void();
30071 {
30072 if (temp2)
30073 delete arg2;
30074 }
30075 return resultobj;
30076 fail:
30077 {
30078 if (temp2)
30079 delete arg2;
30080 }
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_PseudoDC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30086 PyObject *resultobj = 0;
30087 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30088 int arg2 ;
30089 wxPoint *arg3 = (wxPoint *) 0 ;
30090 void *argp1 = 0 ;
30091 int res1 = 0 ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 char * kwnames[] = {
30095 (char *) "self",(char *) "points", NULL
30096 };
30097
30098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
30099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30100 if (!SWIG_IsOK(res1)) {
30101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawSpline" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30102 }
30103 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30104 {
30105 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30106 if (arg3 == NULL) SWIG_fail;
30107 }
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 (arg1)->DrawSpline(arg2,arg3);
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 resultobj = SWIG_Py_Void();
30115 {
30116 if (arg3) delete [] arg3;
30117 }
30118 return resultobj;
30119 fail:
30120 {
30121 if (arg3) delete [] arg3;
30122 }
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_PseudoDC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 PyObject *swig_obj[1] ;
30133
30134 if (!args) SWIG_fail;
30135 swig_obj[0] = args;
30136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30137 if (!SWIG_IsOK(res1)) {
30138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_Clear" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30139 }
30140 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 (arg1)->Clear();
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 resultobj = SWIG_Py_Void();
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 SWIGINTERN PyObject *_wrap_PseudoDC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30155 PyObject *resultobj = 0;
30156 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30157 wxFont *arg2 = 0 ;
30158 void *argp1 = 0 ;
30159 int res1 = 0 ;
30160 void *argp2 = 0 ;
30161 int res2 = 0 ;
30162 PyObject * obj0 = 0 ;
30163 PyObject * obj1 = 0 ;
30164 char * kwnames[] = {
30165 (char *) "self",(char *) "font", NULL
30166 };
30167
30168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
30169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30170 if (!SWIG_IsOK(res1)) {
30171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetFont" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30172 }
30173 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
30175 if (!SWIG_IsOK(res2)) {
30176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
30177 }
30178 if (!argp2) {
30179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
30180 }
30181 arg2 = reinterpret_cast< wxFont * >(argp2);
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 (arg1)->SetFont((wxFont const &)*arg2);
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 resultobj = SWIG_Py_Void();
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_PseudoDC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30198 wxPen *arg2 = 0 ;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 void *argp2 = 0 ;
30202 int res2 = 0 ;
30203 PyObject * obj0 = 0 ;
30204 PyObject * obj1 = 0 ;
30205 char * kwnames[] = {
30206 (char *) "self",(char *) "pen", NULL
30207 };
30208
30209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
30210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30211 if (!SWIG_IsOK(res1)) {
30212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30213 }
30214 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
30216 if (!SWIG_IsOK(res2)) {
30217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
30218 }
30219 if (!argp2) {
30220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
30221 }
30222 arg2 = reinterpret_cast< wxPen * >(argp2);
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 (arg1)->SetPen((wxPen const &)*arg2);
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 resultobj = SWIG_Py_Void();
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 SWIGINTERN PyObject *_wrap_PseudoDC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = 0;
30238 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30239 wxBrush *arg2 = 0 ;
30240 void *argp1 = 0 ;
30241 int res1 = 0 ;
30242 void *argp2 = 0 ;
30243 int res2 = 0 ;
30244 PyObject * obj0 = 0 ;
30245 PyObject * obj1 = 0 ;
30246 char * kwnames[] = {
30247 (char *) "self",(char *) "brush", NULL
30248 };
30249
30250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
30251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30252 if (!SWIG_IsOK(res1)) {
30253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBrush" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30254 }
30255 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30256 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
30257 if (!SWIG_IsOK(res2)) {
30258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
30259 }
30260 if (!argp2) {
30261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
30262 }
30263 arg2 = reinterpret_cast< wxBrush * >(argp2);
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 (arg1)->SetBrush((wxBrush const &)*arg2);
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 resultobj = SWIG_Py_Void();
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = 0;
30279 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30280 wxBrush *arg2 = 0 ;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 void *argp2 = 0 ;
30284 int res2 = 0 ;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 char * kwnames[] = {
30288 (char *) "self",(char *) "brush", NULL
30289 };
30290
30291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
30292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30293 if (!SWIG_IsOK(res1)) {
30294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30295 }
30296 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
30298 if (!SWIG_IsOK(res2)) {
30299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
30300 }
30301 if (!argp2) {
30302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
30303 }
30304 arg2 = reinterpret_cast< wxBrush * >(argp2);
30305 {
30306 PyThreadState* __tstate = wxPyBeginAllowThreads();
30307 (arg1)->SetBackground((wxBrush const &)*arg2);
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 resultobj = SWIG_Py_Void();
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj = 0;
30320 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30321 int arg2 ;
30322 void *argp1 = 0 ;
30323 int res1 = 0 ;
30324 int val2 ;
30325 int ecode2 = 0 ;
30326 PyObject * obj0 = 0 ;
30327 PyObject * obj1 = 0 ;
30328 char * kwnames[] = {
30329 (char *) "self",(char *) "mode", NULL
30330 };
30331
30332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
30333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30334 if (!SWIG_IsOK(res1)) {
30335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30336 }
30337 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30338 ecode2 = SWIG_AsVal_int(obj1, &val2);
30339 if (!SWIG_IsOK(ecode2)) {
30340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
30341 }
30342 arg2 = static_cast< int >(val2);
30343 {
30344 PyThreadState* __tstate = wxPyBeginAllowThreads();
30345 (arg1)->SetBackgroundMode(arg2);
30346 wxPyEndAllowThreads(__tstate);
30347 if (PyErr_Occurred()) SWIG_fail;
30348 }
30349 resultobj = SWIG_Py_Void();
30350 return resultobj;
30351 fail:
30352 return NULL;
30353 }
30354
30355
30356 SWIGINTERN PyObject *_wrap_PseudoDC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30357 PyObject *resultobj = 0;
30358 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30359 wxPalette *arg2 = 0 ;
30360 void *argp1 = 0 ;
30361 int res1 = 0 ;
30362 void *argp2 = 0 ;
30363 int res2 = 0 ;
30364 PyObject * obj0 = 0 ;
30365 PyObject * obj1 = 0 ;
30366 char * kwnames[] = {
30367 (char *) "self",(char *) "palette", NULL
30368 };
30369
30370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
30371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30372 if (!SWIG_IsOK(res1)) {
30373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPalette" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30374 }
30375 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
30377 if (!SWIG_IsOK(res2)) {
30378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
30379 }
30380 if (!argp2) {
30381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
30382 }
30383 arg2 = reinterpret_cast< wxPalette * >(argp2);
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 (arg1)->SetPalette((wxPalette const &)*arg2);
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 resultobj = SWIG_Py_Void();
30391 return resultobj;
30392 fail:
30393 return NULL;
30394 }
30395
30396
30397 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30398 PyObject *resultobj = 0;
30399 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30400 wxColour *arg2 = 0 ;
30401 void *argp1 = 0 ;
30402 int res1 = 0 ;
30403 wxColour temp2 ;
30404 PyObject * obj0 = 0 ;
30405 PyObject * obj1 = 0 ;
30406 char * kwnames[] = {
30407 (char *) "self",(char *) "colour", NULL
30408 };
30409
30410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
30411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextForeground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30414 }
30415 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30416 {
30417 arg2 = &temp2;
30418 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30419 }
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 (arg1)->SetTextForeground((wxColour const &)*arg2);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_Py_Void();
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj = 0;
30435 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30436 wxColour *arg2 = 0 ;
30437 void *argp1 = 0 ;
30438 int res1 = 0 ;
30439 wxColour temp2 ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 char * kwnames[] = {
30443 (char *) "self",(char *) "colour", NULL
30444 };
30445
30446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
30447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30448 if (!SWIG_IsOK(res1)) {
30449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30450 }
30451 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30452 {
30453 arg2 = &temp2;
30454 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetTextBackground((wxColour const &)*arg2);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_Py_Void();
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_PseudoDC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30470 PyObject *resultobj = 0;
30471 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30472 int arg2 ;
30473 void *argp1 = 0 ;
30474 int res1 = 0 ;
30475 int val2 ;
30476 int ecode2 = 0 ;
30477 PyObject * obj0 = 0 ;
30478 PyObject * obj1 = 0 ;
30479 char * kwnames[] = {
30480 (char *) "self",(char *) "function", NULL
30481 };
30482
30483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
30484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30485 if (!SWIG_IsOK(res1)) {
30486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30487 }
30488 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30489 ecode2 = SWIG_AsVal_int(obj1, &val2);
30490 if (!SWIG_IsOK(ecode2)) {
30491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
30492 }
30493 arg2 = static_cast< int >(val2);
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 (arg1)->SetLogicalFunction(arg2);
30497 wxPyEndAllowThreads(__tstate);
30498 if (PyErr_Occurred()) SWIG_fail;
30499 }
30500 resultobj = SWIG_Py_Void();
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *PseudoDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30508 PyObject *obj;
30509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPseudoDC, SWIG_NewClientData(obj));
30511 return SWIG_Py_Void();
30512 }
30513
30514 SWIGINTERN PyObject *PseudoDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30515 return SWIG_Python_InitShadowInstance(args);
30516 }
30517
30518 static PyMethodDef SwigMethods[] = {
30519 { (char *)"new_GDIObject", (PyCFunction)_wrap_new_GDIObject, METH_NOARGS, NULL},
30520 { (char *)"delete_GDIObject", (PyCFunction)_wrap_delete_GDIObject, METH_O, NULL},
30521 { (char *)"GDIObject_IsNull", (PyCFunction)_wrap_GDIObject_IsNull, METH_O, NULL},
30522 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
30523 { (char *)"GDIObject_swiginit", GDIObject_swiginit, METH_VARARGS, NULL},
30524 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
30525 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
30526 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30527 { (char *)"delete_Colour", (PyCFunction)_wrap_delete_Colour, METH_O, NULL},
30528 { (char *)"Colour_Red", (PyCFunction)_wrap_Colour_Red, METH_O, NULL},
30529 { (char *)"Colour_Green", (PyCFunction)_wrap_Colour_Green, METH_O, NULL},
30530 { (char *)"Colour_Blue", (PyCFunction)_wrap_Colour_Blue, METH_O, NULL},
30531 { (char *)"Colour_Alpha", (PyCFunction)_wrap_Colour_Alpha, METH_O, NULL},
30532 { (char *)"Colour_Ok", (PyCFunction)_wrap_Colour_Ok, METH_O, NULL},
30533 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30534 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30535 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
30536 { (char *)"Colour_GetAsString", (PyCFunction) _wrap_Colour_GetAsString, METH_VARARGS | METH_KEYWORDS, NULL},
30537 { (char *)"Colour_GetPixel", (PyCFunction)_wrap_Colour_GetPixel, METH_O, NULL},
30538 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30539 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30540 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
30541 { (char *)"Colour_GetRGB", (PyCFunction)_wrap_Colour_GetRGB, METH_O, NULL},
30542 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
30543 { (char *)"Colour_swiginit", Colour_swiginit, METH_VARARGS, NULL},
30544 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
30545 { (char *)"delete_Palette", (PyCFunction)_wrap_delete_Palette, METH_O, NULL},
30546 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
30547 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
30548 { (char *)"Palette_GetColoursCount", (PyCFunction)_wrap_Palette_GetColoursCount, METH_O, NULL},
30549 { (char *)"Palette_Ok", (PyCFunction)_wrap_Palette_Ok, METH_O, NULL},
30550 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
30551 { (char *)"Palette_swiginit", Palette_swiginit, METH_VARARGS, NULL},
30552 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
30553 { (char *)"delete_Pen", (PyCFunction)_wrap_delete_Pen, METH_O, NULL},
30554 { (char *)"Pen_GetCap", (PyCFunction)_wrap_Pen_GetCap, METH_O, NULL},
30555 { (char *)"Pen_GetColour", (PyCFunction)_wrap_Pen_GetColour, METH_O, NULL},
30556 { (char *)"Pen_GetJoin", (PyCFunction)_wrap_Pen_GetJoin, METH_O, NULL},
30557 { (char *)"Pen_GetStyle", (PyCFunction)_wrap_Pen_GetStyle, METH_O, NULL},
30558 { (char *)"Pen_GetWidth", (PyCFunction)_wrap_Pen_GetWidth, METH_O, NULL},
30559 { (char *)"Pen_Ok", (PyCFunction)_wrap_Pen_Ok, METH_O, NULL},
30560 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
30561 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30562 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
30563 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30564 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30565 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
30566 { (char *)"Pen_GetDashes", (PyCFunction)_wrap_Pen_GetDashes, METH_O, NULL},
30567 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
30568 { (char *)"Pen_GetDashCount", (PyCFunction)_wrap_Pen_GetDashCount, METH_O, NULL},
30569 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30570 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30571 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
30572 { (char *)"Pen_swiginit", Pen_swiginit, METH_VARARGS, NULL},
30573 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
30574 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30575 { (char *)"delete_Brush", (PyCFunction)_wrap_delete_Brush, METH_O, NULL},
30576 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30577 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30578 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
30579 { (char *)"Brush_GetColour", (PyCFunction)_wrap_Brush_GetColour, METH_O, NULL},
30580 { (char *)"Brush_GetStyle", (PyCFunction)_wrap_Brush_GetStyle, METH_O, NULL},
30581 { (char *)"Brush_GetStipple", (PyCFunction)_wrap_Brush_GetStipple, METH_O, NULL},
30582 { (char *)"Brush_IsHatch", (PyCFunction)_wrap_Brush_IsHatch, METH_O, NULL},
30583 { (char *)"Brush_Ok", (PyCFunction)_wrap_Brush_Ok, METH_O, NULL},
30584 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
30585 { (char *)"Brush_swiginit", Brush_swiginit, METH_VARARGS, NULL},
30586 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30587 { (char *)"delete_Bitmap", (PyCFunction)_wrap_delete_Bitmap, METH_O, NULL},
30588 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30589 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30590 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
30591 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
30592 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
30593 { (char *)"Bitmap_Ok", (PyCFunction)_wrap_Bitmap_Ok, METH_O, NULL},
30594 { (char *)"Bitmap_GetWidth", (PyCFunction)_wrap_Bitmap_GetWidth, METH_O, NULL},
30595 { (char *)"Bitmap_GetHeight", (PyCFunction)_wrap_Bitmap_GetHeight, METH_O, NULL},
30596 { (char *)"Bitmap_GetDepth", (PyCFunction)_wrap_Bitmap_GetDepth, METH_O, NULL},
30597 { (char *)"Bitmap_GetSize", (PyCFunction)_wrap_Bitmap_GetSize, METH_O, NULL},
30598 { (char *)"Bitmap_ConvertToImage", (PyCFunction)_wrap_Bitmap_ConvertToImage, METH_O, NULL},
30599 { (char *)"Bitmap_GetMask", (PyCFunction)_wrap_Bitmap_GetMask, METH_O, NULL},
30600 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
30601 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
30602 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30603 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
30604 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
30605 { (char *)"Bitmap_GetPalette", (PyCFunction)_wrap_Bitmap_GetPalette, METH_O, NULL},
30606 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30607 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
30608 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30609 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30610 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
30611 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30612 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30613 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
30614 { (char *)"Bitmap_swiginit", Bitmap_swiginit, METH_VARARGS, NULL},
30615 { (char *)"_BitmapFromBufferAlpha", (PyCFunction) _wrap__BitmapFromBufferAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
30616 { (char *)"_BitmapFromBuffer", (PyCFunction) _wrap__BitmapFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
30617 { (char *)"_BitmapFromBufferRGBA", (PyCFunction) _wrap__BitmapFromBufferRGBA, METH_VARARGS | METH_KEYWORDS, NULL},
30618 { (char *)"PixelDataBase_GetOrigin", (PyCFunction)_wrap_PixelDataBase_GetOrigin, METH_O, NULL},
30619 { (char *)"PixelDataBase_GetWidth", (PyCFunction)_wrap_PixelDataBase_GetWidth, METH_O, NULL},
30620 { (char *)"PixelDataBase_GetHeight", (PyCFunction)_wrap_PixelDataBase_GetHeight, METH_O, NULL},
30621 { (char *)"PixelDataBase_GetSize", (PyCFunction)_wrap_PixelDataBase_GetSize, METH_O, NULL},
30622 { (char *)"PixelDataBase_GetRowStride", (PyCFunction)_wrap_PixelDataBase_GetRowStride, METH_O, NULL},
30623 { (char *)"PixelDataBase_swigregister", PixelDataBase_swigregister, METH_VARARGS, NULL},
30624 { (char *)"new_NativePixelData", _wrap_new_NativePixelData, METH_VARARGS, NULL},
30625 { (char *)"delete_NativePixelData", (PyCFunction)_wrap_delete_NativePixelData, METH_O, NULL},
30626 { (char *)"NativePixelData_GetPixels", (PyCFunction)_wrap_NativePixelData_GetPixels, METH_O, NULL},
30627 { (char *)"NativePixelData_UseAlpha", (PyCFunction)_wrap_NativePixelData_UseAlpha, METH_O, NULL},
30628 { (char *)"NativePixelData___nonzero__", (PyCFunction)_wrap_NativePixelData___nonzero__, METH_O, NULL},
30629 { (char *)"NativePixelData_swigregister", NativePixelData_swigregister, METH_VARARGS, NULL},
30630 { (char *)"NativePixelData_swiginit", NativePixelData_swiginit, METH_VARARGS, NULL},
30631 { (char *)"new_NativePixelData_Accessor", _wrap_new_NativePixelData_Accessor, METH_VARARGS, NULL},
30632 { (char *)"delete_NativePixelData_Accessor", (PyCFunction)_wrap_delete_NativePixelData_Accessor, METH_O, NULL},
30633 { (char *)"NativePixelData_Accessor_Reset", (PyCFunction) _wrap_NativePixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
30634 { (char *)"NativePixelData_Accessor_IsOk", (PyCFunction)_wrap_NativePixelData_Accessor_IsOk, METH_O, NULL},
30635 { (char *)"NativePixelData_Accessor_nextPixel", (PyCFunction)_wrap_NativePixelData_Accessor_nextPixel, METH_O, NULL},
30636 { (char *)"NativePixelData_Accessor_Offset", (PyCFunction) _wrap_NativePixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30637 { (char *)"NativePixelData_Accessor_OffsetX", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
30638 { (char *)"NativePixelData_Accessor_OffsetY", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
30639 { (char *)"NativePixelData_Accessor_MoveTo", (PyCFunction) _wrap_NativePixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
30640 { (char *)"NativePixelData_Accessor_Set", (PyCFunction) _wrap_NativePixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30641 { (char *)"NativePixelData_Accessor_Get", (PyCFunction)_wrap_NativePixelData_Accessor_Get, METH_O, NULL},
30642 { (char *)"NativePixelData_Accessor_swigregister", NativePixelData_Accessor_swigregister, METH_VARARGS, NULL},
30643 { (char *)"NativePixelData_Accessor_swiginit", NativePixelData_Accessor_swiginit, METH_VARARGS, NULL},
30644 { (char *)"new_AlphaPixelData", _wrap_new_AlphaPixelData, METH_VARARGS, NULL},
30645 { (char *)"delete_AlphaPixelData", (PyCFunction)_wrap_delete_AlphaPixelData, METH_O, NULL},
30646 { (char *)"AlphaPixelData_GetPixels", (PyCFunction)_wrap_AlphaPixelData_GetPixels, METH_O, NULL},
30647 { (char *)"AlphaPixelData_UseAlpha", (PyCFunction)_wrap_AlphaPixelData_UseAlpha, METH_O, NULL},
30648 { (char *)"AlphaPixelData___nonzero__", (PyCFunction)_wrap_AlphaPixelData___nonzero__, METH_O, NULL},
30649 { (char *)"AlphaPixelData_swigregister", AlphaPixelData_swigregister, METH_VARARGS, NULL},
30650 { (char *)"AlphaPixelData_swiginit", AlphaPixelData_swiginit, METH_VARARGS, NULL},
30651 { (char *)"new_AlphaPixelData_Accessor", _wrap_new_AlphaPixelData_Accessor, METH_VARARGS, NULL},
30652 { (char *)"delete_AlphaPixelData_Accessor", (PyCFunction)_wrap_delete_AlphaPixelData_Accessor, METH_O, NULL},
30653 { (char *)"AlphaPixelData_Accessor_Reset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
30654 { (char *)"AlphaPixelData_Accessor_IsOk", (PyCFunction)_wrap_AlphaPixelData_Accessor_IsOk, METH_O, NULL},
30655 { (char *)"AlphaPixelData_Accessor_nextPixel", (PyCFunction)_wrap_AlphaPixelData_Accessor_nextPixel, METH_O, NULL},
30656 { (char *)"AlphaPixelData_Accessor_Offset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30657 { (char *)"AlphaPixelData_Accessor_OffsetX", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
30658 { (char *)"AlphaPixelData_Accessor_OffsetY", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
30659 { (char *)"AlphaPixelData_Accessor_MoveTo", (PyCFunction) _wrap_AlphaPixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
30660 { (char *)"AlphaPixelData_Accessor_Set", (PyCFunction) _wrap_AlphaPixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30661 { (char *)"AlphaPixelData_Accessor_Get", (PyCFunction)_wrap_AlphaPixelData_Accessor_Get, METH_O, NULL},
30662 { (char *)"AlphaPixelData_Accessor_swigregister", AlphaPixelData_Accessor_swigregister, METH_VARARGS, NULL},
30663 { (char *)"AlphaPixelData_Accessor_swiginit", AlphaPixelData_Accessor_swiginit, METH_VARARGS, NULL},
30664 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
30665 { (char *)"delete_Mask", (PyCFunction)_wrap_delete_Mask, METH_O, NULL},
30666 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
30667 { (char *)"Mask_swiginit", Mask_swiginit, METH_VARARGS, NULL},
30668 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
30669 { (char *)"delete_Icon", (PyCFunction)_wrap_delete_Icon, METH_O, NULL},
30670 { (char *)"new_EmptyIcon", (PyCFunction)_wrap_new_EmptyIcon, METH_NOARGS, NULL},
30671 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
30672 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30673 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
30674 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
30675 { (char *)"Icon_Ok", (PyCFunction)_wrap_Icon_Ok, METH_O, NULL},
30676 { (char *)"Icon_GetWidth", (PyCFunction)_wrap_Icon_GetWidth, METH_O, NULL},
30677 { (char *)"Icon_GetHeight", (PyCFunction)_wrap_Icon_GetHeight, METH_O, NULL},
30678 { (char *)"Icon_GetDepth", (PyCFunction)_wrap_Icon_GetDepth, METH_O, NULL},
30679 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
30680 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
30681 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30682 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30683 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
30684 { (char *)"Icon_swiginit", Icon_swiginit, METH_VARARGS, NULL},
30685 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
30686 { (char *)"delete_IconLocation", (PyCFunction)_wrap_delete_IconLocation, METH_O, NULL},
30687 { (char *)"IconLocation_IsOk", (PyCFunction)_wrap_IconLocation_IsOk, METH_O, NULL},
30688 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
30689 { (char *)"IconLocation_GetFileName", (PyCFunction)_wrap_IconLocation_GetFileName, METH_O, NULL},
30690 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
30691 { (char *)"IconLocation_GetIndex", (PyCFunction)_wrap_IconLocation_GetIndex, METH_O, NULL},
30692 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
30693 { (char *)"IconLocation_swiginit", IconLocation_swiginit, METH_VARARGS, NULL},
30694 { (char *)"new_IconBundle", (PyCFunction)_wrap_new_IconBundle, METH_NOARGS, NULL},
30695 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
30696 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30697 { (char *)"delete_IconBundle", (PyCFunction)_wrap_delete_IconBundle, METH_O, NULL},
30698 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30699 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
30700 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30701 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
30702 { (char *)"IconBundle_swiginit", IconBundle_swiginit, METH_VARARGS, NULL},
30703 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
30704 { (char *)"delete_Cursor", (PyCFunction)_wrap_delete_Cursor, METH_O, NULL},
30705 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30706 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
30707 { (char *)"Cursor_Ok", (PyCFunction)_wrap_Cursor_Ok, METH_O, NULL},
30708 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
30709 { (char *)"Cursor_swiginit", Cursor_swiginit, METH_VARARGS, NULL},
30710 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
30711 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30712 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
30713 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
30714 { (char *)"delete_Region", (PyCFunction)_wrap_delete_Region, METH_O, NULL},
30715 { (char *)"Region_Clear", (PyCFunction)_wrap_Region_Clear, METH_O, NULL},
30716 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
30717 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
30718 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30719 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
30720 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
30721 { (char *)"Region_GetBox", (PyCFunction)_wrap_Region_GetBox, METH_O, NULL},
30722 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
30723 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
30724 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30725 { (char *)"Region_IsEmpty", (PyCFunction)_wrap_Region_IsEmpty, METH_O, NULL},
30726 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
30727 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
30728 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30729 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
30730 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
30731 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30732 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
30733 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
30734 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30735 { (char *)"Region_ConvertToBitmap", (PyCFunction)_wrap_Region_ConvertToBitmap, METH_O, NULL},
30736 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30737 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
30738 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
30739 { (char *)"Region_swiginit", Region_swiginit, METH_VARARGS, NULL},
30740 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
30741 { (char *)"delete_RegionIterator", (PyCFunction)_wrap_delete_RegionIterator, METH_O, NULL},
30742 { (char *)"RegionIterator_GetX", (PyCFunction)_wrap_RegionIterator_GetX, METH_O, NULL},
30743 { (char *)"RegionIterator_GetY", (PyCFunction)_wrap_RegionIterator_GetY, METH_O, NULL},
30744 { (char *)"RegionIterator_GetW", (PyCFunction)_wrap_RegionIterator_GetW, METH_O, NULL},
30745 { (char *)"RegionIterator_GetWidth", (PyCFunction)_wrap_RegionIterator_GetWidth, METH_O, NULL},
30746 { (char *)"RegionIterator_GetH", (PyCFunction)_wrap_RegionIterator_GetH, METH_O, NULL},
30747 { (char *)"RegionIterator_GetHeight", (PyCFunction)_wrap_RegionIterator_GetHeight, METH_O, NULL},
30748 { (char *)"RegionIterator_GetRect", (PyCFunction)_wrap_RegionIterator_GetRect, METH_O, NULL},
30749 { (char *)"RegionIterator_HaveRects", (PyCFunction)_wrap_RegionIterator_HaveRects, METH_O, NULL},
30750 { (char *)"RegionIterator_Reset", (PyCFunction)_wrap_RegionIterator_Reset, METH_O, NULL},
30751 { (char *)"RegionIterator_Next", (PyCFunction)_wrap_RegionIterator_Next, METH_O, NULL},
30752 { (char *)"RegionIterator___nonzero__", (PyCFunction)_wrap_RegionIterator___nonzero__, METH_O, NULL},
30753 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
30754 { (char *)"RegionIterator_swiginit", RegionIterator_swiginit, METH_VARARGS, NULL},
30755 { (char *)"new_NativeFontInfo", (PyCFunction)_wrap_new_NativeFontInfo, METH_NOARGS, NULL},
30756 { (char *)"delete_NativeFontInfo", (PyCFunction)_wrap_delete_NativeFontInfo, METH_O, NULL},
30757 { (char *)"NativeFontInfo_Init", (PyCFunction)_wrap_NativeFontInfo_Init, METH_O, NULL},
30758 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
30759 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction)_wrap_NativeFontInfo_GetPointSize, METH_O, NULL},
30760 { (char *)"NativeFontInfo_GetStyle", (PyCFunction)_wrap_NativeFontInfo_GetStyle, METH_O, NULL},
30761 { (char *)"NativeFontInfo_GetWeight", (PyCFunction)_wrap_NativeFontInfo_GetWeight, METH_O, NULL},
30762 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction)_wrap_NativeFontInfo_GetUnderlined, METH_O, NULL},
30763 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction)_wrap_NativeFontInfo_GetFaceName, METH_O, NULL},
30764 { (char *)"NativeFontInfo_GetFamily", (PyCFunction)_wrap_NativeFontInfo_GetFamily, METH_O, NULL},
30765 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction)_wrap_NativeFontInfo_GetEncoding, METH_O, NULL},
30766 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30767 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30768 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
30769 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
30770 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
30771 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
30772 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30773 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
30774 { (char *)"NativeFontInfo_ToString", (PyCFunction)_wrap_NativeFontInfo_ToString, METH_O, NULL},
30775 { (char *)"NativeFontInfo___str__", (PyCFunction)_wrap_NativeFontInfo___str__, METH_O, NULL},
30776 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
30777 { (char *)"NativeFontInfo_ToUserString", (PyCFunction)_wrap_NativeFontInfo_ToUserString, METH_O, NULL},
30778 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
30779 { (char *)"NativeFontInfo_swiginit", NativeFontInfo_swiginit, METH_VARARGS, NULL},
30780 { (char *)"NativeEncodingInfo_facename_set", _wrap_NativeEncodingInfo_facename_set, METH_VARARGS, NULL},
30781 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction)_wrap_NativeEncodingInfo_facename_get, METH_O, NULL},
30782 { (char *)"NativeEncodingInfo_encoding_set", _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS, NULL},
30783 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction)_wrap_NativeEncodingInfo_encoding_get, METH_O, NULL},
30784 { (char *)"new_NativeEncodingInfo", (PyCFunction)_wrap_new_NativeEncodingInfo, METH_NOARGS, NULL},
30785 { (char *)"delete_NativeEncodingInfo", (PyCFunction)_wrap_delete_NativeEncodingInfo, METH_O, NULL},
30786 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
30787 { (char *)"NativeEncodingInfo_ToString", (PyCFunction)_wrap_NativeEncodingInfo_ToString, METH_O, NULL},
30788 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
30789 { (char *)"NativeEncodingInfo_swiginit", NativeEncodingInfo_swiginit, METH_VARARGS, NULL},
30790 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30791 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30792 { (char *)"new_FontMapper", (PyCFunction)_wrap_new_FontMapper, METH_NOARGS, NULL},
30793 { (char *)"delete_FontMapper", (PyCFunction)_wrap_delete_FontMapper, METH_O, NULL},
30794 { (char *)"FontMapper_Get", (PyCFunction)_wrap_FontMapper_Get, METH_NOARGS, NULL},
30795 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
30796 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30797 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction)_wrap_FontMapper_GetSupportedEncodingsCount, METH_NOARGS, NULL},
30798 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30799 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
30800 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
30801 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
30802 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
30803 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction)_wrap_FontMapper_GetDefaultConfigPath, METH_NOARGS, NULL},
30804 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30805 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
30806 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
30807 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
30808 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
30809 { (char *)"FontMapper_swiginit", FontMapper_swiginit, METH_VARARGS, NULL},
30810 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
30811 { (char *)"delete_Font", (PyCFunction)_wrap_delete_Font, METH_O, NULL},
30812 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30813 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
30814 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
30815 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
30816 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
30817 { (char *)"Font_Ok", (PyCFunction)_wrap_Font_Ok, METH_O, NULL},
30818 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
30819 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
30820 { (char *)"Font_GetPointSize", (PyCFunction)_wrap_Font_GetPointSize, METH_O, NULL},
30821 { (char *)"Font_GetPixelSize", (PyCFunction)_wrap_Font_GetPixelSize, METH_O, NULL},
30822 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction)_wrap_Font_IsUsingSizeInPixels, METH_O, NULL},
30823 { (char *)"Font_GetFamily", (PyCFunction)_wrap_Font_GetFamily, METH_O, NULL},
30824 { (char *)"Font_GetStyle", (PyCFunction)_wrap_Font_GetStyle, METH_O, NULL},
30825 { (char *)"Font_GetWeight", (PyCFunction)_wrap_Font_GetWeight, METH_O, NULL},
30826 { (char *)"Font_GetUnderlined", (PyCFunction)_wrap_Font_GetUnderlined, METH_O, NULL},
30827 { (char *)"Font_GetFaceName", (PyCFunction)_wrap_Font_GetFaceName, METH_O, NULL},
30828 { (char *)"Font_GetEncoding", (PyCFunction)_wrap_Font_GetEncoding, METH_O, NULL},
30829 { (char *)"Font_GetNativeFontInfo", (PyCFunction)_wrap_Font_GetNativeFontInfo, METH_O, NULL},
30830 { (char *)"Font_IsFixedWidth", (PyCFunction)_wrap_Font_IsFixedWidth, METH_O, NULL},
30831 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoDesc, METH_O, NULL},
30832 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoUserDesc, METH_O, NULL},
30833 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30834 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
30835 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
30836 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
30837 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
30838 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
30839 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
30840 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30841 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30842 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
30843 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
30844 { (char *)"Font_GetFamilyString", (PyCFunction)_wrap_Font_GetFamilyString, METH_O, NULL},
30845 { (char *)"Font_GetStyleString", (PyCFunction)_wrap_Font_GetStyleString, METH_O, NULL},
30846 { (char *)"Font_GetWeightString", (PyCFunction)_wrap_Font_GetWeightString, METH_O, NULL},
30847 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
30848 { (char *)"Font_GetNoAntiAliasing", (PyCFunction)_wrap_Font_GetNoAntiAliasing, METH_O, NULL},
30849 { (char *)"Font_GetDefaultEncoding", (PyCFunction)_wrap_Font_GetDefaultEncoding, METH_NOARGS, NULL},
30850 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
30851 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
30852 { (char *)"Font_swiginit", Font_swiginit, METH_VARARGS, NULL},
30853 { (char *)"new_FontEnumerator", (PyCFunction)_wrap_new_FontEnumerator, METH_NOARGS, NULL},
30854 { (char *)"delete_FontEnumerator", (PyCFunction)_wrap_delete_FontEnumerator, METH_O, NULL},
30855 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30856 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
30857 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
30858 { (char *)"FontEnumerator_GetEncodings", (PyCFunction)_wrap_FontEnumerator_GetEncodings, METH_NOARGS, NULL},
30859 { (char *)"FontEnumerator_GetFacenames", (PyCFunction)_wrap_FontEnumerator_GetFacenames, METH_NOARGS, NULL},
30860 { (char *)"FontEnumerator_IsValidFacename", (PyCFunction) _wrap_FontEnumerator_IsValidFacename, METH_VARARGS | METH_KEYWORDS, NULL},
30861 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
30862 { (char *)"FontEnumerator_swiginit", FontEnumerator_swiginit, METH_VARARGS, NULL},
30863 { (char *)"LanguageInfo_Language_set", _wrap_LanguageInfo_Language_set, METH_VARARGS, NULL},
30864 { (char *)"LanguageInfo_Language_get", (PyCFunction)_wrap_LanguageInfo_Language_get, METH_O, NULL},
30865 { (char *)"LanguageInfo_CanonicalName_set", _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS, NULL},
30866 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction)_wrap_LanguageInfo_CanonicalName_get, METH_O, NULL},
30867 { (char *)"LanguageInfo_Description_set", _wrap_LanguageInfo_Description_set, METH_VARARGS, NULL},
30868 { (char *)"LanguageInfo_Description_get", (PyCFunction)_wrap_LanguageInfo_Description_get, METH_O, NULL},
30869 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
30870 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
30871 { (char *)"delete_Locale", (PyCFunction)_wrap_delete_Locale, METH_O, NULL},
30872 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
30873 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
30874 { (char *)"Locale_GetSystemLanguage", (PyCFunction)_wrap_Locale_GetSystemLanguage, METH_NOARGS, NULL},
30875 { (char *)"Locale_GetSystemEncoding", (PyCFunction)_wrap_Locale_GetSystemEncoding, METH_NOARGS, NULL},
30876 { (char *)"Locale_GetSystemEncodingName", (PyCFunction)_wrap_Locale_GetSystemEncodingName, METH_NOARGS, NULL},
30877 { (char *)"Locale_IsOk", (PyCFunction)_wrap_Locale_IsOk, METH_O, NULL},
30878 { (char *)"Locale_GetLocale", (PyCFunction)_wrap_Locale_GetLocale, METH_O, NULL},
30879 { (char *)"Locale_GetLanguage", (PyCFunction)_wrap_Locale_GetLanguage, METH_O, NULL},
30880 { (char *)"Locale_GetSysName", (PyCFunction)_wrap_Locale_GetSysName, METH_O, NULL},
30881 { (char *)"Locale_GetCanonicalName", (PyCFunction)_wrap_Locale_GetCanonicalName, METH_O, NULL},
30882 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
30883 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
30884 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
30885 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30886 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
30887 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30888 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
30889 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
30890 { (char *)"Locale_GetName", (PyCFunction)_wrap_Locale_GetName, METH_O, NULL},
30891 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
30892 { (char *)"Locale_swiginit", Locale_swiginit, METH_VARARGS, NULL},
30893 { (char *)"new_PyLocale", (PyCFunction) _wrap_new_PyLocale, METH_VARARGS | METH_KEYWORDS, NULL},
30894 { (char *)"delete_PyLocale", (PyCFunction)_wrap_delete_PyLocale, METH_O, NULL},
30895 { (char *)"PyLocale__setCallbackInfo", (PyCFunction) _wrap_PyLocale__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
30896 { (char *)"PyLocale_GetSingularString", (PyCFunction) _wrap_PyLocale_GetSingularString, METH_VARARGS | METH_KEYWORDS, NULL},
30897 { (char *)"PyLocale_GetPluralString", (PyCFunction) _wrap_PyLocale_GetPluralString, METH_VARARGS | METH_KEYWORDS, NULL},
30898 { (char *)"PyLocale_swigregister", PyLocale_swigregister, METH_VARARGS, NULL},
30899 { (char *)"PyLocale_swiginit", PyLocale_swiginit, METH_VARARGS, NULL},
30900 { (char *)"GetLocale", (PyCFunction)_wrap_GetLocale, METH_NOARGS, NULL},
30901 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
30902 { (char *)"new_EncodingConverter", (PyCFunction)_wrap_new_EncodingConverter, METH_NOARGS, NULL},
30903 { (char *)"delete_EncodingConverter", (PyCFunction)_wrap_delete_EncodingConverter, METH_O, NULL},
30904 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
30905 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
30906 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
30907 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
30908 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
30909 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
30910 { (char *)"EncodingConverter_swiginit", EncodingConverter_swiginit, METH_VARARGS, NULL},
30911 { (char *)"delete_DC", (PyCFunction)_wrap_delete_DC, METH_O, NULL},
30912 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
30913 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30914 { (char *)"DC_GradientFillConcentric", (PyCFunction) _wrap_DC_GradientFillConcentric, METH_VARARGS | METH_KEYWORDS, NULL},
30915 { (char *)"DC_GradientFillLinear", (PyCFunction) _wrap_DC_GradientFillLinear, METH_VARARGS | METH_KEYWORDS, NULL},
30916 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
30917 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30918 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
30919 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
30920 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
30921 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30922 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
30923 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30924 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
30925 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
30926 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
30927 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30928 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30929 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30930 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
30931 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
30932 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30933 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
30934 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
30935 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30936 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
30937 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
30938 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
30939 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
30940 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30941 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
30942 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30943 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
30944 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30945 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
30946 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30947 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
30948 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30949 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
30950 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30951 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30952 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
30953 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
30954 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
30955 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
30956 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
30957 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30958 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30959 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
30960 { (char *)"DC_Clear", (PyCFunction)_wrap_DC_Clear, METH_O, NULL},
30961 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
30962 { (char *)"DC_EndDoc", (PyCFunction)_wrap_DC_EndDoc, METH_O, NULL},
30963 { (char *)"DC_StartPage", (PyCFunction)_wrap_DC_StartPage, METH_O, NULL},
30964 { (char *)"DC_EndPage", (PyCFunction)_wrap_DC_EndPage, METH_O, NULL},
30965 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30966 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
30967 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
30968 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
30969 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
30970 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
30971 { (char *)"DC_DestroyClippingRegion", (PyCFunction)_wrap_DC_DestroyClippingRegion, METH_O, NULL},
30972 { (char *)"DC_GetClippingBox", (PyCFunction)_wrap_DC_GetClippingBox, METH_O, NULL},
30973 { (char *)"DC_GetClippingRect", (PyCFunction)_wrap_DC_GetClippingRect, METH_O, NULL},
30974 { (char *)"DC_GetCharHeight", (PyCFunction)_wrap_DC_GetCharHeight, METH_O, NULL},
30975 { (char *)"DC_GetCharWidth", (PyCFunction)_wrap_DC_GetCharWidth, METH_O, NULL},
30976 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
30977 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
30978 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
30979 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
30980 { (char *)"DC_GetSize", (PyCFunction)_wrap_DC_GetSize, METH_O, NULL},
30981 { (char *)"DC_GetSizeTuple", (PyCFunction)_wrap_DC_GetSizeTuple, METH_O, NULL},
30982 { (char *)"DC_GetSizeMM", (PyCFunction)_wrap_DC_GetSizeMM, METH_O, NULL},
30983 { (char *)"DC_GetSizeMMTuple", (PyCFunction)_wrap_DC_GetSizeMMTuple, METH_O, NULL},
30984 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
30985 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
30986 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
30987 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"DC_CanDrawBitmap", (PyCFunction)_wrap_DC_CanDrawBitmap, METH_O, NULL},
30993 { (char *)"DC_CanGetTextExtent", (PyCFunction)_wrap_DC_CanGetTextExtent, METH_O, NULL},
30994 { (char *)"DC_GetDepth", (PyCFunction)_wrap_DC_GetDepth, METH_O, NULL},
30995 { (char *)"DC_GetPPI", (PyCFunction)_wrap_DC_GetPPI, METH_O, NULL},
30996 { (char *)"DC_Ok", (PyCFunction)_wrap_DC_Ok, METH_O, NULL},
30997 { (char *)"DC_GetBackgroundMode", (PyCFunction)_wrap_DC_GetBackgroundMode, METH_O, NULL},
30998 { (char *)"DC_GetBackground", (PyCFunction)_wrap_DC_GetBackground, METH_O, NULL},
30999 { (char *)"DC_GetBrush", (PyCFunction)_wrap_DC_GetBrush, METH_O, NULL},
31000 { (char *)"DC_GetFont", (PyCFunction)_wrap_DC_GetFont, METH_O, NULL},
31001 { (char *)"DC_GetPen", (PyCFunction)_wrap_DC_GetPen, METH_O, NULL},
31002 { (char *)"DC_GetTextBackground", (PyCFunction)_wrap_DC_GetTextBackground, METH_O, NULL},
31003 { (char *)"DC_GetTextForeground", (PyCFunction)_wrap_DC_GetTextForeground, METH_O, NULL},
31004 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"DC_GetMapMode", (PyCFunction)_wrap_DC_GetMapMode, METH_O, NULL},
31007 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"DC_GetUserScale", (PyCFunction)_wrap_DC_GetUserScale, METH_O, NULL},
31009 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"DC_GetLogicalScale", (PyCFunction)_wrap_DC_GetLogicalScale, METH_O, NULL},
31011 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"DC_GetLogicalOrigin", (PyCFunction)_wrap_DC_GetLogicalOrigin, METH_O, NULL},
31013 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction)_wrap_DC_GetLogicalOriginTuple, METH_O, NULL},
31014 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"DC_GetDeviceOrigin", (PyCFunction)_wrap_DC_GetDeviceOrigin, METH_O, NULL},
31017 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction)_wrap_DC_GetDeviceOriginTuple, METH_O, NULL},
31018 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"DC_GetLogicalFunction", (PyCFunction)_wrap_DC_GetLogicalFunction, METH_O, NULL},
31022 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction)_wrap_DC_ComputeScaleAndOrigin, METH_O, NULL},
31024 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"DC_ResetBoundingBox", (PyCFunction)_wrap_DC_ResetBoundingBox, METH_O, NULL},
31027 { (char *)"DC_MinX", (PyCFunction)_wrap_DC_MinX, METH_O, NULL},
31028 { (char *)"DC_MaxX", (PyCFunction)_wrap_DC_MaxX, METH_O, NULL},
31029 { (char *)"DC_MinY", (PyCFunction)_wrap_DC_MinY, METH_O, NULL},
31030 { (char *)"DC_MaxY", (PyCFunction)_wrap_DC_MaxY, METH_O, NULL},
31031 { (char *)"DC_GetBoundingBox", (PyCFunction)_wrap_DC_GetBoundingBox, METH_O, NULL},
31032 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
31039 { (char *)"new_MemoryDC", (PyCFunction)_wrap_new_MemoryDC, METH_NOARGS, NULL},
31040 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
31043 { (char *)"MemoryDC_swiginit", MemoryDC_swiginit, METH_VARARGS, NULL},
31044 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
31045 { (char *)"delete_BufferedDC", (PyCFunction)_wrap_delete_BufferedDC, METH_O, NULL},
31046 { (char *)"BufferedDC_UnMask", (PyCFunction)_wrap_BufferedDC_UnMask, METH_O, NULL},
31047 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
31048 { (char *)"BufferedDC_swiginit", BufferedDC_swiginit, METH_VARARGS, NULL},
31049 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
31051 { (char *)"BufferedPaintDC_swiginit", BufferedPaintDC_swiginit, METH_VARARGS, NULL},
31052 { (char *)"new_ScreenDC", (PyCFunction)_wrap_new_ScreenDC, METH_NOARGS, NULL},
31053 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction)_wrap_ScreenDC_EndDrawingOnTop, METH_O, NULL},
31056 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
31057 { (char *)"ScreenDC_swiginit", ScreenDC_swiginit, METH_VARARGS, NULL},
31058 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
31060 { (char *)"ClientDC_swiginit", ClientDC_swiginit, METH_VARARGS, NULL},
31061 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
31063 { (char *)"PaintDC_swiginit", PaintDC_swiginit, METH_VARARGS, NULL},
31064 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
31066 { (char *)"WindowDC_swiginit", WindowDC_swiginit, METH_VARARGS, NULL},
31067 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
31069 { (char *)"MirrorDC_swiginit", MirrorDC_swiginit, METH_VARARGS, NULL},
31070 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"PostScriptDC_GetPrintData", (PyCFunction)_wrap_PostScriptDC_GetPrintData, METH_O, NULL},
31072 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"PostScriptDC_GetResolution", (PyCFunction)_wrap_PostScriptDC_GetResolution, METH_NOARGS, NULL},
31075 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
31076 { (char *)"PostScriptDC_swiginit", PostScriptDC_swiginit, METH_VARARGS, NULL},
31077 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
31079 { (char *)"MetaFile_swiginit", MetaFile_swiginit, METH_VARARGS, NULL},
31080 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
31082 { (char *)"MetaFileDC_swiginit", MetaFileDC_swiginit, METH_VARARGS, NULL},
31083 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
31085 { (char *)"PrinterDC_swiginit", PrinterDC_swiginit, METH_VARARGS, NULL},
31086 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"delete_ImageList", (PyCFunction)_wrap_delete_ImageList, METH_O, NULL},
31088 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"ImageList_GetImageCount", (PyCFunction)_wrap_ImageList_GetImageCount, METH_O, NULL},
31096 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"ImageList_RemoveAll", (PyCFunction)_wrap_ImageList_RemoveAll, METH_O, NULL},
31098 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
31100 { (char *)"ImageList_swiginit", ImageList_swiginit, METH_VARARGS, NULL},
31101 { (char *)"new_StockGDI", (PyCFunction)_wrap_new_StockGDI, METH_NOARGS, NULL},
31102 { (char *)"delete_StockGDI", (PyCFunction)_wrap_delete_StockGDI, METH_O, NULL},
31103 { (char *)"StockGDI_DeleteAll", (PyCFunction)_wrap_StockGDI_DeleteAll, METH_NOARGS, NULL},
31104 { (char *)"StockGDI_instance", (PyCFunction)_wrap_StockGDI_instance, METH_NOARGS, NULL},
31105 { (char *)"StockGDI_GetBrush", (PyCFunction) _wrap_StockGDI_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"StockGDI_GetColour", (PyCFunction) _wrap_StockGDI_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"StockGDI_GetCursor", (PyCFunction) _wrap_StockGDI_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"StockGDI_GetPen", (PyCFunction) _wrap_StockGDI_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"StockGDI_GetFont", (PyCFunction) _wrap_StockGDI_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"StockGDI_swigregister", StockGDI_swigregister, METH_VARARGS, NULL},
31111 { (char *)"StockGDI_swiginit", StockGDI_swiginit, METH_VARARGS, NULL},
31112 { (char *)"new_GDIObjListBase", (PyCFunction)_wrap_new_GDIObjListBase, METH_NOARGS, NULL},
31113 { (char *)"delete_GDIObjListBase", (PyCFunction)_wrap_delete_GDIObjListBase, METH_O, NULL},
31114 { (char *)"GDIObjListBase_swigregister", GDIObjListBase_swigregister, METH_VARARGS, NULL},
31115 { (char *)"GDIObjListBase_swiginit", GDIObjListBase_swiginit, METH_VARARGS, NULL},
31116 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
31120 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
31124 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
31128 { (char *)"new_ColourDatabase", (PyCFunction)_wrap_new_ColourDatabase, METH_NOARGS, NULL},
31129 { (char *)"delete_ColourDatabase", (PyCFunction)_wrap_delete_ColourDatabase, METH_O, NULL},
31130 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
31135 { (char *)"ColourDatabase_swiginit", ColourDatabase_swiginit, METH_VARARGS, NULL},
31136 { (char *)"_wxPyInitTheFontList", (PyCFunction)_wrap__wxPyInitTheFontList, METH_NOARGS, NULL},
31137 { (char *)"_wxPyInitThePenList", (PyCFunction)_wrap__wxPyInitThePenList, METH_NOARGS, NULL},
31138 { (char *)"_wxPyInitTheBrushList", (PyCFunction)_wrap__wxPyInitTheBrushList, METH_NOARGS, NULL},
31139 { (char *)"_wxPyInitTheColourDatabase", (PyCFunction)_wrap__wxPyInitTheColourDatabase, METH_NOARGS, NULL},
31140 { (char *)"new_Effects", (PyCFunction)_wrap_new_Effects, METH_NOARGS, NULL},
31141 { (char *)"Effects_GetHighlightColour", (PyCFunction)_wrap_Effects_GetHighlightColour, METH_O, NULL},
31142 { (char *)"Effects_GetLightShadow", (PyCFunction)_wrap_Effects_GetLightShadow, METH_O, NULL},
31143 { (char *)"Effects_GetFaceColour", (PyCFunction)_wrap_Effects_GetFaceColour, METH_O, NULL},
31144 { (char *)"Effects_GetMediumShadow", (PyCFunction)_wrap_Effects_GetMediumShadow, METH_O, NULL},
31145 { (char *)"Effects_GetDarkShadow", (PyCFunction)_wrap_Effects_GetDarkShadow, METH_O, NULL},
31146 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
31155 { (char *)"Effects_swiginit", Effects_swiginit, METH_VARARGS, NULL},
31156 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"delete_SplitterRenderParams", (PyCFunction)_wrap_delete_SplitterRenderParams, METH_O, NULL},
31158 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction)_wrap_SplitterRenderParams_widthSash_get, METH_O, NULL},
31159 { (char *)"SplitterRenderParams_border_get", (PyCFunction)_wrap_SplitterRenderParams_border_get, METH_O, NULL},
31160 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction)_wrap_SplitterRenderParams_isHotSensitive_get, METH_O, NULL},
31161 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
31162 { (char *)"SplitterRenderParams_swiginit", SplitterRenderParams_swiginit, METH_VARARGS, NULL},
31163 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"delete_RendererVersion", (PyCFunction)_wrap_delete_RendererVersion, METH_O, NULL},
31165 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"RendererVersion_version_get", (PyCFunction)_wrap_RendererVersion_version_get, METH_O, NULL},
31167 { (char *)"RendererVersion_age_get", (PyCFunction)_wrap_RendererVersion_age_get, METH_O, NULL},
31168 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
31169 { (char *)"RendererVersion_swiginit", RendererVersion_swiginit, METH_VARARGS, NULL},
31170 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"RendererNative_DrawCheckBox", (PyCFunction) _wrap_RendererNative_DrawCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"RendererNative_DrawPushButton", (PyCFunction) _wrap_RendererNative_DrawPushButton, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"RendererNative_DrawItemSelectionRect", (PyCFunction) _wrap_RendererNative_DrawItemSelectionRect, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"RendererNative_Get", (PyCFunction)_wrap_RendererNative_Get, METH_NOARGS, NULL},
31181 { (char *)"RendererNative_GetGeneric", (PyCFunction)_wrap_RendererNative_GetGeneric, METH_NOARGS, NULL},
31182 { (char *)"RendererNative_GetDefault", (PyCFunction)_wrap_RendererNative_GetDefault, METH_NOARGS, NULL},
31183 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"RendererNative_GetVersion", (PyCFunction)_wrap_RendererNative_GetVersion, METH_O, NULL},
31185 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
31186 { (char *)"new_PseudoDC", (PyCFunction)_wrap_new_PseudoDC, METH_NOARGS, NULL},
31187 { (char *)"PseudoDC_BeginDrawing", (PyCFunction)_wrap_PseudoDC_BeginDrawing, METH_O, NULL},
31188 { (char *)"PseudoDC_EndDrawing", (PyCFunction)_wrap_PseudoDC_EndDrawing, METH_O, NULL},
31189 { (char *)"delete_PseudoDC", (PyCFunction)_wrap_delete_PseudoDC, METH_O, NULL},
31190 { (char *)"PseudoDC_RemoveAll", (PyCFunction)_wrap_PseudoDC_RemoveAll, METH_O, NULL},
31191 { (char *)"PseudoDC_GetLen", (PyCFunction)_wrap_PseudoDC_GetLen, METH_O, NULL},
31192 { (char *)"PseudoDC_SetId", (PyCFunction) _wrap_PseudoDC_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"PseudoDC_ClearId", (PyCFunction) _wrap_PseudoDC_ClearId, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"PseudoDC_RemoveId", (PyCFunction) _wrap_PseudoDC_RemoveId, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"PseudoDC_TranslateId", (PyCFunction) _wrap_PseudoDC_TranslateId, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"PseudoDC_DrawIdToDC", (PyCFunction) _wrap_PseudoDC_DrawIdToDC, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"PseudoDC_SetIdBounds", (PyCFunction) _wrap_PseudoDC_SetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"PseudoDC_GetIdBounds", (PyCFunction) _wrap_PseudoDC_GetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"PseudoDC_DrawToDCClipped", (PyCFunction) _wrap_PseudoDC_DrawToDCClipped, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"PseudoDC_DrawToDCClippedRgn", (PyCFunction) _wrap_PseudoDC_DrawToDCClippedRgn, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"PseudoDC_DrawToDC", (PyCFunction) _wrap_PseudoDC_DrawToDC, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"PseudoDC_FloodFill", (PyCFunction) _wrap_PseudoDC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"PseudoDC_FloodFillPoint", (PyCFunction) _wrap_PseudoDC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"PseudoDC_DrawLine", (PyCFunction) _wrap_PseudoDC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"PseudoDC_DrawLinePoint", (PyCFunction) _wrap_PseudoDC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"PseudoDC_CrossHair", (PyCFunction) _wrap_PseudoDC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"PseudoDC_CrossHairPoint", (PyCFunction) _wrap_PseudoDC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"PseudoDC_DrawArc", (PyCFunction) _wrap_PseudoDC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"PseudoDC_DrawArcPoint", (PyCFunction) _wrap_PseudoDC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"PseudoDC_DrawCheckMark", (PyCFunction) _wrap_PseudoDC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"PseudoDC_DrawCheckMarkRect", (PyCFunction) _wrap_PseudoDC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"PseudoDC_DrawEllipticArc", (PyCFunction) _wrap_PseudoDC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"PseudoDC_DrawEllipticArcPointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"PseudoDC_DrawPoint", (PyCFunction) _wrap_PseudoDC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"PseudoDC_DrawPointPoint", (PyCFunction) _wrap_PseudoDC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"PseudoDC_DrawRectangle", (PyCFunction) _wrap_PseudoDC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"PseudoDC_DrawRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"PseudoDC_DrawRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"PseudoDC_DrawRoundedRectangle", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"PseudoDC_DrawRoundedRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"PseudoDC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"PseudoDC_DrawCircle", (PyCFunction) _wrap_PseudoDC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"PseudoDC_DrawCirclePoint", (PyCFunction) _wrap_PseudoDC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"PseudoDC_DrawEllipse", (PyCFunction) _wrap_PseudoDC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"PseudoDC_DrawEllipseRect", (PyCFunction) _wrap_PseudoDC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"PseudoDC_DrawEllipsePointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"PseudoDC_DrawIcon", (PyCFunction) _wrap_PseudoDC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"PseudoDC_DrawIconPoint", (PyCFunction) _wrap_PseudoDC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"PseudoDC_DrawBitmap", (PyCFunction) _wrap_PseudoDC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"PseudoDC_DrawBitmapPoint", (PyCFunction) _wrap_PseudoDC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"PseudoDC_DrawText", (PyCFunction) _wrap_PseudoDC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"PseudoDC_DrawTextPoint", (PyCFunction) _wrap_PseudoDC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"PseudoDC_DrawRotatedText", (PyCFunction) _wrap_PseudoDC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"PseudoDC_DrawRotatedTextPoint", (PyCFunction) _wrap_PseudoDC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"PseudoDC_DrawLines", (PyCFunction) _wrap_PseudoDC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"PseudoDC_DrawPolygon", (PyCFunction) _wrap_PseudoDC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"PseudoDC_DrawLabel", (PyCFunction) _wrap_PseudoDC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"PseudoDC_DrawImageLabel", (PyCFunction) _wrap_PseudoDC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"PseudoDC_DrawSpline", (PyCFunction) _wrap_PseudoDC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"PseudoDC_Clear", (PyCFunction)_wrap_PseudoDC_Clear, METH_O, NULL},
31241 { (char *)"PseudoDC_SetFont", (PyCFunction) _wrap_PseudoDC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"PseudoDC_SetPen", (PyCFunction) _wrap_PseudoDC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"PseudoDC_SetBrush", (PyCFunction) _wrap_PseudoDC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"PseudoDC_SetBackground", (PyCFunction) _wrap_PseudoDC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"PseudoDC_SetBackgroundMode", (PyCFunction) _wrap_PseudoDC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"PseudoDC_SetPalette", (PyCFunction) _wrap_PseudoDC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"PseudoDC_SetTextForeground", (PyCFunction) _wrap_PseudoDC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"PseudoDC_SetTextBackground", (PyCFunction) _wrap_PseudoDC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"PseudoDC_SetLogicalFunction", (PyCFunction) _wrap_PseudoDC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"PseudoDC_swigregister", PseudoDC_swigregister, METH_VARARGS, NULL},
31251 { (char *)"PseudoDC_swiginit", PseudoDC_swiginit, METH_VARARGS, NULL},
31252 { NULL, NULL, 0, NULL }
31253 };
31254
31255
31256 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31257
31258 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
31259 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
31260 }
31261 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
31262 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
31263 }
31264 static void *_p_wxPyLocaleTo_p_wxLocale(void *x) {
31265 return (void *)((wxLocale *) ((wxPyLocale *) x));
31266 }
31267 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
31268 return (void *)((wxGDIObject *) ((wxIcon *) x));
31269 }
31270 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
31271 return (void *)((wxGDIObject *) ((wxPalette *) x));
31272 }
31273 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
31274 return (void *)((wxGDIObject *) ((wxPen *) x));
31275 }
31276 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
31277 return (void *)((wxGDIObject *) ((wxFont *) x));
31278 }
31279 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
31280 return (void *)((wxGDIObject *) ((wxCursor *) x));
31281 }
31282 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
31283 return (void *)((wxGDIObject *) ((wxBitmap *) x));
31284 }
31285 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
31286 return (void *)((wxGDIObject *) ((wxRegion *) x));
31287 }
31288 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
31289 return (void *)((wxGDIObject *) ((wxBrush *) x));
31290 }
31291 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
31292 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
31293 }
31294 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
31295 return (void *)((wxDC *) ((wxScreenDC *) x));
31296 }
31297 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
31298 return (void *)((wxDC *) ((wxMirrorDC *) x));
31299 }
31300 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
31301 return (void *)((wxDC *) ((wxMemoryDC *) x));
31302 }
31303 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
31304 return (void *)((wxDC *) ((wxWindowDC *) x));
31305 }
31306 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
31307 return (void *)((wxDC *) ((wxMetaFileDC *) x));
31308 }
31309 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
31310 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
31311 }
31312 static void *_p_wxClientDCTo_p_wxDC(void *x) {
31313 return (void *)((wxDC *) ((wxClientDC *) x));
31314 }
31315 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
31316 return (void *)((wxDC *) ((wxPaintDC *) x));
31317 }
31318 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
31319 return (void *)((wxDC *) ((wxPostScriptDC *) x));
31320 }
31321 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
31322 return (void *)((wxDC *) ((wxPrinterDC *) x));
31323 }
31324 static void *_p_wxBrushListTo_p_wxGDIObjListBase(void *x) {
31325 return (void *)((wxGDIObjListBase *) ((wxBrushList *) x));
31326 }
31327 static void *_p_wxFontListTo_p_wxGDIObjListBase(void *x) {
31328 return (void *)((wxGDIObjListBase *) ((wxFontList *) x));
31329 }
31330 static void *_p_wxPenListTo_p_wxGDIObjListBase(void *x) {
31331 return (void *)((wxGDIObjListBase *) ((wxPenList *) x));
31332 }
31333 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
31334 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
31335 }
31336 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
31337 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
31338 }
31339 static void *_p_wxPenTo_p_wxObject(void *x) {
31340 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
31341 }
31342 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
31343 return (void *)((wxObject *) ((wxRegionIterator *) x));
31344 }
31345 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
31346 return (void *)((wxObject *) ((wxSizerItem *) x));
31347 }
31348 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
31349 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
31350 }
31351 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
31352 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
31353 }
31354 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
31355 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
31356 }
31357 static void *_p_wxIconTo_p_wxObject(void *x) {
31358 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
31359 }
31360 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
31361 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
31362 }
31363 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
31364 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
31365 }
31366 static void *_p_wxSizerTo_p_wxObject(void *x) {
31367 return (void *)((wxObject *) ((wxSizer *) x));
31368 }
31369 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
31370 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
31371 }
31372 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
31373 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
31374 }
31375 static void *_p_wxEventTo_p_wxObject(void *x) {
31376 return (void *)((wxObject *) ((wxEvent *) x));
31377 }
31378 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
31379 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
31380 }
31381 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
31382 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
31383 }
31384 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
31385 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
31386 }
31387 static void *_p_wxPseudoDCTo_p_wxObject(void *x) {
31388 return (void *)((wxObject *) ((wxPseudoDC *) x));
31389 }
31390 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
31391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
31392 }
31393 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
31394 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
31395 }
31396 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
31397 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
31398 }
31399 static void *_p_wxDCTo_p_wxObject(void *x) {
31400 return (void *)((wxObject *) ((wxDC *) x));
31401 }
31402 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
31403 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
31404 }
31405 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
31406 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
31407 }
31408 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
31409 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31410 }
31411 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
31412 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
31413 }
31414 static void *_p_wxControlTo_p_wxObject(void *x) {
31415 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
31416 }
31417 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
31418 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
31419 }
31420 static void *_p_wxClientDCTo_p_wxObject(void *x) {
31421 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
31422 }
31423 static void *_p_wxFSFileTo_p_wxObject(void *x) {
31424 return (void *)((wxObject *) ((wxFSFile *) x));
31425 }
31426 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
31427 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
31428 }
31429 static void *_p_wxRegionTo_p_wxObject(void *x) {
31430 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
31431 }
31432 static void *_p_wxPySizerTo_p_wxObject(void *x) {
31433 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
31434 }
31435 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
31436 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
31437 }
31438 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
31439 return (void *)((wxObject *) ((wxGDIObject *) x));
31440 }
31441 static void *_p_wxEffectsTo_p_wxObject(void *x) {
31442 return (void *)((wxObject *) ((wxEffects *) x));
31443 }
31444 static void *_p_wxPyEventTo_p_wxObject(void *x) {
31445 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
31446 }
31447 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
31448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
31449 }
31450 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
31451 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
31452 }
31453 static void *_p_wxShowEventTo_p_wxObject(void *x) {
31454 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
31455 }
31456 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
31457 return (void *)((wxObject *) ((wxMenuItem *) x));
31458 }
31459 static void *_p_wxDateEventTo_p_wxObject(void *x) {
31460 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
31461 }
31462 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
31463 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
31464 }
31465 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
31466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
31467 }
31468 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
31469 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
31470 }
31471 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
31472 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
31473 }
31474 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
31475 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
31476 }
31477 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
31478 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
31479 }
31480 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
31481 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
31482 }
31483 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
31484 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
31485 }
31486 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
31487 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
31488 }
31489 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
31490 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
31491 }
31492 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
31493 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
31494 }
31495 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
31496 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
31497 }
31498 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
31499 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
31500 }
31501 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
31502 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
31503 }
31504 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
31505 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
31506 }
31507 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
31508 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
31509 }
31510 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
31511 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
31512 }
31513 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
31514 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
31515 }
31516 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
31517 return (void *)((wxObject *) ((wxImageHandler *) x));
31518 }
31519 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
31520 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
31521 }
31522 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
31523 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
31524 }
31525 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
31526 return (void *)((wxObject *) ((wxEvtHandler *) x));
31527 }
31528 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
31529 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
31530 }
31531 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
31532 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
31533 }
31534 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
31535 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
31536 }
31537 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
31538 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
31539 }
31540 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
31541 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
31542 }
31543 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
31544 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
31545 }
31546 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
31547 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
31548 }
31549 static void *_p_wxImageTo_p_wxObject(void *x) {
31550 return (void *)((wxObject *) ((wxImage *) x));
31551 }
31552 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
31553 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
31554 }
31555 static void *_p_wxPaletteTo_p_wxObject(void *x) {
31556 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
31557 }
31558 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
31559 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
31560 }
31561 static void *_p_wxImageListTo_p_wxObject(void *x) {
31562 return (void *)((wxObject *) ((wxImageList *) x));
31563 }
31564 static void *_p_wxCursorTo_p_wxObject(void *x) {
31565 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
31566 }
31567 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
31568 return (void *)((wxObject *) ((wxEncodingConverter *) x));
31569 }
31570 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
31571 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
31572 }
31573 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
31574 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31575 }
31576 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
31577 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
31578 }
31579 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
31580 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
31581 }
31582 static void *_p_wxWindowTo_p_wxObject(void *x) {
31583 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
31584 }
31585 static void *_p_wxMenuTo_p_wxObject(void *x) {
31586 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
31587 }
31588 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
31589 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
31590 }
31591 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
31592 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
31593 }
31594 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
31595 return (void *)((wxObject *) ((wxFileSystem *) x));
31596 }
31597 static void *_p_wxBitmapTo_p_wxObject(void *x) {
31598 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
31599 }
31600 static void *_p_wxMaskTo_p_wxObject(void *x) {
31601 return (void *)((wxObject *) ((wxMask *) x));
31602 }
31603 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
31604 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
31605 }
31606 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
31607 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
31608 }
31609 static void *_p_wxPyAppTo_p_wxObject(void *x) {
31610 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
31611 }
31612 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
31613 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
31614 }
31615 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
31616 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
31617 }
31618 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
31619 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
31620 }
31621 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
31622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
31623 }
31624 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
31625 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
31626 }
31627 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
31628 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
31629 }
31630 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
31631 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
31632 }
31633 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
31634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
31635 }
31636 static void *_p_wxFontTo_p_wxObject(void *x) {
31637 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
31638 }
31639 static void *_p_wxBrushTo_p_wxObject(void *x) {
31640 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
31641 }
31642 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
31643 return (void *)((wxObject *) ((wxMetaFile *) x));
31644 }
31645 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
31646 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31647 }
31648 static void *_p_wxColourTo_p_wxObject(void *x) {
31649 return (void *)((wxObject *) ((wxColour *) x));
31650 }
31651 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
31652 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
31653 }
31654 static void *_p_wxValidatorTo_p_wxObject(void *x) {
31655 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
31656 }
31657 static void *_p_wxControlTo_p_wxWindow(void *x) {
31658 return (void *)((wxWindow *) ((wxControl *) x));
31659 }
31660 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
31661 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
31662 }
31663 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
31664 return (void *)((wxWindow *) ((wxMenuBar *) x));
31665 }
31666 static void *_p_wxNativePixelDataTo_p_wxPixelDataBase(void *x) {
31667 return (void *)((wxPixelDataBase *) ((wxNativePixelData *) x));
31668 }
31669 static void *_p_wxAlphaPixelDataTo_p_wxPixelDataBase(void *x) {
31670 return (void *)((wxPixelDataBase *) ((wxAlphaPixelData *) x));
31671 }
31672 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
31673 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
31674 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
31675 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};
31676 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
31677 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
31678 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
31679 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
31680 static swig_type_info _swigt__p_wxAlphaPixelData = {"_p_wxAlphaPixelData", "wxAlphaPixelData *", 0, 0, (void*)0, 0};
31681 static swig_type_info _swigt__p_wxAlphaPixelData_Accessor = {"_p_wxAlphaPixelData_Accessor", "wxAlphaPixelData_Accessor *", 0, 0, (void*)0, 0};
31682 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
31683 static swig_type_info _swigt__p_wxBrush = {"_p_wxBrush", "wxBrush *", 0, 0, (void*)0, 0};
31684 static swig_type_info _swigt__p_wxBrushList = {"_p_wxBrushList", "wxBrushList *", 0, 0, (void*)0, 0};
31685 static swig_type_info _swigt__p_wxBufferedDC = {"_p_wxBufferedDC", "wxBufferedDC *", 0, 0, (void*)0, 0};
31686 static swig_type_info _swigt__p_wxBufferedPaintDC = {"_p_wxBufferedPaintDC", "wxBufferedPaintDC *", 0, 0, (void*)0, 0};
31687 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
31688 static swig_type_info _swigt__p_wxClientDC = {"_p_wxClientDC", "wxClientDC *", 0, 0, (void*)0, 0};
31689 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
31690 static swig_type_info _swigt__p_wxColourDatabase = {"_p_wxColourDatabase", "wxColourDatabase *", 0, 0, (void*)0, 0};
31691 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
31692 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
31693 static swig_type_info _swigt__p_wxDash = {"_p_wxDash", "wxDash *", 0, 0, (void*)0, 0};
31694 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
31695 static swig_type_info _swigt__p_wxEffects = {"_p_wxEffects", "wxEffects *", 0, 0, (void*)0, 0};
31696 static swig_type_info _swigt__p_wxEncodingConverter = {"_p_wxEncodingConverter", "wxEncodingConverter *", 0, 0, (void*)0, 0};
31697 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
31698 static swig_type_info _swigt__p_wxFontList = {"_p_wxFontList", "wxFontList *", 0, 0, (void*)0, 0};
31699 static swig_type_info _swigt__p_wxFontMapper = {"_p_wxFontMapper", "wxFontMapper *", 0, 0, (void*)0, 0};
31700 static swig_type_info _swigt__p_wxGDIObjListBase = {"_p_wxGDIObjListBase", "wxGDIObjListBase *", 0, 0, (void*)0, 0};
31701 static swig_type_info _swigt__p_wxGDIObject = {"_p_wxGDIObject", "wxGDIObject *", 0, 0, (void*)0, 0};
31702 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
31703 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
31704 static swig_type_info _swigt__p_wxIconLocation = {"_p_wxIconLocation", "wxIconLocation *", 0, 0, (void*)0, 0};
31705 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
31706 static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
31707 static swig_type_info _swigt__p_wxLanguageInfo = {"_p_wxLanguageInfo", "wxLanguageInfo *", 0, 0, (void*)0, 0};
31708 static swig_type_info _swigt__p_wxLocale = {"_p_wxLocale", "wxLocale *", 0, 0, (void*)0, 0};
31709 static swig_type_info _swigt__p_wxMask = {"_p_wxMask", "wxMask *", 0, 0, (void*)0, 0};
31710 static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
31711 static swig_type_info _swigt__p_wxMetaFile = {"_p_wxMetaFile", "wxMetaFile *", 0, 0, (void*)0, 0};
31712 static swig_type_info _swigt__p_wxMetaFileDC = {"_p_wxMetaFileDC", "wxMetaFileDC *", 0, 0, (void*)0, 0};
31713 static swig_type_info _swigt__p_wxMirrorDC = {"_p_wxMirrorDC", "wxMirrorDC *", 0, 0, (void*)0, 0};
31714 static swig_type_info _swigt__p_wxNativeEncodingInfo = {"_p_wxNativeEncodingInfo", "wxNativeEncodingInfo *", 0, 0, (void*)0, 0};
31715 static swig_type_info _swigt__p_wxNativeFontInfo = {"_p_wxNativeFontInfo", "wxNativeFontInfo *", 0, 0, (void*)0, 0};
31716 static swig_type_info _swigt__p_wxNativePixelData = {"_p_wxNativePixelData", "wxNativePixelData *", 0, 0, (void*)0, 0};
31717 static swig_type_info _swigt__p_wxNativePixelData_Accessor = {"_p_wxNativePixelData_Accessor", "wxNativePixelData_Accessor *", 0, 0, (void*)0, 0};
31718 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
31719 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
31720 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
31721 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
31722 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
31723 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
31724 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
31725 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
31726 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
31727 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
31728 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
31729 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
31730 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
31731 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
31732 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
31733 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
31734 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
31735 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
31736 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
31737 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
31738 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
31739 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
31740 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
31741 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
31742 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
31743 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
31744 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
31745 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
31746 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
31747 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
31748 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
31749 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
31750 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
31751 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
31752 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
31753 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
31754 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
31755 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
31756 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
31757 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
31758 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
31759 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
31760 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
31761 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
31762 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
31763 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
31764 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
31765 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
31766 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
31767 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
31768 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
31769 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
31770 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
31771 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
31772 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
31773 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
31774 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
31775 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
31776 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
31777 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
31778 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
31779 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
31780 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
31781 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
31782 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
31783 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
31784 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
31785 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
31786 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
31787 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
31788 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
31789 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
31790 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
31791 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
31792 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
31793 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
31794 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
31795 static swig_type_info _swigt__p_wxPaintDC = {"_p_wxPaintDC", "wxPaintDC *", 0, 0, (void*)0, 0};
31796 static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, (void*)0, 0};
31797 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
31798 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
31799 static swig_type_info _swigt__p_wxPenList = {"_p_wxPenList", "wxPenList *", 0, 0, (void*)0, 0};
31800 static swig_type_info _swigt__p_wxPixelDataBase = {"_p_wxPixelDataBase", "wxPixelDataBase *", 0, 0, (void*)0, 0};
31801 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
31802 static swig_type_info _swigt__p_wxPostScriptDC = {"_p_wxPostScriptDC", "wxPostScriptDC *", 0, 0, (void*)0, 0};
31803 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};
31804 static swig_type_info _swigt__p_wxPrinterDC = {"_p_wxPrinterDC", "wxPrinterDC *", 0, 0, (void*)0, 0};
31805 static swig_type_info _swigt__p_wxPseudoDC = {"_p_wxPseudoDC", "wxPseudoDC *", 0, 0, (void*)0, 0};
31806 static swig_type_info _swigt__p_wxPyFontEnumerator = {"_p_wxPyFontEnumerator", "wxPyFontEnumerator *", 0, 0, (void*)0, 0};
31807 static swig_type_info _swigt__p_wxPyLocale = {"_p_wxPyLocale", "wxPyLocale *", 0, 0, (void*)0, 0};
31808 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
31809 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
31810 static swig_type_info _swigt__p_wxRegionIterator = {"_p_wxRegionIterator", "wxRegionIterator *", 0, 0, (void*)0, 0};
31811 static swig_type_info _swigt__p_wxRendererNative = {"_p_wxRendererNative", "wxRendererNative *", 0, 0, (void*)0, 0};
31812 static swig_type_info _swigt__p_wxRendererVersion = {"_p_wxRendererVersion", "wxRendererVersion *", 0, 0, (void*)0, 0};
31813 static swig_type_info _swigt__p_wxScreenDC = {"_p_wxScreenDC", "wxScreenDC *", 0, 0, (void*)0, 0};
31814 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
31815 static swig_type_info _swigt__p_wxSplitterRenderParams = {"_p_wxSplitterRenderParams", "wxSplitterRenderParams *", 0, 0, (void*)0, 0};
31816 static swig_type_info _swigt__p_wxStockGDI = {"_p_wxStockGDI", "wxStockGDI *", 0, 0, (void*)0, 0};
31817 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
31818 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
31819 static swig_type_info _swigt__p_wxWindowDC = {"_p_wxWindowDC", "wxWindowDC *", 0, 0, (void*)0, 0};
31820
31821 static swig_type_info *swig_type_initial[] = {
31822 &_swigt__p_buffer,
31823 &_swigt__p_char,
31824 &_swigt__p_double,
31825 &_swigt__p_form_ops_t,
31826 &_swigt__p_int,
31827 &_swigt__p_unsigned_char,
31828 &_swigt__p_unsigned_int,
31829 &_swigt__p_unsigned_long,
31830 &_swigt__p_wxANIHandler,
31831 &_swigt__p_wxAcceleratorTable,
31832 &_swigt__p_wxActivateEvent,
31833 &_swigt__p_wxAlphaPixelData,
31834 &_swigt__p_wxAlphaPixelData_Accessor,
31835 &_swigt__p_wxBMPHandler,
31836 &_swigt__p_wxBitmap,
31837 &_swigt__p_wxBoxSizer,
31838 &_swigt__p_wxBrush,
31839 &_swigt__p_wxBrushList,
31840 &_swigt__p_wxBufferedDC,
31841 &_swigt__p_wxBufferedPaintDC,
31842 &_swigt__p_wxCURHandler,
31843 &_swigt__p_wxChar,
31844 &_swigt__p_wxChildFocusEvent,
31845 &_swigt__p_wxClientDC,
31846 &_swigt__p_wxClipboardTextEvent,
31847 &_swigt__p_wxCloseEvent,
31848 &_swigt__p_wxColour,
31849 &_swigt__p_wxColourDatabase,
31850 &_swigt__p_wxCommandEvent,
31851 &_swigt__p_wxContextMenuEvent,
31852 &_swigt__p_wxControl,
31853 &_swigt__p_wxControlWithItems,
31854 &_swigt__p_wxCursor,
31855 &_swigt__p_wxDC,
31856 &_swigt__p_wxDash,
31857 &_swigt__p_wxDateEvent,
31858 &_swigt__p_wxDisplayChangedEvent,
31859 &_swigt__p_wxDropFilesEvent,
31860 &_swigt__p_wxDuplexMode,
31861 &_swigt__p_wxEffects,
31862 &_swigt__p_wxEncodingConverter,
31863 &_swigt__p_wxEraseEvent,
31864 &_swigt__p_wxEvent,
31865 &_swigt__p_wxEvtHandler,
31866 &_swigt__p_wxFSFile,
31867 &_swigt__p_wxFileSystem,
31868 &_swigt__p_wxFlexGridSizer,
31869 &_swigt__p_wxFocusEvent,
31870 &_swigt__p_wxFont,
31871 &_swigt__p_wxFontList,
31872 &_swigt__p_wxFontMapper,
31873 &_swigt__p_wxGBSizerItem,
31874 &_swigt__p_wxGDIObjListBase,
31875 &_swigt__p_wxGDIObject,
31876 &_swigt__p_wxGIFHandler,
31877 &_swigt__p_wxGridBagSizer,
31878 &_swigt__p_wxGridSizer,
31879 &_swigt__p_wxICOHandler,
31880 &_swigt__p_wxIcon,
31881 &_swigt__p_wxIconBundle,
31882 &_swigt__p_wxIconLocation,
31883 &_swigt__p_wxIconizeEvent,
31884 &_swigt__p_wxIdleEvent,
31885 &_swigt__p_wxImage,
31886 &_swigt__p_wxImageHandler,
31887 &_swigt__p_wxImageList,
31888 &_swigt__p_wxIndividualLayoutConstraint,
31889 &_swigt__p_wxInitDialogEvent,
31890 &_swigt__p_wxJPEGHandler,
31891 &_swigt__p_wxKeyEvent,
31892 &_swigt__p_wxLanguageInfo,
31893 &_swigt__p_wxLayoutConstraints,
31894 &_swigt__p_wxLocale,
31895 &_swigt__p_wxMask,
31896 &_swigt__p_wxMaximizeEvent,
31897 &_swigt__p_wxMemoryDC,
31898 &_swigt__p_wxMenu,
31899 &_swigt__p_wxMenuBar,
31900 &_swigt__p_wxMenuEvent,
31901 &_swigt__p_wxMenuItem,
31902 &_swigt__p_wxMetaFile,
31903 &_swigt__p_wxMetaFileDC,
31904 &_swigt__p_wxMirrorDC,
31905 &_swigt__p_wxMouseCaptureChangedEvent,
31906 &_swigt__p_wxMouseCaptureLostEvent,
31907 &_swigt__p_wxMouseEvent,
31908 &_swigt__p_wxMoveEvent,
31909 &_swigt__p_wxNativeEncodingInfo,
31910 &_swigt__p_wxNativeFontInfo,
31911 &_swigt__p_wxNativePixelData,
31912 &_swigt__p_wxNativePixelData_Accessor,
31913 &_swigt__p_wxNavigationKeyEvent,
31914 &_swigt__p_wxNcPaintEvent,
31915 &_swigt__p_wxNotifyEvent,
31916 &_swigt__p_wxObject,
31917 &_swigt__p_wxPCXHandler,
31918 &_swigt__p_wxPNGHandler,
31919 &_swigt__p_wxPNMHandler,
31920 &_swigt__p_wxPaintDC,
31921 &_swigt__p_wxPaintEvent,
31922 &_swigt__p_wxPalette,
31923 &_swigt__p_wxPaletteChangedEvent,
31924 &_swigt__p_wxPaperSize,
31925 &_swigt__p_wxPen,
31926 &_swigt__p_wxPenList,
31927 &_swigt__p_wxPixelDataBase,
31928 &_swigt__p_wxPoint,
31929 &_swigt__p_wxPostScriptDC,
31930 &_swigt__p_wxPrintData,
31931 &_swigt__p_wxPrinterDC,
31932 &_swigt__p_wxPseudoDC,
31933 &_swigt__p_wxPyApp,
31934 &_swigt__p_wxPyCommandEvent,
31935 &_swigt__p_wxPyEvent,
31936 &_swigt__p_wxPyFontEnumerator,
31937 &_swigt__p_wxPyImageHandler,
31938 &_swigt__p_wxPyLocale,
31939 &_swigt__p_wxPySizer,
31940 &_swigt__p_wxPyValidator,
31941 &_swigt__p_wxQueryNewPaletteEvent,
31942 &_swigt__p_wxRect,
31943 &_swigt__p_wxRegion,
31944 &_swigt__p_wxRegionIterator,
31945 &_swigt__p_wxRendererNative,
31946 &_swigt__p_wxRendererVersion,
31947 &_swigt__p_wxScreenDC,
31948 &_swigt__p_wxScrollEvent,
31949 &_swigt__p_wxScrollWinEvent,
31950 &_swigt__p_wxSetCursorEvent,
31951 &_swigt__p_wxShowEvent,
31952 &_swigt__p_wxSize,
31953 &_swigt__p_wxSizeEvent,
31954 &_swigt__p_wxSizer,
31955 &_swigt__p_wxSizerItem,
31956 &_swigt__p_wxSplitterRenderParams,
31957 &_swigt__p_wxStaticBoxSizer,
31958 &_swigt__p_wxStdDialogButtonSizer,
31959 &_swigt__p_wxStockGDI,
31960 &_swigt__p_wxString,
31961 &_swigt__p_wxSysColourChangedEvent,
31962 &_swigt__p_wxTIFFHandler,
31963 &_swigt__p_wxUpdateUIEvent,
31964 &_swigt__p_wxValidator,
31965 &_swigt__p_wxWindow,
31966 &_swigt__p_wxWindowCreateEvent,
31967 &_swigt__p_wxWindowDC,
31968 &_swigt__p_wxWindowDestroyEvent,
31969 &_swigt__p_wxXPMHandler,
31970 };
31971
31972 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
31973 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
31974 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
31975 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
31976 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
31977 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
31978 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
31979 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
31980 static swig_cast_info _swigc__p_wxAlphaPixelData[] = { {&_swigt__p_wxAlphaPixelData, 0, 0, 0},{0, 0, 0, 0}};
31981 static swig_cast_info _swigc__p_wxAlphaPixelData_Accessor[] = { {&_swigt__p_wxAlphaPixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
31982 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
31983 static swig_cast_info _swigc__p_wxBrush[] = { {&_swigt__p_wxBrush, 0, 0, 0},{0, 0, 0, 0}};
31984 static swig_cast_info _swigc__p_wxBrushList[] = { {&_swigt__p_wxBrushList, 0, 0, 0},{0, 0, 0, 0}};
31985 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}};
31986 static swig_cast_info _swigc__p_wxBufferedPaintDC[] = { {&_swigt__p_wxBufferedPaintDC, 0, 0, 0},{0, 0, 0, 0}};
31987 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
31988 static swig_cast_info _swigc__p_wxClientDC[] = { {&_swigt__p_wxClientDC, 0, 0, 0},{0, 0, 0, 0}};
31989 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
31990 static swig_cast_info _swigc__p_wxColourDatabase[] = { {&_swigt__p_wxColourDatabase, 0, 0, 0},{0, 0, 0, 0}};
31991 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
31992 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}};
31993 static swig_cast_info _swigc__p_wxDash[] = { {&_swigt__p_wxDash, 0, 0, 0},{0, 0, 0, 0}};
31994 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
31995 static swig_cast_info _swigc__p_wxEffects[] = { {&_swigt__p_wxEffects, 0, 0, 0},{0, 0, 0, 0}};
31996 static swig_cast_info _swigc__p_wxEncodingConverter[] = { {&_swigt__p_wxEncodingConverter, 0, 0, 0},{0, 0, 0, 0}};
31997 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
31998 static swig_cast_info _swigc__p_wxFontList[] = { {&_swigt__p_wxFontList, 0, 0, 0},{0, 0, 0, 0}};
31999 static swig_cast_info _swigc__p_wxFontMapper[] = { {&_swigt__p_wxFontMapper, 0, 0, 0},{0, 0, 0, 0}};
32000 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}};
32001 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}};
32002 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
32003 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
32004 static swig_cast_info _swigc__p_wxIconLocation[] = { {&_swigt__p_wxIconLocation, 0, 0, 0},{0, 0, 0, 0}};
32005 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
32006 static swig_cast_info _swigc__p_wxImageList[] = { {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
32007 static swig_cast_info _swigc__p_wxLanguageInfo[] = { {&_swigt__p_wxLanguageInfo, 0, 0, 0},{0, 0, 0, 0}};
32008 static swig_cast_info _swigc__p_wxLocale[] = { {&_swigt__p_wxPyLocale, _p_wxPyLocaleTo_p_wxLocale, 0, 0}, {&_swigt__p_wxLocale, 0, 0, 0},{0, 0, 0, 0}};
32009 static swig_cast_info _swigc__p_wxMask[] = { {&_swigt__p_wxMask, 0, 0, 0},{0, 0, 0, 0}};
32010 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}};
32011 static swig_cast_info _swigc__p_wxMetaFile[] = { {&_swigt__p_wxMetaFile, 0, 0, 0},{0, 0, 0, 0}};
32012 static swig_cast_info _swigc__p_wxMetaFileDC[] = { {&_swigt__p_wxMetaFileDC, 0, 0, 0},{0, 0, 0, 0}};
32013 static swig_cast_info _swigc__p_wxMirrorDC[] = { {&_swigt__p_wxMirrorDC, 0, 0, 0},{0, 0, 0, 0}};
32014 static swig_cast_info _swigc__p_wxNativeEncodingInfo[] = { {&_swigt__p_wxNativeEncodingInfo, 0, 0, 0},{0, 0, 0, 0}};
32015 static swig_cast_info _swigc__p_wxNativeFontInfo[] = { {&_swigt__p_wxNativeFontInfo, 0, 0, 0},{0, 0, 0, 0}};
32016 static swig_cast_info _swigc__p_wxNativePixelData[] = { {&_swigt__p_wxNativePixelData, 0, 0, 0},{0, 0, 0, 0}};
32017 static swig_cast_info _swigc__p_wxNativePixelData_Accessor[] = { {&_swigt__p_wxNativePixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
32018 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
32019 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32020 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32021 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
32022 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
32023 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
32024 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
32025 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
32026 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
32027 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
32028 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
32029 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
32030 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
32031 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
32032 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
32033 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
32034 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
32035 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
32036 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32037 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32038 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32039 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
32040 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
32041 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
32042 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
32043 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
32044 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
32045 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
32046 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
32047 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
32048 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
32049 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
32050 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
32051 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
32052 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32053 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32054 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32055 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
32056 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
32057 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
32058 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
32059 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
32060 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
32061 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
32062 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
32063 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
32064 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
32065 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
32066 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
32067 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
32068 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
32069 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
32070 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
32071 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
32072 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
32073 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
32074 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
32075 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
32076 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
32077 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
32078 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
32079 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
32080 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
32081 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
32082 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
32083 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
32084 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
32085 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
32086 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
32087 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
32088 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
32089 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
32090 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
32091 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
32092 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
32093 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
32094 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxRegionIterator, _p_wxRegionIteratorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPen, _p_wxPenTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMask, _p_wxMaskTo_p_wxObject, 0, 0}, {&_swigt__p_wxPseudoDC, _p_wxPseudoDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxFont, _p_wxFontTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClientDC, _p_wxClientDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxMemoryDC, _p_wxMemoryDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxRegion, _p_wxRegionTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxDC, _p_wxDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxIcon, _p_wxIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDC, _p_wxWindowDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxGDIObject, _p_wxGDIObjectTo_p_wxObject, 0, 0}, {&_swigt__p_wxEffects, _p_wxEffectsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPostScriptDC, _p_wxPostScriptDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintDC, _p_wxPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxBufferedPaintDC, _p_wxBufferedPaintDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinterDC, _p_wxPrinterDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxScreenDC, _p_wxScreenDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBufferedDC, _p_wxBufferedDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxPalette, _p_wxPaletteTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageList, _p_wxImageListTo_p_wxObject, 0, 0}, {&_swigt__p_wxCursor, _p_wxCursorTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxMirrorDC, _p_wxMirrorDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxEncodingConverter, _p_wxEncodingConverterTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFileDC, _p_wxMetaFileDCTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxBitmap, _p_wxBitmapTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBrush, _p_wxBrushTo_p_wxObject, 0, 0}, {&_swigt__p_wxMetaFile, _p_wxMetaFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxColour, _p_wxColourTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
32095 static swig_cast_info _swigc__p_wxPaintDC[] = { {&_swigt__p_wxPaintDC, 0, 0, 0},{0, 0, 0, 0}};
32096 static swig_cast_info _swigc__p_wxPalette[] = { {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
32097 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
32098 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
32099 static swig_cast_info _swigc__p_wxPenList[] = { {&_swigt__p_wxPenList, 0, 0, 0},{0, 0, 0, 0}};
32100 static swig_cast_info _swigc__p_wxPixelDataBase[] = { {&_swigt__p_wxPixelDataBase, 0, 0, 0}, {&_swigt__p_wxNativePixelData, _p_wxNativePixelDataTo_p_wxPixelDataBase, 0, 0}, {&_swigt__p_wxAlphaPixelData, _p_wxAlphaPixelDataTo_p_wxPixelDataBase, 0, 0},{0, 0, 0, 0}};
32101 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
32102 static swig_cast_info _swigc__p_wxPostScriptDC[] = { {&_swigt__p_wxPostScriptDC, 0, 0, 0},{0, 0, 0, 0}};
32103 static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
32104 static swig_cast_info _swigc__p_wxPrinterDC[] = { {&_swigt__p_wxPrinterDC, 0, 0, 0},{0, 0, 0, 0}};
32105 static swig_cast_info _swigc__p_wxPseudoDC[] = { {&_swigt__p_wxPseudoDC, 0, 0, 0},{0, 0, 0, 0}};
32106 static swig_cast_info _swigc__p_wxPyFontEnumerator[] = { {&_swigt__p_wxPyFontEnumerator, 0, 0, 0},{0, 0, 0, 0}};
32107 static swig_cast_info _swigc__p_wxPyLocale[] = { {&_swigt__p_wxPyLocale, 0, 0, 0},{0, 0, 0, 0}};
32108 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
32109 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
32110 static swig_cast_info _swigc__p_wxRegionIterator[] = { {&_swigt__p_wxRegionIterator, 0, 0, 0},{0, 0, 0, 0}};
32111 static swig_cast_info _swigc__p_wxRendererNative[] = { {&_swigt__p_wxRendererNative, 0, 0, 0},{0, 0, 0, 0}};
32112 static swig_cast_info _swigc__p_wxRendererVersion[] = { {&_swigt__p_wxRendererVersion, 0, 0, 0},{0, 0, 0, 0}};
32113 static swig_cast_info _swigc__p_wxScreenDC[] = { {&_swigt__p_wxScreenDC, 0, 0, 0},{0, 0, 0, 0}};
32114 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
32115 static swig_cast_info _swigc__p_wxSplitterRenderParams[] = { {&_swigt__p_wxSplitterRenderParams, 0, 0, 0},{0, 0, 0, 0}};
32116 static swig_cast_info _swigc__p_wxStockGDI[] = { {&_swigt__p_wxStockGDI, 0, 0, 0},{0, 0, 0, 0}};
32117 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
32118 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}};
32119 static swig_cast_info _swigc__p_wxWindowDC[] = { {&_swigt__p_wxWindowDC, 0, 0, 0},{0, 0, 0, 0}};
32120
32121 static swig_cast_info *swig_cast_initial[] = {
32122 _swigc__p_buffer,
32123 _swigc__p_char,
32124 _swigc__p_double,
32125 _swigc__p_form_ops_t,
32126 _swigc__p_int,
32127 _swigc__p_unsigned_char,
32128 _swigc__p_unsigned_int,
32129 _swigc__p_unsigned_long,
32130 _swigc__p_wxANIHandler,
32131 _swigc__p_wxAcceleratorTable,
32132 _swigc__p_wxActivateEvent,
32133 _swigc__p_wxAlphaPixelData,
32134 _swigc__p_wxAlphaPixelData_Accessor,
32135 _swigc__p_wxBMPHandler,
32136 _swigc__p_wxBitmap,
32137 _swigc__p_wxBoxSizer,
32138 _swigc__p_wxBrush,
32139 _swigc__p_wxBrushList,
32140 _swigc__p_wxBufferedDC,
32141 _swigc__p_wxBufferedPaintDC,
32142 _swigc__p_wxCURHandler,
32143 _swigc__p_wxChar,
32144 _swigc__p_wxChildFocusEvent,
32145 _swigc__p_wxClientDC,
32146 _swigc__p_wxClipboardTextEvent,
32147 _swigc__p_wxCloseEvent,
32148 _swigc__p_wxColour,
32149 _swigc__p_wxColourDatabase,
32150 _swigc__p_wxCommandEvent,
32151 _swigc__p_wxContextMenuEvent,
32152 _swigc__p_wxControl,
32153 _swigc__p_wxControlWithItems,
32154 _swigc__p_wxCursor,
32155 _swigc__p_wxDC,
32156 _swigc__p_wxDash,
32157 _swigc__p_wxDateEvent,
32158 _swigc__p_wxDisplayChangedEvent,
32159 _swigc__p_wxDropFilesEvent,
32160 _swigc__p_wxDuplexMode,
32161 _swigc__p_wxEffects,
32162 _swigc__p_wxEncodingConverter,
32163 _swigc__p_wxEraseEvent,
32164 _swigc__p_wxEvent,
32165 _swigc__p_wxEvtHandler,
32166 _swigc__p_wxFSFile,
32167 _swigc__p_wxFileSystem,
32168 _swigc__p_wxFlexGridSizer,
32169 _swigc__p_wxFocusEvent,
32170 _swigc__p_wxFont,
32171 _swigc__p_wxFontList,
32172 _swigc__p_wxFontMapper,
32173 _swigc__p_wxGBSizerItem,
32174 _swigc__p_wxGDIObjListBase,
32175 _swigc__p_wxGDIObject,
32176 _swigc__p_wxGIFHandler,
32177 _swigc__p_wxGridBagSizer,
32178 _swigc__p_wxGridSizer,
32179 _swigc__p_wxICOHandler,
32180 _swigc__p_wxIcon,
32181 _swigc__p_wxIconBundle,
32182 _swigc__p_wxIconLocation,
32183 _swigc__p_wxIconizeEvent,
32184 _swigc__p_wxIdleEvent,
32185 _swigc__p_wxImage,
32186 _swigc__p_wxImageHandler,
32187 _swigc__p_wxImageList,
32188 _swigc__p_wxIndividualLayoutConstraint,
32189 _swigc__p_wxInitDialogEvent,
32190 _swigc__p_wxJPEGHandler,
32191 _swigc__p_wxKeyEvent,
32192 _swigc__p_wxLanguageInfo,
32193 _swigc__p_wxLayoutConstraints,
32194 _swigc__p_wxLocale,
32195 _swigc__p_wxMask,
32196 _swigc__p_wxMaximizeEvent,
32197 _swigc__p_wxMemoryDC,
32198 _swigc__p_wxMenu,
32199 _swigc__p_wxMenuBar,
32200 _swigc__p_wxMenuEvent,
32201 _swigc__p_wxMenuItem,
32202 _swigc__p_wxMetaFile,
32203 _swigc__p_wxMetaFileDC,
32204 _swigc__p_wxMirrorDC,
32205 _swigc__p_wxMouseCaptureChangedEvent,
32206 _swigc__p_wxMouseCaptureLostEvent,
32207 _swigc__p_wxMouseEvent,
32208 _swigc__p_wxMoveEvent,
32209 _swigc__p_wxNativeEncodingInfo,
32210 _swigc__p_wxNativeFontInfo,
32211 _swigc__p_wxNativePixelData,
32212 _swigc__p_wxNativePixelData_Accessor,
32213 _swigc__p_wxNavigationKeyEvent,
32214 _swigc__p_wxNcPaintEvent,
32215 _swigc__p_wxNotifyEvent,
32216 _swigc__p_wxObject,
32217 _swigc__p_wxPCXHandler,
32218 _swigc__p_wxPNGHandler,
32219 _swigc__p_wxPNMHandler,
32220 _swigc__p_wxPaintDC,
32221 _swigc__p_wxPaintEvent,
32222 _swigc__p_wxPalette,
32223 _swigc__p_wxPaletteChangedEvent,
32224 _swigc__p_wxPaperSize,
32225 _swigc__p_wxPen,
32226 _swigc__p_wxPenList,
32227 _swigc__p_wxPixelDataBase,
32228 _swigc__p_wxPoint,
32229 _swigc__p_wxPostScriptDC,
32230 _swigc__p_wxPrintData,
32231 _swigc__p_wxPrinterDC,
32232 _swigc__p_wxPseudoDC,
32233 _swigc__p_wxPyApp,
32234 _swigc__p_wxPyCommandEvent,
32235 _swigc__p_wxPyEvent,
32236 _swigc__p_wxPyFontEnumerator,
32237 _swigc__p_wxPyImageHandler,
32238 _swigc__p_wxPyLocale,
32239 _swigc__p_wxPySizer,
32240 _swigc__p_wxPyValidator,
32241 _swigc__p_wxQueryNewPaletteEvent,
32242 _swigc__p_wxRect,
32243 _swigc__p_wxRegion,
32244 _swigc__p_wxRegionIterator,
32245 _swigc__p_wxRendererNative,
32246 _swigc__p_wxRendererVersion,
32247 _swigc__p_wxScreenDC,
32248 _swigc__p_wxScrollEvent,
32249 _swigc__p_wxScrollWinEvent,
32250 _swigc__p_wxSetCursorEvent,
32251 _swigc__p_wxShowEvent,
32252 _swigc__p_wxSize,
32253 _swigc__p_wxSizeEvent,
32254 _swigc__p_wxSizer,
32255 _swigc__p_wxSizerItem,
32256 _swigc__p_wxSplitterRenderParams,
32257 _swigc__p_wxStaticBoxSizer,
32258 _swigc__p_wxStdDialogButtonSizer,
32259 _swigc__p_wxStockGDI,
32260 _swigc__p_wxString,
32261 _swigc__p_wxSysColourChangedEvent,
32262 _swigc__p_wxTIFFHandler,
32263 _swigc__p_wxUpdateUIEvent,
32264 _swigc__p_wxValidator,
32265 _swigc__p_wxWindow,
32266 _swigc__p_wxWindowCreateEvent,
32267 _swigc__p_wxWindowDC,
32268 _swigc__p_wxWindowDestroyEvent,
32269 _swigc__p_wxXPMHandler,
32270 };
32271
32272
32273 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32274
32275 static swig_const_info swig_const_table[] = {
32276 {0, 0, 0, 0.0, 0, 0}};
32277
32278 #ifdef __cplusplus
32279 }
32280 #endif
32281 /* -----------------------------------------------------------------------------
32282 * Type initialization:
32283 * This problem is tough by the requirement that no dynamic
32284 * memory is used. Also, since swig_type_info structures store pointers to
32285 * swig_cast_info structures and swig_cast_info structures store pointers back
32286 * to swig_type_info structures, we need some lookup code at initialization.
32287 * The idea is that swig generates all the structures that are needed.
32288 * The runtime then collects these partially filled structures.
32289 * The SWIG_InitializeModule function takes these initial arrays out of
32290 * swig_module, and does all the lookup, filling in the swig_module.types
32291 * array with the correct data and linking the correct swig_cast_info
32292 * structures together.
32293 *
32294 * The generated swig_type_info structures are assigned staticly to an initial
32295 * array. We just loop though that array, and handle each type individually.
32296 * First we lookup if this type has been already loaded, and if so, use the
32297 * loaded structure instead of the generated one. Then we have to fill in the
32298 * cast linked list. The cast data is initially stored in something like a
32299 * two-dimensional array. Each row corresponds to a type (there are the same
32300 * number of rows as there are in the swig_type_initial array). Each entry in
32301 * a column is one of the swig_cast_info structures for that type.
32302 * The cast_initial array is actually an array of arrays, because each row has
32303 * a variable number of columns. So to actually build the cast linked list,
32304 * we find the array of casts associated with the type, and loop through it
32305 * adding the casts to the list. The one last trick we need to do is making
32306 * sure the type pointer in the swig_cast_info struct is correct.
32307 *
32308 * First off, we lookup the cast->type name to see if it is already loaded.
32309 * There are three cases to handle:
32310 * 1) If the cast->type has already been loaded AND the type we are adding
32311 * casting info to has not been loaded (it is in this module), THEN we
32312 * replace the cast->type pointer with the type pointer that has already
32313 * been loaded.
32314 * 2) If BOTH types (the one we are adding casting info to, and the
32315 * cast->type) are loaded, THEN the cast info has already been loaded by
32316 * the previous module so we just ignore it.
32317 * 3) Finally, if cast->type has not already been loaded, then we add that
32318 * swig_cast_info to the linked list (because the cast->type) pointer will
32319 * be correct.
32320 * ----------------------------------------------------------------------------- */
32321
32322 #ifdef __cplusplus
32323 extern "C" {
32324 #if 0
32325 } /* c-mode */
32326 #endif
32327 #endif
32328
32329 #if 0
32330 #define SWIGRUNTIME_DEBUG
32331 #endif
32332
32333 SWIGRUNTIME void
32334 SWIG_InitializeModule(void *clientdata) {
32335 size_t i;
32336 swig_module_info *module_head;
32337 static int init_run = 0;
32338
32339 clientdata = clientdata;
32340
32341 if (init_run) return;
32342 init_run = 1;
32343
32344 /* Initialize the swig_module */
32345 swig_module.type_initial = swig_type_initial;
32346 swig_module.cast_initial = swig_cast_initial;
32347
32348 /* Try and load any already created modules */
32349 module_head = SWIG_GetModule(clientdata);
32350 if (module_head) {
32351 swig_module.next = module_head->next;
32352 module_head->next = &swig_module;
32353 } else {
32354 /* This is the first module loaded */
32355 swig_module.next = &swig_module;
32356 SWIG_SetModule(clientdata, &swig_module);
32357 }
32358
32359 /* Now work on filling in swig_module.types */
32360 #ifdef SWIGRUNTIME_DEBUG
32361 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32362 #endif
32363 for (i = 0; i < swig_module.size; ++i) {
32364 swig_type_info *type = 0;
32365 swig_type_info *ret;
32366 swig_cast_info *cast;
32367
32368 #ifdef SWIGRUNTIME_DEBUG
32369 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32370 #endif
32371
32372 /* if there is another module already loaded */
32373 if (swig_module.next != &swig_module) {
32374 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
32375 }
32376 if (type) {
32377 /* Overwrite clientdata field */
32378 #ifdef SWIGRUNTIME_DEBUG
32379 printf("SWIG_InitializeModule: found type %s\n", type->name);
32380 #endif
32381 if (swig_module.type_initial[i]->clientdata) {
32382 type->clientdata = swig_module.type_initial[i]->clientdata;
32383 #ifdef SWIGRUNTIME_DEBUG
32384 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32385 #endif
32386 }
32387 } else {
32388 type = swig_module.type_initial[i];
32389 }
32390
32391 /* Insert casting types */
32392 cast = swig_module.cast_initial[i];
32393 while (cast->type) {
32394 /* Don't need to add information already in the list */
32395 ret = 0;
32396 #ifdef SWIGRUNTIME_DEBUG
32397 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32398 #endif
32399 if (swig_module.next != &swig_module) {
32400 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32401 #ifdef SWIGRUNTIME_DEBUG
32402 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32403 #endif
32404 }
32405 if (ret) {
32406 if (type == swig_module.type_initial[i]) {
32407 #ifdef SWIGRUNTIME_DEBUG
32408 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32409 #endif
32410 cast->type = ret;
32411 ret = 0;
32412 } else {
32413 /* Check for casting already in the list */
32414 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32415 #ifdef SWIGRUNTIME_DEBUG
32416 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32417 #endif
32418 if (!ocast) ret = 0;
32419 }
32420 }
32421
32422 if (!ret) {
32423 #ifdef SWIGRUNTIME_DEBUG
32424 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32425 #endif
32426 if (type->cast) {
32427 type->cast->prev = cast;
32428 cast->next = type->cast;
32429 }
32430 type->cast = cast;
32431 }
32432 cast++;
32433 }
32434 /* Set entry in modules->types array equal to the type */
32435 swig_module.types[i] = type;
32436 }
32437 swig_module.types[i] = 0;
32438
32439 #ifdef SWIGRUNTIME_DEBUG
32440 printf("**** SWIG_InitializeModule: Cast List ******\n");
32441 for (i = 0; i < swig_module.size; ++i) {
32442 int j = 0;
32443 swig_cast_info *cast = swig_module.cast_initial[i];
32444 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32445 while (cast->type) {
32446 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
32447 cast++;
32448 ++j;
32449 }
32450 printf("---- Total casts: %d\n",j);
32451 }
32452 printf("**** SWIG_InitializeModule: Cast List ******\n");
32453 #endif
32454 }
32455
32456 /* This function will propagate the clientdata field of type to
32457 * any new swig_type_info structures that have been added into the list
32458 * of equivalent types. It is like calling
32459 * SWIG_TypeClientData(type, clientdata) a second time.
32460 */
32461 SWIGRUNTIME void
32462 SWIG_PropagateClientData(void) {
32463 size_t i;
32464 swig_cast_info *equiv;
32465 static int init_run = 0;
32466
32467 if (init_run) return;
32468 init_run = 1;
32469
32470 for (i = 0; i < swig_module.size; i++) {
32471 if (swig_module.types[i]->clientdata) {
32472 equiv = swig_module.types[i]->cast;
32473 while (equiv) {
32474 if (!equiv->converter) {
32475 if (equiv->type && !equiv->type->clientdata)
32476 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32477 }
32478 equiv = equiv->next;
32479 }
32480 }
32481 }
32482 }
32483
32484 #ifdef __cplusplus
32485 #if 0
32486 {
32487 /* c-mode */
32488 #endif
32489 }
32490 #endif
32491
32492
32493
32494 #ifdef __cplusplus
32495 extern "C" {
32496 #endif
32497
32498 /* Python-specific SWIG API */
32499 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32500 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32501 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32502
32503 /* -----------------------------------------------------------------------------
32504 * global variable support code.
32505 * ----------------------------------------------------------------------------- */
32506
32507 typedef struct swig_globalvar {
32508 char *name; /* Name of global variable */
32509 PyObject *(*get_attr)(void); /* Return the current value */
32510 int (*set_attr)(PyObject *); /* Set the value */
32511 struct swig_globalvar *next;
32512 } swig_globalvar;
32513
32514 typedef struct swig_varlinkobject {
32515 PyObject_HEAD
32516 swig_globalvar *vars;
32517 } swig_varlinkobject;
32518
32519 SWIGINTERN PyObject *
32520 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
32521 return PyString_FromString("<Swig global variables>");
32522 }
32523
32524 SWIGINTERN PyObject *
32525 swig_varlink_str(swig_varlinkobject *v) {
32526 PyObject *str = PyString_FromString("(");
32527 swig_globalvar *var;
32528 for (var = v->vars; var; var=var->next) {
32529 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
32530 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
32531 }
32532 PyString_ConcatAndDel(&str,PyString_FromString(")"));
32533 return str;
32534 }
32535
32536 SWIGINTERN int
32537 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
32538 PyObject *str = swig_varlink_str(v);
32539 fprintf(fp,"Swig global variables ");
32540 fprintf(fp,"%s\n", PyString_AsString(str));
32541 Py_DECREF(str);
32542 return 0;
32543 }
32544
32545 SWIGINTERN void
32546 swig_varlink_dealloc(swig_varlinkobject *v) {
32547 swig_globalvar *var = v->vars;
32548 while (var) {
32549 swig_globalvar *n = var->next;
32550 free(var->name);
32551 free(var);
32552 var = n;
32553 }
32554 }
32555
32556 SWIGINTERN PyObject *
32557 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32558 PyObject *res = NULL;
32559 swig_globalvar *var = v->vars;
32560 while (var) {
32561 if (strcmp(var->name,n) == 0) {
32562 res = (*var->get_attr)();
32563 break;
32564 }
32565 var = var->next;
32566 }
32567 if (res == NULL && !PyErr_Occurred()) {
32568 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32569 }
32570 return res;
32571 }
32572
32573 SWIGINTERN int
32574 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32575 int res = 1;
32576 swig_globalvar *var = v->vars;
32577 while (var) {
32578 if (strcmp(var->name,n) == 0) {
32579 res = (*var->set_attr)(p);
32580 break;
32581 }
32582 var = var->next;
32583 }
32584 if (res == 1 && !PyErr_Occurred()) {
32585 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32586 }
32587 return res;
32588 }
32589
32590 SWIGINTERN PyTypeObject*
32591 swig_varlink_type(void) {
32592 static char varlink__doc__[] = "Swig var link object";
32593 static PyTypeObject varlink_type;
32594 static int type_init = 0;
32595 if (!type_init) {
32596 const PyTypeObject tmp
32597 = {
32598 PyObject_HEAD_INIT(NULL)
32599 0, /* Number of items in variable part (ob_size) */
32600 (char *)"swigvarlink", /* Type name (tp_name) */
32601 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32602 0, /* Itemsize (tp_itemsize) */
32603 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
32604 (printfunc) swig_varlink_print, /* Print (tp_print) */
32605 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32606 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32607 0, /* tp_compare */
32608 (reprfunc) swig_varlink_repr, /* tp_repr */
32609 0, /* tp_as_number */
32610 0, /* tp_as_sequence */
32611 0, /* tp_as_mapping */
32612 0, /* tp_hash */
32613 0, /* tp_call */
32614 (reprfunc)swig_varlink_str, /* tp_str */
32615 0, /* tp_getattro */
32616 0, /* tp_setattro */
32617 0, /* tp_as_buffer */
32618 0, /* tp_flags */
32619 varlink__doc__, /* tp_doc */
32620 0, /* tp_traverse */
32621 0, /* tp_clear */
32622 0, /* tp_richcompare */
32623 0, /* tp_weaklistoffset */
32624 #if PY_VERSION_HEX >= 0x02020000
32625 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32626 #endif
32627 #if PY_VERSION_HEX >= 0x02030000
32628 0, /* tp_del */
32629 #endif
32630 #ifdef COUNT_ALLOCS
32631 0,0,0,0 /* tp_alloc -> tp_next */
32632 #endif
32633 };
32634 varlink_type = tmp;
32635 varlink_type.ob_type = &PyType_Type;
32636 type_init = 1;
32637 }
32638 return &varlink_type;
32639 }
32640
32641 /* Create a variable linking object for use later */
32642 SWIGINTERN PyObject *
32643 SWIG_Python_newvarlink(void) {
32644 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
32645 if (result) {
32646 result->vars = 0;
32647 }
32648 return ((PyObject*) result);
32649 }
32650
32651 SWIGINTERN void
32652 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32653 swig_varlinkobject *v = (swig_varlinkobject *) p;
32654 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32655 if (gv) {
32656 size_t size = strlen(name)+1;
32657 gv->name = (char *)malloc(size);
32658 if (gv->name) {
32659 strncpy(gv->name,name,size);
32660 gv->get_attr = get_attr;
32661 gv->set_attr = set_attr;
32662 gv->next = v->vars;
32663 }
32664 }
32665 v->vars = gv;
32666 }
32667
32668 SWIGINTERN PyObject *
32669 SWIG_globals() {
32670 static PyObject *_SWIG_globals = 0;
32671 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
32672 return _SWIG_globals;
32673 }
32674
32675 /* -----------------------------------------------------------------------------
32676 * constants/methods manipulation
32677 * ----------------------------------------------------------------------------- */
32678
32679 /* Install Constants */
32680 SWIGINTERN void
32681 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32682 PyObject *obj = 0;
32683 size_t i;
32684 for (i = 0; constants[i].type; ++i) {
32685 switch(constants[i].type) {
32686 case SWIG_PY_POINTER:
32687 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32688 break;
32689 case SWIG_PY_BINARY:
32690 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32691 break;
32692 default:
32693 obj = 0;
32694 break;
32695 }
32696 if (obj) {
32697 PyDict_SetItemString(d, constants[i].name, obj);
32698 Py_DECREF(obj);
32699 }
32700 }
32701 }
32702
32703 /* -----------------------------------------------------------------------------*/
32704 /* Fix SwigMethods to carry the callback ptrs when needed */
32705 /* -----------------------------------------------------------------------------*/
32706
32707 SWIGINTERN void
32708 SWIG_Python_FixMethods(PyMethodDef *methods,
32709 swig_const_info *const_table,
32710 swig_type_info **types,
32711 swig_type_info **types_initial) {
32712 size_t i;
32713 for (i = 0; methods[i].ml_name; ++i) {
32714 const char *c = methods[i].ml_doc;
32715 if (c && (c = strstr(c, "swig_ptr: "))) {
32716 int j;
32717 swig_const_info *ci = 0;
32718 const char *name = c + 10;
32719 for (j = 0; const_table[j].type; ++j) {
32720 if (strncmp(const_table[j].name, name,
32721 strlen(const_table[j].name)) == 0) {
32722 ci = &(const_table[j]);
32723 break;
32724 }
32725 }
32726 if (ci) {
32727 size_t shift = (ci->ptype) - types;
32728 swig_type_info *ty = types_initial[shift];
32729 size_t ldoc = (c - methods[i].ml_doc);
32730 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32731 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32732 if (ndoc) {
32733 char *buff = ndoc;
32734 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
32735 if (ptr) {
32736 strncpy(buff, methods[i].ml_doc, ldoc);
32737 buff += ldoc;
32738 strncpy(buff, "swig_ptr: ", 10);
32739 buff += 10;
32740 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32741 methods[i].ml_doc = ndoc;
32742 }
32743 }
32744 }
32745 }
32746 }
32747 }
32748
32749 #ifdef __cplusplus
32750 }
32751 #endif
32752
32753 /* -----------------------------------------------------------------------------*
32754 * Partial Init method
32755 * -----------------------------------------------------------------------------*/
32756
32757 #ifdef __cplusplus
32758 extern "C"
32759 #endif
32760 SWIGEXPORT void SWIG_init(void) {
32761 PyObject *m, *d;
32762
32763 /* Fix SwigMethods to carry the callback ptrs when needed */
32764 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
32765
32766 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32767 d = PyModule_GetDict(m);
32768
32769 SWIG_InitializeModule(0);
32770 SWIG_InstallConstants(d,swig_const_table);
32771
32772
32773 SWIG_Python_SetConstant(d, "C2S_NAME",SWIG_From_int(static_cast< int >(wxC2S_NAME)));
32774 SWIG_Python_SetConstant(d, "C2S_CSS_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_CSS_SYNTAX)));
32775 SWIG_Python_SetConstant(d, "C2S_HTML_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_HTML_SYNTAX)));
32776 SWIG_Python_SetConstant(d, "ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxALPHA_TRANSPARENT)));
32777 SWIG_Python_SetConstant(d, "ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxALPHA_OPAQUE)));
32778 SWIG_Python_SetConstant(d, "OutRegion",SWIG_From_int(static_cast< int >(wxOutRegion)));
32779 SWIG_Python_SetConstant(d, "PartRegion",SWIG_From_int(static_cast< int >(wxPartRegion)));
32780 SWIG_Python_SetConstant(d, "InRegion",SWIG_From_int(static_cast< int >(wxInRegion)));
32781 SWIG_Python_SetConstant(d, "FONTFAMILY_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DEFAULT)));
32782 SWIG_Python_SetConstant(d, "FONTFAMILY_DECORATIVE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DECORATIVE)));
32783 SWIG_Python_SetConstant(d, "FONTFAMILY_ROMAN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_ROMAN)));
32784 SWIG_Python_SetConstant(d, "FONTFAMILY_SCRIPT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SCRIPT)));
32785 SWIG_Python_SetConstant(d, "FONTFAMILY_SWISS",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SWISS)));
32786 SWIG_Python_SetConstant(d, "FONTFAMILY_MODERN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MODERN)));
32787 SWIG_Python_SetConstant(d, "FONTFAMILY_TELETYPE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_TELETYPE)));
32788 SWIG_Python_SetConstant(d, "FONTFAMILY_MAX",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MAX)));
32789 SWIG_Python_SetConstant(d, "FONTFAMILY_UNKNOWN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_UNKNOWN)));
32790 SWIG_Python_SetConstant(d, "FONTSTYLE_NORMAL",SWIG_From_int(static_cast< int >(wxFONTSTYLE_NORMAL)));
32791 SWIG_Python_SetConstant(d, "FONTSTYLE_ITALIC",SWIG_From_int(static_cast< int >(wxFONTSTYLE_ITALIC)));
32792 SWIG_Python_SetConstant(d, "FONTSTYLE_SLANT",SWIG_From_int(static_cast< int >(wxFONTSTYLE_SLANT)));
32793 SWIG_Python_SetConstant(d, "FONTSTYLE_MAX",SWIG_From_int(static_cast< int >(wxFONTSTYLE_MAX)));
32794 SWIG_Python_SetConstant(d, "FONTWEIGHT_NORMAL",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_NORMAL)));
32795 SWIG_Python_SetConstant(d, "FONTWEIGHT_LIGHT",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_LIGHT)));
32796 SWIG_Python_SetConstant(d, "FONTWEIGHT_BOLD",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_BOLD)));
32797 SWIG_Python_SetConstant(d, "FONTWEIGHT_MAX",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_MAX)));
32798 SWIG_Python_SetConstant(d, "FONTFLAG_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFLAG_DEFAULT)));
32799 SWIG_Python_SetConstant(d, "FONTFLAG_ITALIC",SWIG_From_int(static_cast< int >(wxFONTFLAG_ITALIC)));
32800 SWIG_Python_SetConstant(d, "FONTFLAG_SLANT",SWIG_From_int(static_cast< int >(wxFONTFLAG_SLANT)));
32801 SWIG_Python_SetConstant(d, "FONTFLAG_LIGHT",SWIG_From_int(static_cast< int >(wxFONTFLAG_LIGHT)));
32802 SWIG_Python_SetConstant(d, "FONTFLAG_BOLD",SWIG_From_int(static_cast< int >(wxFONTFLAG_BOLD)));
32803 SWIG_Python_SetConstant(d, "FONTFLAG_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_ANTIALIASED)));
32804 SWIG_Python_SetConstant(d, "FONTFLAG_NOT_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_NOT_ANTIALIASED)));
32805 SWIG_Python_SetConstant(d, "FONTFLAG_UNDERLINED",SWIG_From_int(static_cast< int >(wxFONTFLAG_UNDERLINED)));
32806 SWIG_Python_SetConstant(d, "FONTFLAG_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxFONTFLAG_STRIKETHROUGH)));
32807 SWIG_Python_SetConstant(d, "FONTFLAG_MASK",SWIG_From_int(static_cast< int >(wxFONTFLAG_MASK)));
32808 SWIG_Python_SetConstant(d, "FONTENCODING_SYSTEM",SWIG_From_int(static_cast< int >(wxFONTENCODING_SYSTEM)));
32809 SWIG_Python_SetConstant(d, "FONTENCODING_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTENCODING_DEFAULT)));
32810 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_1",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_1)));
32811 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_2",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_2)));
32812 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_3",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_3)));
32813 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_4",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_4)));
32814 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_5",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_5)));
32815 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_6",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_6)));
32816 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_7",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_7)));
32817 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_8",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_8)));
32818 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_9",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_9)));
32819 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_10",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_10)));
32820 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_11",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_11)));
32821 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_12",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_12)));
32822 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_13",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_13)));
32823 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_14",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_14)));
32824 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_15",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_15)));
32825 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_MAX)));
32826 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8)));
32827 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8_U",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8_U)));
32828 SWIG_Python_SetConstant(d, "FONTENCODING_ALTERNATIVE",SWIG_From_int(static_cast< int >(wxFONTENCODING_ALTERNATIVE)));
32829 SWIG_Python_SetConstant(d, "FONTENCODING_BULGARIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_BULGARIAN)));
32830 SWIG_Python_SetConstant(d, "FONTENCODING_CP437",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP437)));
32831 SWIG_Python_SetConstant(d, "FONTENCODING_CP850",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP850)));
32832 SWIG_Python_SetConstant(d, "FONTENCODING_CP852",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP852)));
32833 SWIG_Python_SetConstant(d, "FONTENCODING_CP855",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP855)));
32834 SWIG_Python_SetConstant(d, "FONTENCODING_CP866",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP866)));
32835 SWIG_Python_SetConstant(d, "FONTENCODING_CP874",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP874)));
32836 SWIG_Python_SetConstant(d, "FONTENCODING_CP932",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP932)));
32837 SWIG_Python_SetConstant(d, "FONTENCODING_CP936",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP936)));
32838 SWIG_Python_SetConstant(d, "FONTENCODING_CP949",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP949)));
32839 SWIG_Python_SetConstant(d, "FONTENCODING_CP950",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP950)));
32840 SWIG_Python_SetConstant(d, "FONTENCODING_CP1250",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1250)));
32841 SWIG_Python_SetConstant(d, "FONTENCODING_CP1251",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1251)));
32842 SWIG_Python_SetConstant(d, "FONTENCODING_CP1252",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1252)));
32843 SWIG_Python_SetConstant(d, "FONTENCODING_CP1253",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1253)));
32844 SWIG_Python_SetConstant(d, "FONTENCODING_CP1254",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1254)));
32845 SWIG_Python_SetConstant(d, "FONTENCODING_CP1255",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1255)));
32846 SWIG_Python_SetConstant(d, "FONTENCODING_CP1256",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1256)));
32847 SWIG_Python_SetConstant(d, "FONTENCODING_CP1257",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1257)));
32848 SWIG_Python_SetConstant(d, "FONTENCODING_CP12_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP12_MAX)));
32849 SWIG_Python_SetConstant(d, "FONTENCODING_UTF7",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF7)));
32850 SWIG_Python_SetConstant(d, "FONTENCODING_UTF8",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF8)));
32851 SWIG_Python_SetConstant(d, "FONTENCODING_EUC_JP",SWIG_From_int(static_cast< int >(wxFONTENCODING_EUC_JP)));
32852 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16BE)));
32853 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16LE)));
32854 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32BE)));
32855 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32LE)));
32856 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMAN)));
32857 SWIG_Python_SetConstant(d, "FONTENCODING_MACJAPANESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACJAPANESE)));
32858 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESETRAD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESETRAD)));
32859 SWIG_Python_SetConstant(d, "FONTENCODING_MACKOREAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKOREAN)));
32860 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABIC)));
32861 SWIG_Python_SetConstant(d, "FONTENCODING_MACHEBREW",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACHEBREW)));
32862 SWIG_Python_SetConstant(d, "FONTENCODING_MACGREEK",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGREEK)));
32863 SWIG_Python_SetConstant(d, "FONTENCODING_MACCYRILLIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCYRILLIC)));
32864 SWIG_Python_SetConstant(d, "FONTENCODING_MACDEVANAGARI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDEVANAGARI)));
32865 SWIG_Python_SetConstant(d, "FONTENCODING_MACGURMUKHI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGURMUKHI)));
32866 SWIG_Python_SetConstant(d, "FONTENCODING_MACGUJARATI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGUJARATI)));
32867 SWIG_Python_SetConstant(d, "FONTENCODING_MACORIYA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACORIYA)));
32868 SWIG_Python_SetConstant(d, "FONTENCODING_MACBENGALI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBENGALI)));
32869 SWIG_Python_SetConstant(d, "FONTENCODING_MACTAMIL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTAMIL)));
32870 SWIG_Python_SetConstant(d, "FONTENCODING_MACTELUGU",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTELUGU)));
32871 SWIG_Python_SetConstant(d, "FONTENCODING_MACKANNADA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKANNADA)));
32872 SWIG_Python_SetConstant(d, "FONTENCODING_MACMALAJALAM",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMALAJALAM)));
32873 SWIG_Python_SetConstant(d, "FONTENCODING_MACSINHALESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSINHALESE)));
32874 SWIG_Python_SetConstant(d, "FONTENCODING_MACBURMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBURMESE)));
32875 SWIG_Python_SetConstant(d, "FONTENCODING_MACKHMER",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKHMER)));
32876 SWIG_Python_SetConstant(d, "FONTENCODING_MACTHAI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTHAI)));
32877 SWIG_Python_SetConstant(d, "FONTENCODING_MACLAOTIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACLAOTIAN)));
32878 SWIG_Python_SetConstant(d, "FONTENCODING_MACGEORGIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGEORGIAN)));
32879 SWIG_Python_SetConstant(d, "FONTENCODING_MACARMENIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARMENIAN)));
32880 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESESIMP",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESESIMP)));
32881 SWIG_Python_SetConstant(d, "FONTENCODING_MACTIBETAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTIBETAN)));
32882 SWIG_Python_SetConstant(d, "FONTENCODING_MACMONGOLIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMONGOLIAN)));
32883 SWIG_Python_SetConstant(d, "FONTENCODING_MACETHIOPIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACETHIOPIC)));
32884 SWIG_Python_SetConstant(d, "FONTENCODING_MACCENTRALEUR",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCENTRALEUR)));
32885 SWIG_Python_SetConstant(d, "FONTENCODING_MACVIATNAMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACVIATNAMESE)));
32886 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABICEXT",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABICEXT)));
32887 SWIG_Python_SetConstant(d, "FONTENCODING_MACSYMBOL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSYMBOL)));
32888 SWIG_Python_SetConstant(d, "FONTENCODING_MACDINGBATS",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDINGBATS)));
32889 SWIG_Python_SetConstant(d, "FONTENCODING_MACTURKISH",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTURKISH)));
32890 SWIG_Python_SetConstant(d, "FONTENCODING_MACCROATIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCROATIAN)));
32891 SWIG_Python_SetConstant(d, "FONTENCODING_MACICELANDIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACICELANDIC)));
32892 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMANIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMANIAN)));
32893 SWIG_Python_SetConstant(d, "FONTENCODING_MACCELTIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCELTIC)));
32894 SWIG_Python_SetConstant(d, "FONTENCODING_MACGAELIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGAELIC)));
32895 SWIG_Python_SetConstant(d, "FONTENCODING_MACKEYBOARD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKEYBOARD)));
32896 SWIG_Python_SetConstant(d, "FONTENCODING_MACMIN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMIN)));
32897 SWIG_Python_SetConstant(d, "FONTENCODING_MACMAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMAX)));
32898 SWIG_Python_SetConstant(d, "FONTENCODING_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MAX)));
32899 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16)));
32900 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32)));
32901 SWIG_Python_SetConstant(d, "FONTENCODING_UNICODE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UNICODE)));
32902 SWIG_Python_SetConstant(d, "FONTENCODING_GB2312",SWIG_From_int(static_cast< int >(wxFONTENCODING_GB2312)));
32903 SWIG_Python_SetConstant(d, "FONTENCODING_BIG5",SWIG_From_int(static_cast< int >(wxFONTENCODING_BIG5)));
32904 SWIG_Python_SetConstant(d, "FONTENCODING_SHIFT_JIS",SWIG_From_int(static_cast< int >(wxFONTENCODING_SHIFT_JIS)));
32905
32906 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
32907
32908 SWIG_Python_SetConstant(d, "LANGUAGE_DEFAULT",SWIG_From_int(static_cast< int >(wxLANGUAGE_DEFAULT)));
32909 SWIG_Python_SetConstant(d, "LANGUAGE_UNKNOWN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UNKNOWN)));
32910 SWIG_Python_SetConstant(d, "LANGUAGE_ABKHAZIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ABKHAZIAN)));
32911 SWIG_Python_SetConstant(d, "LANGUAGE_AFAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFAR)));
32912 SWIG_Python_SetConstant(d, "LANGUAGE_AFRIKAANS",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFRIKAANS)));
32913 SWIG_Python_SetConstant(d, "LANGUAGE_ALBANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ALBANIAN)));
32914 SWIG_Python_SetConstant(d, "LANGUAGE_AMHARIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AMHARIC)));
32915 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC)));
32916 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_ALGERIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_ALGERIA)));
32917 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_BAHRAIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_BAHRAIN)));
32918 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_EGYPT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_EGYPT)));
32919 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_IRAQ",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_IRAQ)));
32920 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_JORDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_JORDAN)));
32921 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_KUWAIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_KUWAIT)));
32922 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LEBANON",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LEBANON)));
32923 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LIBYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LIBYA)));
32924 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_MOROCCO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_MOROCCO)));
32925 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_OMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_OMAN)));
32926 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_QATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_QATAR)));
32927 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SAUDI_ARABIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
32928 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SUDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SUDAN)));
32929 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SYRIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SYRIA)));
32930 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_TUNISIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_TUNISIA)));
32931 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_UAE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_UAE)));
32932 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_YEMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_YEMEN)));
32933 SWIG_Python_SetConstant(d, "LANGUAGE_ARMENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARMENIAN)));
32934 SWIG_Python_SetConstant(d, "LANGUAGE_ASSAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ASSAMESE)));
32935 SWIG_Python_SetConstant(d, "LANGUAGE_AYMARA",SWIG_From_int(static_cast< int >(wxLANGUAGE_AYMARA)));
32936 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI)));
32937 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_CYRILLIC)));
32938 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_LATIN)));
32939 SWIG_Python_SetConstant(d, "LANGUAGE_BASHKIR",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASHKIR)));
32940 SWIG_Python_SetConstant(d, "LANGUAGE_BASQUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASQUE)));
32941 SWIG_Python_SetConstant(d, "LANGUAGE_BELARUSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BELARUSIAN)));
32942 SWIG_Python_SetConstant(d, "LANGUAGE_BENGALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BENGALI)));
32943 SWIG_Python_SetConstant(d, "LANGUAGE_BHUTANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BHUTANI)));
32944 SWIG_Python_SetConstant(d, "LANGUAGE_BIHARI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BIHARI)));
32945 SWIG_Python_SetConstant(d, "LANGUAGE_BISLAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_BISLAMA)));
32946 SWIG_Python_SetConstant(d, "LANGUAGE_BRETON",SWIG_From_int(static_cast< int >(wxLANGUAGE_BRETON)));
32947 SWIG_Python_SetConstant(d, "LANGUAGE_BULGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BULGARIAN)));
32948 SWIG_Python_SetConstant(d, "LANGUAGE_BURMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BURMESE)));
32949 SWIG_Python_SetConstant(d, "LANGUAGE_CAMBODIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CAMBODIAN)));
32950 SWIG_Python_SetConstant(d, "LANGUAGE_CATALAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CATALAN)));
32951 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE)));
32952 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SIMPLIFIED",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SIMPLIFIED)));
32953 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TRADITIONAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TRADITIONAL)));
32954 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_HONGKONG",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_HONGKONG)));
32955 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_MACAU",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_MACAU)));
32956 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SINGAPORE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SINGAPORE)));
32957 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TAIWAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TAIWAN)));
32958 SWIG_Python_SetConstant(d, "LANGUAGE_CORSICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CORSICAN)));
32959 SWIG_Python_SetConstant(d, "LANGUAGE_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CROATIAN)));
32960 SWIG_Python_SetConstant(d, "LANGUAGE_CZECH",SWIG_From_int(static_cast< int >(wxLANGUAGE_CZECH)));
32961 SWIG_Python_SetConstant(d, "LANGUAGE_DANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DANISH)));
32962 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH)));
32963 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH_BELGIAN)));
32964 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH)));
32965 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_UK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_UK)));
32966 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_US)));
32967 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_AUSTRALIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_AUSTRALIA)));
32968 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BELIZE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BELIZE)));
32969 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BOTSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BOTSWANA)));
32970 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CANADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CANADA)));
32971 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CARIBBEAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CARIBBEAN)));
32972 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_DENMARK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_DENMARK)));
32973 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_EIRE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_EIRE)));
32974 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_JAMAICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_JAMAICA)));
32975 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_NEW_ZEALAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
32976 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_PHILIPPINES",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_PHILIPPINES)));
32977 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_SOUTH_AFRICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
32978 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_TRINIDAD",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_TRINIDAD)));
32979 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_ZIMBABWE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_ZIMBABWE)));
32980 SWIG_Python_SetConstant(d, "LANGUAGE_ESPERANTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESPERANTO)));
32981 SWIG_Python_SetConstant(d, "LANGUAGE_ESTONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESTONIAN)));
32982 SWIG_Python_SetConstant(d, "LANGUAGE_FAEROESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_FAEROESE)));
32983 SWIG_Python_SetConstant(d, "LANGUAGE_FARSI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FARSI)));
32984 SWIG_Python_SetConstant(d, "LANGUAGE_FIJI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FIJI)));
32985 SWIG_Python_SetConstant(d, "LANGUAGE_FINNISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FINNISH)));
32986 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH)));
32987 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_BELGIAN)));
32988 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_CANADIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_CANADIAN)));
32989 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_LUXEMBOURG)));
32990 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_MONACO",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_MONACO)));
32991 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_SWISS)));
32992 SWIG_Python_SetConstant(d, "LANGUAGE_FRISIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRISIAN)));
32993 SWIG_Python_SetConstant(d, "LANGUAGE_GALICIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GALICIAN)));
32994 SWIG_Python_SetConstant(d, "LANGUAGE_GEORGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GEORGIAN)));
32995 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN)));
32996 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_AUSTRIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_AUSTRIAN)));
32997 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_BELGIUM",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_BELGIUM)));
32998 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LIECHTENSTEIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
32999 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LUXEMBOURG)));
33000 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_SWISS)));
33001 SWIG_Python_SetConstant(d, "LANGUAGE_GREEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREEK)));
33002 SWIG_Python_SetConstant(d, "LANGUAGE_GREENLANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREENLANDIC)));
33003 SWIG_Python_SetConstant(d, "LANGUAGE_GUARANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUARANI)));
33004 SWIG_Python_SetConstant(d, "LANGUAGE_GUJARATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUJARATI)));
33005 SWIG_Python_SetConstant(d, "LANGUAGE_HAUSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_HAUSA)));
33006 SWIG_Python_SetConstant(d, "LANGUAGE_HEBREW",SWIG_From_int(static_cast< int >(wxLANGUAGE_HEBREW)));
33007 SWIG_Python_SetConstant(d, "LANGUAGE_HINDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_HINDI)));
33008 SWIG_Python_SetConstant(d, "LANGUAGE_HUNGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_HUNGARIAN)));
33009 SWIG_Python_SetConstant(d, "LANGUAGE_ICELANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ICELANDIC)));
33010 SWIG_Python_SetConstant(d, "LANGUAGE_INDONESIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_INDONESIAN)));
33011 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUA)));
33012 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUE)));
33013 SWIG_Python_SetConstant(d, "LANGUAGE_INUKTITUT",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUKTITUT)));
33014 SWIG_Python_SetConstant(d, "LANGUAGE_INUPIAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUPIAK)));
33015 SWIG_Python_SetConstant(d, "LANGUAGE_IRISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_IRISH)));
33016 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN)));
33017 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN_SWISS)));
33018 SWIG_Python_SetConstant(d, "LANGUAGE_JAPANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAPANESE)));
33019 SWIG_Python_SetConstant(d, "LANGUAGE_JAVANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAVANESE)));
33020 SWIG_Python_SetConstant(d, "LANGUAGE_KANNADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KANNADA)));
33021 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI)));
33022 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI_INDIA)));
33023 SWIG_Python_SetConstant(d, "LANGUAGE_KAZAKH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KAZAKH)));
33024 SWIG_Python_SetConstant(d, "LANGUAGE_KERNEWEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_KERNEWEK)));
33025 SWIG_Python_SetConstant(d, "LANGUAGE_KINYARWANDA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KINYARWANDA)));
33026 SWIG_Python_SetConstant(d, "LANGUAGE_KIRGHIZ",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRGHIZ)));
33027 SWIG_Python_SetConstant(d, "LANGUAGE_KIRUNDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRUNDI)));
33028 SWIG_Python_SetConstant(d, "LANGUAGE_KONKANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KONKANI)));
33029 SWIG_Python_SetConstant(d, "LANGUAGE_KOREAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_KOREAN)));
33030 SWIG_Python_SetConstant(d, "LANGUAGE_KURDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KURDISH)));
33031 SWIG_Python_SetConstant(d, "LANGUAGE_LAOTHIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LAOTHIAN)));
33032 SWIG_Python_SetConstant(d, "LANGUAGE_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATIN)));
33033 SWIG_Python_SetConstant(d, "LANGUAGE_LATVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATVIAN)));
33034 SWIG_Python_SetConstant(d, "LANGUAGE_LINGALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_LINGALA)));
33035 SWIG_Python_SetConstant(d, "LANGUAGE_LITHUANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LITHUANIAN)));
33036 SWIG_Python_SetConstant(d, "LANGUAGE_MACEDONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MACEDONIAN)));
33037 SWIG_Python_SetConstant(d, "LANGUAGE_MALAGASY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAGASY)));
33038 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY)));
33039 SWIG_Python_SetConstant(d, "LANGUAGE_MALAYALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAYALAM)));
33040 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_BRUNEI_DARUSSALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
33041 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_MALAYSIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_MALAYSIA)));
33042 SWIG_Python_SetConstant(d, "LANGUAGE_MALTESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALTESE)));
33043 SWIG_Python_SetConstant(d, "LANGUAGE_MANIPURI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MANIPURI)));
33044 SWIG_Python_SetConstant(d, "LANGUAGE_MAORI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MAORI)));
33045 SWIG_Python_SetConstant(d, "LANGUAGE_MARATHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MARATHI)));
33046 SWIG_Python_SetConstant(d, "LANGUAGE_MOLDAVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MOLDAVIAN)));
33047 SWIG_Python_SetConstant(d, "LANGUAGE_MONGOLIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MONGOLIAN)));
33048 SWIG_Python_SetConstant(d, "LANGUAGE_NAURU",SWIG_From_int(static_cast< int >(wxLANGUAGE_NAURU)));
33049 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI)));
33050 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI_INDIA)));
33051 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_BOKMAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_BOKMAL)));
33052 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_NYNORSK",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_NYNORSK)));
33053 SWIG_Python_SetConstant(d, "LANGUAGE_OCCITAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_OCCITAN)));
33054 SWIG_Python_SetConstant(d, "LANGUAGE_ORIYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ORIYA)));
33055 SWIG_Python_SetConstant(d, "LANGUAGE_OROMO",SWIG_From_int(static_cast< int >(wxLANGUAGE_OROMO)));
33056 SWIG_Python_SetConstant(d, "LANGUAGE_PASHTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_PASHTO)));
33057 SWIG_Python_SetConstant(d, "LANGUAGE_POLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_POLISH)));
33058 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE)));
33059 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE_BRAZILIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
33060 SWIG_Python_SetConstant(d, "LANGUAGE_PUNJABI",SWIG_From_int(static_cast< int >(wxLANGUAGE_PUNJABI)));
33061 SWIG_Python_SetConstant(d, "LANGUAGE_QUECHUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_QUECHUA)));
33062 SWIG_Python_SetConstant(d, "LANGUAGE_RHAETO_ROMANCE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RHAETO_ROMANCE)));
33063 SWIG_Python_SetConstant(d, "LANGUAGE_ROMANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ROMANIAN)));
33064 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN)));
33065 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN_UKRAINE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN_UKRAINE)));
33066 SWIG_Python_SetConstant(d, "LANGUAGE_SAMOAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SAMOAN)));
33067 SWIG_Python_SetConstant(d, "LANGUAGE_SANGHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANGHO)));
33068 SWIG_Python_SetConstant(d, "LANGUAGE_SANSKRIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANSKRIT)));
33069 SWIG_Python_SetConstant(d, "LANGUAGE_SCOTS_GAELIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SCOTS_GAELIC)));
33070 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN)));
33071 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_CYRILLIC)));
33072 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_LATIN)));
33073 SWIG_Python_SetConstant(d, "LANGUAGE_SERBO_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBO_CROATIAN)));
33074 SWIG_Python_SetConstant(d, "LANGUAGE_SESOTHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SESOTHO)));
33075 SWIG_Python_SetConstant(d, "LANGUAGE_SETSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SETSWANA)));
33076 SWIG_Python_SetConstant(d, "LANGUAGE_SHONA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SHONA)));
33077 SWIG_Python_SetConstant(d, "LANGUAGE_SINDHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINDHI)));
33078 SWIG_Python_SetConstant(d, "LANGUAGE_SINHALESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINHALESE)));
33079 SWIG_Python_SetConstant(d, "LANGUAGE_SISWATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SISWATI)));
33080 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVAK)));
33081 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVENIAN)));
33082 SWIG_Python_SetConstant(d, "LANGUAGE_SOMALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SOMALI)));
33083 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH)));
33084 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ARGENTINA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ARGENTINA)));
33085 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_BOLIVIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_BOLIVIA)));
33086 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_CHILE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_CHILE)));
33087 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COLOMBIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COLOMBIA)));
33088 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COSTA_RICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COSTA_RICA)));
33089 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_DOMINICAN_REPUBLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
33090 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ECUADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ECUADOR)));
33091 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_EL_SALVADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_EL_SALVADOR)));
33092 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_GUATEMALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_GUATEMALA)));
33093 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_HONDURAS",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_HONDURAS)));
33094 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MEXICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MEXICAN)));
33095 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MODERN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MODERN)));
33096 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_NICARAGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_NICARAGUA)));
33097 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PANAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PANAMA)));
33098 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PARAGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PARAGUAY)));
33099 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PERU",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PERU)));
33100 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PUERTO_RICO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PUERTO_RICO)));
33101 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_URUGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_URUGUAY)));
33102 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_US)));
33103 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_VENEZUELA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_VENEZUELA)));
33104 SWIG_Python_SetConstant(d, "LANGUAGE_SUNDANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SUNDANESE)));
33105 SWIG_Python_SetConstant(d, "LANGUAGE_SWAHILI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWAHILI)));
33106 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH)));
33107 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH_FINLAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH_FINLAND)));
33108 SWIG_Python_SetConstant(d, "LANGUAGE_TAGALOG",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAGALOG)));
33109 SWIG_Python_SetConstant(d, "LANGUAGE_TAJIK",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAJIK)));
33110 SWIG_Python_SetConstant(d, "LANGUAGE_TAMIL",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAMIL)));
33111 SWIG_Python_SetConstant(d, "LANGUAGE_TATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_TATAR)));
33112 SWIG_Python_SetConstant(d, "LANGUAGE_TELUGU",SWIG_From_int(static_cast< int >(wxLANGUAGE_TELUGU)));
33113 SWIG_Python_SetConstant(d, "LANGUAGE_THAI",SWIG_From_int(static_cast< int >(wxLANGUAGE_THAI)));
33114 SWIG_Python_SetConstant(d, "LANGUAGE_TIBETAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIBETAN)));
33115 SWIG_Python_SetConstant(d, "LANGUAGE_TIGRINYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIGRINYA)));
33116 SWIG_Python_SetConstant(d, "LANGUAGE_TONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TONGA)));
33117 SWIG_Python_SetConstant(d, "LANGUAGE_TSONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TSONGA)));
33118 SWIG_Python_SetConstant(d, "LANGUAGE_TURKISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKISH)));
33119 SWIG_Python_SetConstant(d, "LANGUAGE_TURKMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKMEN)));
33120 SWIG_Python_SetConstant(d, "LANGUAGE_TWI",SWIG_From_int(static_cast< int >(wxLANGUAGE_TWI)));
33121 SWIG_Python_SetConstant(d, "LANGUAGE_UIGHUR",SWIG_From_int(static_cast< int >(wxLANGUAGE_UIGHUR)));
33122 SWIG_Python_SetConstant(d, "LANGUAGE_UKRAINIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UKRAINIAN)));
33123 SWIG_Python_SetConstant(d, "LANGUAGE_URDU",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU)));
33124 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_INDIA)));
33125 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_PAKISTAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_PAKISTAN)));
33126 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK)));
33127 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_CYRILLIC)));
33128 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_LATIN)));
33129 SWIG_Python_SetConstant(d, "LANGUAGE_VIETNAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_VIETNAMESE)));
33130 SWIG_Python_SetConstant(d, "LANGUAGE_VOLAPUK",SWIG_From_int(static_cast< int >(wxLANGUAGE_VOLAPUK)));
33131 SWIG_Python_SetConstant(d, "LANGUAGE_WELSH",SWIG_From_int(static_cast< int >(wxLANGUAGE_WELSH)));
33132 SWIG_Python_SetConstant(d, "LANGUAGE_WOLOF",SWIG_From_int(static_cast< int >(wxLANGUAGE_WOLOF)));
33133 SWIG_Python_SetConstant(d, "LANGUAGE_XHOSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_XHOSA)));
33134 SWIG_Python_SetConstant(d, "LANGUAGE_YIDDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_YIDDISH)));
33135 SWIG_Python_SetConstant(d, "LANGUAGE_YORUBA",SWIG_From_int(static_cast< int >(wxLANGUAGE_YORUBA)));
33136 SWIG_Python_SetConstant(d, "LANGUAGE_ZHUANG",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZHUANG)));
33137 SWIG_Python_SetConstant(d, "LANGUAGE_ZULU",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZULU)));
33138 SWIG_Python_SetConstant(d, "LANGUAGE_USER_DEFINED",SWIG_From_int(static_cast< int >(wxLANGUAGE_USER_DEFINED)));
33139 SWIG_Python_SetConstant(d, "LOCALE_CAT_NUMBER",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_NUMBER)));
33140 SWIG_Python_SetConstant(d, "LOCALE_CAT_DATE",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_DATE)));
33141 SWIG_Python_SetConstant(d, "LOCALE_CAT_MONEY",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MONEY)));
33142 SWIG_Python_SetConstant(d, "LOCALE_CAT_MAX",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MAX)));
33143 SWIG_Python_SetConstant(d, "LOCALE_THOUSANDS_SEP",SWIG_From_int(static_cast< int >(wxLOCALE_THOUSANDS_SEP)));
33144 SWIG_Python_SetConstant(d, "LOCALE_DECIMAL_POINT",SWIG_From_int(static_cast< int >(wxLOCALE_DECIMAL_POINT)));
33145 SWIG_Python_SetConstant(d, "LOCALE_LOAD_DEFAULT",SWIG_From_int(static_cast< int >(wxLOCALE_LOAD_DEFAULT)));
33146 SWIG_Python_SetConstant(d, "LOCALE_CONV_ENCODING",SWIG_From_int(static_cast< int >(wxLOCALE_CONV_ENCODING)));
33147 SWIG_Python_SetConstant(d, "CONVERT_STRICT",SWIG_From_int(static_cast< int >(wxCONVERT_STRICT)));
33148 SWIG_Python_SetConstant(d, "CONVERT_SUBSTITUTE",SWIG_From_int(static_cast< int >(wxCONVERT_SUBSTITUTE)));
33149 SWIG_Python_SetConstant(d, "PLATFORM_CURRENT",SWIG_From_int(static_cast< int >(wxPLATFORM_CURRENT)));
33150 SWIG_Python_SetConstant(d, "PLATFORM_UNIX",SWIG_From_int(static_cast< int >(wxPLATFORM_UNIX)));
33151 SWIG_Python_SetConstant(d, "PLATFORM_WINDOWS",SWIG_From_int(static_cast< int >(wxPLATFORM_WINDOWS)));
33152 SWIG_Python_SetConstant(d, "PLATFORM_OS2",SWIG_From_int(static_cast< int >(wxPLATFORM_OS2)));
33153 SWIG_Python_SetConstant(d, "PLATFORM_MAC",SWIG_From_int(static_cast< int >(wxPLATFORM_MAC)));
33154 SWIG_Python_SetConstant(d, "BUFFER_VIRTUAL_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_VIRTUAL_AREA)));
33155 SWIG_Python_SetConstant(d, "BUFFER_CLIENT_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_CLIENT_AREA)));
33156 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_NORMAL)));
33157 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_TRANSPARENT)));
33158 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_SELECTED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_SELECTED)));
33159 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_FOCUSED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_FOCUSED)));
33160 SWIG_Python_SetConstant(d, "IMAGE_LIST_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_NORMAL)));
33161 SWIG_Python_SetConstant(d, "IMAGE_LIST_SMALL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_SMALL)));
33162 SWIG_Python_SetConstant(d, "IMAGE_LIST_STATE",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_STATE)));
33163 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLACK)));
33164 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLUE)));
33165 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_CYAN)));
33166 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREEN)));
33167 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREY)));
33168 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_LIGHTGREY)));
33169 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_MEDIUMGREY)));
33170 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_RED",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_RED)));
33171 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_TRANSPARENT)));
33172 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_WHITE)));
33173 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLACK)));
33174 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLUE)));
33175 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_CYAN)));
33176 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_GREEN)));
33177 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_LIGHTGREY)));
33178 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_RED",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_RED)));
33179 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_WHITE)));
33180 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_CROSS)));
33181 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_HOURGLASS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_HOURGLASS)));
33182 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_STANDARD",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_STANDARD)));
33183 SWIG_Python_SetConstant(d, "StockGDI_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_ITALIC)));
33184 SWIG_Python_SetConstant(d, "StockGDI_FONT_NORMAL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_NORMAL)));
33185 SWIG_Python_SetConstant(d, "StockGDI_FONT_SMALL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SMALL)));
33186 SWIG_Python_SetConstant(d, "StockGDI_FONT_SWISS",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SWISS)));
33187 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACK)));
33188 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACKDASHED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACKDASHED)));
33189 SWIG_Python_SetConstant(d, "StockGDI_PEN_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_CYAN)));
33190 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREEN)));
33191 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREY)));
33192 SWIG_Python_SetConstant(d, "StockGDI_PEN_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_LIGHTGREY)));
33193 SWIG_Python_SetConstant(d, "StockGDI_PEN_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_MEDIUMGREY)));
33194 SWIG_Python_SetConstant(d, "StockGDI_PEN_RED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_RED)));
33195 SWIG_Python_SetConstant(d, "StockGDI_PEN_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_TRANSPARENT)));
33196 SWIG_Python_SetConstant(d, "StockGDI_PEN_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_WHITE)));
33197 SWIG_Python_SetConstant(d, "StockGDI_ITEMCOUNT",SWIG_From_int(static_cast< int >(wxStockGDI::ITEMCOUNT)));
33198 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
33199 SWIG_addvarlink(SWIG_globals(),(char*)"NullBitmap",NullBitmap_get, NullBitmap_set);
33200 SWIG_addvarlink(SWIG_globals(),(char*)"NullIcon",NullIcon_get, NullIcon_set);
33201 SWIG_addvarlink(SWIG_globals(),(char*)"NullCursor",NullCursor_get, NullCursor_set);
33202 SWIG_addvarlink(SWIG_globals(),(char*)"NullPen",NullPen_get, NullPen_set);
33203 SWIG_addvarlink(SWIG_globals(),(char*)"NullBrush",NullBrush_get, NullBrush_set);
33204 SWIG_addvarlink(SWIG_globals(),(char*)"NullPalette",NullPalette_get, NullPalette_set);
33205 SWIG_addvarlink(SWIG_globals(),(char*)"NullFont",NullFont_get, NullFont_set);
33206 SWIG_addvarlink(SWIG_globals(),(char*)"NullColour",NullColour_get, NullColour_set);
33207 SWIG_Python_SetConstant(d, "CONTROL_DISABLED",SWIG_From_int(static_cast< int >(wxCONTROL_DISABLED)));
33208 SWIG_Python_SetConstant(d, "CONTROL_FOCUSED",SWIG_From_int(static_cast< int >(wxCONTROL_FOCUSED)));
33209 SWIG_Python_SetConstant(d, "CONTROL_PRESSED",SWIG_From_int(static_cast< int >(wxCONTROL_PRESSED)));
33210 SWIG_Python_SetConstant(d, "CONTROL_ISDEFAULT",SWIG_From_int(static_cast< int >(wxCONTROL_ISDEFAULT)));
33211 SWIG_Python_SetConstant(d, "CONTROL_ISSUBMENU",SWIG_From_int(static_cast< int >(wxCONTROL_ISSUBMENU)));
33212 SWIG_Python_SetConstant(d, "CONTROL_EXPANDED",SWIG_From_int(static_cast< int >(wxCONTROL_EXPANDED)));
33213 SWIG_Python_SetConstant(d, "CONTROL_CURRENT",SWIG_From_int(static_cast< int >(wxCONTROL_CURRENT)));
33214 SWIG_Python_SetConstant(d, "CONTROL_SELECTED",SWIG_From_int(static_cast< int >(wxCONTROL_SELECTED)));
33215 SWIG_Python_SetConstant(d, "CONTROL_CHECKED",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKED)));
33216 SWIG_Python_SetConstant(d, "CONTROL_CHECKABLE",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKABLE)));
33217 SWIG_Python_SetConstant(d, "CONTROL_UNDETERMINED",SWIG_From_int(static_cast< int >(wxCONTROL_UNDETERMINED)));
33218 SWIG_Python_SetConstant(d, "CONTROL_FLAGS_MASK",SWIG_From_int(static_cast< int >(wxCONTROL_FLAGS_MASK)));
33219 SWIG_Python_SetConstant(d, "CONTROL_DIRTY",SWIG_From_int(static_cast< int >(wxCONTROL_DIRTY)));
33220 SWIG_Python_SetConstant(d, "RendererVersion_Current_Version",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Version)));
33221 SWIG_Python_SetConstant(d, "RendererVersion_Current_Age",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Age)));
33222
33223 // Work around a chicken/egg problem in drawlist.cpp
33224 wxPyDrawList_SetAPIPtr();
33225
33226 }
33227
wxWidgets (Impactor)