projects / wxWidgets.git / blob
? search:


ec1eab7b195ec12eb0fd850a3c6f0de6ee1c99ef
[wxWidgets.git] / wxPython / src / msw / _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 void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
2946 SWIGINTERN wxSize wxBitmap_GetSize(wxBitmap *self){
2947 wxSize size(self->GetWidth(), self->GetHeight());
2948 return size;
2949 }
2950 SWIGINTERN void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
2951 wxMask *mask = new wxMask(*self, colour);
2952 self->SetMask(mask);
2953 }
2954 SWIGINTERN void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
2955 self->SetWidth(size.x);
2956 self->SetHeight(size.y);
2957 }
2958 SWIGINTERN bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
2959 SWIGINTERN bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
2960
2961 // See http://tinyurl.com/e5adr for what premultiplying alpha means. It
2962 // appears to me that the other platforms are already doing it, so I'll just
2963 // automatically do it for wxMSW here.
2964 #ifdef __WXMSW__
2965 #define wxPy_premultiply(p, a) ((p) * (a) / 256)
2966 #define wxPy_unpremultiply(p, a) ((a) ? ((p) * 256 / (a)) : (p))
2967 #else
2968 #define wxPy_premultiply(p, a) (p)
2969 #define wxPy_unpremultiply(p, a) (p)
2970 #endif
2971
2972
2973 wxBitmap* _BitmapFromBufferAlpha(int width, int height,
2974 buffer data, int DATASIZE,
2975 buffer alpha, int ALPHASIZE)
2976 {
2977 if (DATASIZE != width*height*3) {
2978 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2979 return NULL;
2980 }
2981
2982 if (ALPHASIZE != width*height) {
2983 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2984 return NULL;
2985 }
2986
2987 wxBitmap* bmp = new wxBitmap(width, height, 32);
2988 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
2989 if (! pixData) {
2990 // raise an exception...
2991 wxPyErr_SetString(PyExc_RuntimeError,
2992 "Failed to gain raw access to bitmap data.");
2993 return NULL;
2994 }
2995
2996 pixData.UseAlpha();
2997 wxAlphaPixelData::Iterator p(pixData);
2998 for (int y=0; y<height; y++) {
2999 wxAlphaPixelData::Iterator rowStart = p;
3000 for (int x=0; x<width; x++) {
3001 byte a = *(alpha++);
3002 p.Red() = wxPy_premultiply(*(data++), a);
3003 p.Green() = wxPy_premultiply(*(data++), a);
3004 p.Blue() = wxPy_premultiply(*(data++), a);
3005 p.Alpha() = a;
3006 ++p;
3007 }
3008 p = rowStart;
3009 p.OffsetY(pixData, 1);
3010 }
3011 return bmp;
3012 }
3013
3014 wxBitmap* _BitmapFromBuffer(int width, int height, buffer data, int DATASIZE)
3015 {
3016 if (DATASIZE != width*height*3) {
3017 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3018 return NULL;
3019 }
3020
3021 wxBitmap* bmp = new wxBitmap(width, height, 24);
3022 wxNativePixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3023 if (! pixData) {
3024 // raise an exception...
3025 wxPyErr_SetString(PyExc_RuntimeError,
3026 "Failed to gain raw access to bitmap data.");
3027 return NULL;
3028 }
3029
3030 wxNativePixelData::Iterator p(pixData);
3031 for (int y=0; y<height; y++) {
3032 wxNativePixelData::Iterator rowStart = p;
3033 for (int x=0; x<width; x++) {
3034 p.Red() = *(data++);
3035 p.Green() = *(data++);
3036 p.Blue() = *(data++);
3037 ++p;
3038 }
3039 p = rowStart;
3040 p.OffsetY(pixData, 1);
3041 }
3042 return bmp;
3043 }
3044
3045
3046 wxBitmap* _BitmapFromBufferRGBA(int width, int height, buffer data, int DATASIZE)
3047 {
3048 if (DATASIZE != width*height*4) {
3049 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3050 return NULL;
3051 }
3052
3053 wxBitmap* bmp = new wxBitmap(width, height, 32);
3054 wxAlphaPixelData pixData(*bmp, wxPoint(0,0), wxSize(width,height));
3055 if (! pixData) {
3056 // raise an exception...
3057 wxPyErr_SetString(PyExc_RuntimeError,
3058 "Failed to gain raw access to bitmap data.");
3059 return NULL;
3060 }
3061
3062 pixData.UseAlpha();
3063 wxAlphaPixelData::Iterator p(pixData);
3064 for (int y=0; y<height; y++) {
3065 wxAlphaPixelData::Iterator rowStart = p;
3066 for (int x=0; x<width; x++) {
3067 byte a = data[3];
3068 p.Red() = wxPy_premultiply(*(data++), a);
3069 p.Green() = wxPy_premultiply(*(data++), a);
3070 p.Blue() = wxPy_premultiply(*(data++), a);
3071 p.Alpha() = a; data++;
3072 ++p;
3073 }
3074 p = rowStart;
3075 p.OffsetY(pixData, 1);
3076 }
3077 return bmp;
3078 }
3079
3080
3081 typedef wxNativePixelData::Iterator wxNativePixelData_Accessor;
3082
3083 SWIGINTERN bool wxNativePixelData___nonzero__(wxNativePixelData *self){ return self->operator bool(); }
3084 SWIGINTERN void wxNativePixelData_Accessor_nextPixel(wxNativePixelData_Accessor *self){ ++(*self); }
3085 SWIGINTERN void wxNativePixelData_Accessor_Set(wxNativePixelData_Accessor *self,byte red,byte green,byte blue){
3086 self->Red() = red;
3087 self->Green() = green;
3088 self->Blue() = blue;
3089 }
3090 SWIGINTERN PyObject *wxNativePixelData_Accessor_Get(wxNativePixelData_Accessor *self){
3091 PyObject* rv = PyTuple_New(3);
3092 PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
3093 PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
3094 PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
3095 return rv;
3096 }
3097
3098 typedef wxAlphaPixelData::Iterator wxAlphaPixelData_Accessor;
3099
3100 SWIGINTERN bool wxAlphaPixelData___nonzero__(wxAlphaPixelData *self){ return self->operator bool(); }
3101 SWIGINTERN void wxAlphaPixelData_Accessor_nextPixel(wxAlphaPixelData_Accessor *self){ ++(*self); }
3102 SWIGINTERN void wxAlphaPixelData_Accessor_Set(wxAlphaPixelData_Accessor *self,byte red,byte green,byte blue,byte alpha){
3103 self->Red() = wxPy_premultiply(red, alpha);
3104 self->Green() = wxPy_premultiply(green, alpha);
3105 self->Blue() = wxPy_premultiply(blue, alpha);
3106 self->Alpha() = alpha;
3107 }
3108 SWIGINTERN PyObject *wxAlphaPixelData_Accessor_Get(wxAlphaPixelData_Accessor *self){
3109 PyObject* rv = PyTuple_New(4);
3110 int red = self->Red();
3111 int green = self->Green();
3112 int blue = self->Blue();
3113 int alpha = self->Alpha();
3114
3115 PyTuple_SetItem(rv, 0, PyInt_FromLong( wxPy_unpremultiply(red, alpha) ));
3116 PyTuple_SetItem(rv, 1, PyInt_FromLong( wxPy_unpremultiply(green, alpha) ));
3117 PyTuple_SetItem(rv, 2, PyInt_FromLong( wxPy_unpremultiply(blue, alpha) ));
3118 PyTuple_SetItem(rv, 3, PyInt_FromLong( alpha ));
3119 return rv;
3120 }
3121 SWIGINTERN wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
3122 if ( !colour.Ok() )
3123 return new wxMask(bitmap, *wxBLACK);
3124 else
3125 return new wxMask(bitmap, colour);
3126 }
3127
3128 #include <wx/iconbndl.h>
3129
3130 SWIGINTERN wxIcon *new_wxIcon(wxBitmap const &bmp){
3131 wxIcon* icon = new wxIcon();
3132 icon->CopyFromBitmap(bmp);
3133 return icon;
3134 }
3135 SWIGINTERN wxIcon *new_wxIcon(PyObject *listOfStrings){
3136 char** cArray = NULL;
3137 wxIcon* icon;
3138
3139 cArray = ConvertListOfStrings(listOfStrings);
3140 if (! cArray)
3141 return NULL;
3142 icon = new wxIcon(cArray);
3143 delete [] cArray;
3144 return icon;
3145 }
3146 SWIGINTERN void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
3147 SWIGINTERN wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
3148
3149 return new wxIconLocation(*filename, num);
3150
3151
3152
3153 }
3154 SWIGINTERN void wxIconLocation_SetIndex(wxIconLocation *self,int num){
3155
3156 self->SetIndex(num);
3157
3158
3159
3160 }
3161 SWIGINTERN int wxIconLocation_GetIndex(wxIconLocation *self){
3162
3163 return self->GetIndex();
3164
3165
3166
3167 }
3168 SWIGINTERN wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
3169 #ifdef __WXGTK__
3170 wxImage img(cursorName, type);
3171 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
3172 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
3173 return new wxCursor(img);
3174 #else
3175 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
3176 #endif
3177 }
3178 SWIGINTERN void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
3179
3180
3181 SWIGINTERN void wxRegionIterator_Next(wxRegionIterator *self){
3182 (*self) ++;
3183 }
3184 SWIGINTERN bool wxRegionIterator___nonzero__(wxRegionIterator *self){
3185 return self->operator bool();
3186 }
3187
3188 #include <wx/fontutil.h>
3189 #include <wx/fontmap.h>
3190 #include <wx/fontenum.h>
3191
3192 SWIGINTERN wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
3193 return self->ToString();
3194 }
3195
3196 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
3197 { wxPyRaiseNotImplemented(); return NULL; }
3198
3199 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
3200 { wxPyRaiseNotImplemented(); return false; }
3201
3202
3203 SWIGINTERNINLINE PyObject *
3204 SWIG_From_size_t (size_t value)
3205 {
3206 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3207 }
3208
3209
3210 SWIGINTERNINLINE int
3211 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3212 {
3213 unsigned long v;
3214 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3215 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3216 return res;
3217 }
3218
3219 SWIGINTERN PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
3220 wxFontEncoding alt_enc;
3221 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
3222 return PyInt_FromLong(alt_enc);
3223 else {
3224 Py_INCREF(Py_None);
3225 return Py_None;
3226 }
3227 }
3228 SWIGINTERN wxFont *new_wxFont(wxString const &info){
3229 wxNativeFontInfo nfi;
3230 nfi.FromString(info);
3231 return new wxFont(nfi);
3232 }
3233 SWIGINTERN wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3234 return wxFont::New(pointSize, family, flags, face, encoding);
3235 }
3236 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3237 return wxFontBase::New(pixelSize, family,
3238 style, weight, underlined,
3239 face, encoding);
3240 }
3241 SWIGINTERN wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
3242 return wxFontBase::New(pixelSize, family, flags, face, encoding);
3243 }
3244 SWIGINTERN bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
3245 SWIGINTERN bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
3246
3247 class wxPyFontEnumerator : public wxFontEnumerator {
3248 public:
3249 wxPyFontEnumerator() {}
3250 ~wxPyFontEnumerator() {}
3251
3252 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
3253 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
3254
3255 PYPRIVATE;
3256 };
3257
3258 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
3259 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
3260
3261
3262 SWIGINTERN PyObject *wxPyFontEnumerator_GetEncodings(){
3263 PyObject* ret;
3264 wxArrayString arr = wxFontEnumerator::GetEncodings();
3265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3266 ret = wxArrayString2PyList_helper(arr);
3267 wxPyEndBlockThreads(blocked);
3268 return ret;
3269 }
3270 SWIGINTERN PyObject *wxPyFontEnumerator_GetFacenames(){
3271 PyObject* ret;
3272 wxArrayString arr = wxFontEnumerator::GetFacenames();
3273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3274 ret = wxArrayString2PyList_helper(arr);
3275 wxPyEndBlockThreads(blocked);
3276 return ret;
3277 }
3278
3279 #include <locale.h>
3280
3281 SWIGINTERN wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3282 wxLocale* loc;
3283 if (language == -1)
3284 loc = new wxLocale();
3285 else
3286 loc = new wxLocale(language, flags);
3287 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3288 // for the floating point conversions and such to work right.
3289 #if PY_VERSION_HEX < 0x02040000
3290 setlocale(LC_NUMERIC, "C");
3291 #endif
3292 return loc;
3293 }
3294 SWIGINTERN bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
3295 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
3296 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3297 // for the floating point conversions and such to work right.
3298 #if PY_VERSION_HEX < 0x02040000
3299 setlocale(LC_NUMERIC, "C");
3300 #endif
3301 return rc;
3302 }
3303 SWIGINTERN bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3304 bool rc = self->Init(language, flags);
3305 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3306 // for the floating point conversions and such to work right.
3307 #if PY_VERSION_HEX < 0x02040000
3308 setlocale(LC_NUMERIC, "C");
3309 #endif
3310 return rc;
3311 }
3312
3313 class wxPyLocale : public wxLocale
3314 {
3315 public:
3316 wxPyLocale();
3317
3318 wxPyLocale(const wxChar *szName, // name (for messages)
3319 const wxChar *szShort = (const wxChar *) NULL, // dir prefix (for msg files)
3320 const wxChar *szLocale = (const wxChar *) NULL, // locale (for setlocale)
3321 bool bLoadDefault = true, // preload wxstd.mo?
3322 bool bConvertEncoding = false); // convert Win<->Unix if necessary?
3323
3324 wxPyLocale(int language, // wxLanguage id or custom language
3325 int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
3326
3327 ~wxPyLocale();
3328
3329 virtual const wxChar *GetString(const wxChar *szOrigString,
3330 const wxChar *szDomain = NULL) const;
3331 virtual const wxChar *GetString(const wxChar *szOrigString,
3332 const wxChar *szOrigString2, size_t n,
3333 const wxChar *szDomain = NULL) const;
3334
3335 virtual wxChar *GetSingularString(const wxChar *szOrigString,
3336 const wxChar *szDomain = NULL) const;
3337 virtual wxChar *GetPluralString(const wxChar *szOrigString,
3338 const wxChar *szOrigString2, size_t n,
3339 const wxChar *szDomain = NULL) const;
3340
3341 PYPRIVATE;
3342 private:
3343 DECLARE_NO_COPY_CLASS(wxPyLocale)
3344 };
3345
3346 wxPyLocale::wxPyLocale() : wxLocale()
3347 {
3348 }
3349
3350 wxPyLocale::wxPyLocale(const wxChar *szName, // name (for messages)
3351 const wxChar *szShort, // dir prefix (for msg files)
3352 const wxChar *szLocale, // locale (for setlocale)
3353 bool bLoadDefault, // preload wxstd.mo?
3354 bool bConvertEncoding) // convert Win<->Unix if necessary?
3355 : wxLocale(szName, szShort, szLocale, bLoadDefault, bConvertEncoding)
3356 {
3357 }
3358
3359 wxPyLocale::wxPyLocale(int language, // wxLanguage id or custom language
3360 int flags) : wxLocale(language, flags)
3361 {
3362 }
3363
3364 wxPyLocale::~wxPyLocale()
3365 {
3366 }
3367
3368 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3369 const wxChar *szDomain) const
3370 {
3371 wxChar *str = GetSingularString(szOrigString, szDomain);
3372 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szDomain);
3373 }
3374
3375 const wxChar *wxPyLocale::GetString(const wxChar *szOrigString,
3376 const wxChar *szOrigString2, size_t n,
3377 const wxChar *szDomain) const
3378 {
3379 wxChar *str = GetPluralString(szOrigString, szOrigString2, n, szDomain);
3380 return (str != NULL) ? str : wxLocale::GetString(szOrigString, szOrigString2, n, szDomain);
3381 }
3382
3383 wxChar *wxPyLocale::GetSingularString(const wxChar *szOrigString,
3384 const wxChar *szDomain) const
3385 {
3386 bool found;
3387 static wxString str;
3388 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.
3389 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3390 if((found=wxPyCBH_findCallback(m_myInst, "GetSingularString"))) {
3391 PyObject* param1 = wx2PyString(szOrigString);
3392 PyObject* param2 = wx2PyString(szDomain);
3393 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", param1, param2));
3394 Py_DECREF(param1);
3395 Py_DECREF(param2);
3396 if (ret) {
3397 str = Py2wxString(ret);
3398 Py_DECREF(ret);
3399 }
3400 }
3401 wxPyEndBlockThreads(blocked);
3402 return (found ? (wxChar*)str.c_str() : NULL);
3403 }
3404
3405 wxChar *wxPyLocale::GetPluralString(const wxChar *szOrigString,
3406 const wxChar *szOrigString2, size_t n,
3407 const wxChar *szDomain) const
3408 {
3409 bool found;
3410 static wxString str;
3411 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.
3412 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3413 if((found=wxPyCBH_findCallback(m_myInst, "GetPluralString"))) {
3414 PyObject* param1 = wx2PyString(szOrigString);
3415 PyObject* param2 = wx2PyString(szOrigString2);
3416 PyObject* param4 = wx2PyString(szDomain);
3417 PyObject* ret = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOiO)", param1, param2, (int)n, param4));
3418 Py_DECREF(param1);
3419 Py_DECREF(param2);
3420 Py_DECREF(param4);
3421 if( ret) {
3422 str = Py2wxString(ret);
3423 Py_DECREF(ret);
3424 }
3425 }
3426 wxPyEndBlockThreads(blocked);
3427 return (found ? (wxChar*)str.c_str() : NULL);
3428 }
3429
3430 SWIGINTERN wxPyLocale *new_wxPyLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
3431 wxPyLocale* loc;
3432 if (language == -1)
3433 loc = new wxPyLocale();
3434 else
3435 loc = new wxPyLocale(language, flags);
3436 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
3437 // for the floating point conversions and such to work right.
3438 #if PY_VERSION_HEX < 0x02040000
3439 setlocale(LC_NUMERIC, "C");
3440 #endif
3441 return loc;
3442 }
3443
3444 #include "wx/wxPython/pydrawxxx.h"
3445
3446 SWIGINTERN wxColour wxDC_GetPixel(wxDC *self,int x,int y){
3447 wxColour col;
3448 self->GetPixel(x, y, &col);
3449 return col;
3450 }
3451 SWIGINTERN wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
3452 wxColour col;
3453 self->GetPixel(pt, &col);
3454 return col;
3455 }
3456
3457 SWIGINTERN int
3458 SWIG_AsVal_double (PyObject *obj, double* val)
3459 {
3460 if (PyNumber_Check(obj)) {
3461 if (val) *val = PyFloat_AsDouble(obj);
3462 return SWIG_OK;
3463 }
3464 return SWIG_TypeError;
3465 }
3466
3467 SWIGINTERN wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
3468 wxRect rv;
3469 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
3470 return rv;
3471 }
3472 SWIGINTERN wxRect wxDC_GetClippingRect(wxDC *self){
3473 wxRect rect;
3474 self->GetClippingBox(rect);
3475 return rect;
3476 }
3477 SWIGINTERN wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
3478 wxArrayInt widths;
3479 self->GetPartialTextExtents(text, widths);
3480 return widths;
3481 }
3482
3483 #define SWIG_From_double PyFloat_FromDouble
3484
3485 SWIGINTERN void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
3486 self->SetLogicalOrigin(point.x, point.y);
3487 }
3488 SWIGINTERN void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
3489 self->SetDeviceOrigin(point.x, point.y);
3490 }
3491 SWIGINTERN void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
3492 self->CalcBoundingBox(point.x, point.y);
3493 }
3494 SWIGINTERN PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3495 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
3496 }
3497 SWIGINTERN PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3498 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
3499 }
3500 SWIGINTERN PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3501 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
3502 }
3503 SWIGINTERN PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3504 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
3505 }
3506 SWIGINTERN PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
3507 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
3508 }
3509 SWIGINTERN PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
3510 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
3511 }
3512
3513 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
3514 *x1 = dc->MinX();
3515 *y1 = dc->MinY();
3516 *x2 = dc->MaxX();
3517 *y2 = dc->MaxY();
3518 }
3519
3520
3521 #include <wx/dcbuffer.h>
3522
3523
3524 #include <wx/dcps.h>
3525
3526
3527 #include <wx/metafile.h>
3528
3529
3530
3531 SWIGINTERN void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
3532 self->AddColour(name, wxColour(red, green, blue));
3533 }
3534
3535 wxFontList* _wxPyInitTheFontList() { return wxTheFontList; }
3536 wxPenList* _wxPyInitThePenList() { return wxThePenList; }
3537 wxBrushList* _wxPyInitTheBrushList() { return wxTheBrushList; }
3538 wxColourDatabase* _wxPyInitTheColourDatabase() { return wxTheColourDatabase; }
3539
3540
3541 #include <wx/effects.h>
3542
3543
3544 #include "wx/renderer.h"
3545
3546
3547 SWIGINTERNINLINE PyObject*
3548 SWIG_From_bool (bool value)
3549 {
3550 return PyBool_FromLong(value ? 1 : 0);
3551 }
3552
3553
3554 #include "wx/wxPython/pseudodc.h"
3555
3556 SWIGINTERN wxRect wxPseudoDC_GetIdBounds(wxPseudoDC *self,int id){
3557 wxRect rect;
3558 self->GetIdBounds(id, rect);
3559 return rect;
3560 }
3561 #ifdef __cplusplus
3562 extern "C" {
3563 #endif
3564 SWIGINTERN PyObject *_wrap_new_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3565 PyObject *resultobj = 0;
3566 wxGDIObject *result = 0 ;
3567
3568 if (!SWIG_Python_UnpackTuple(args,"new_GDIObject",0,0,0)) SWIG_fail;
3569 {
3570 if (!wxPyCheckForApp()) SWIG_fail;
3571 PyThreadState* __tstate = wxPyBeginAllowThreads();
3572 result = (wxGDIObject *)new wxGDIObject();
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObject, SWIG_POINTER_NEW | 0 );
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 SWIGINTERN PyObject *_wrap_delete_GDIObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3584 PyObject *resultobj = 0;
3585 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3586 void *argp1 = 0 ;
3587 int res1 = 0 ;
3588 PyObject *swig_obj[1] ;
3589
3590 if (!args) SWIG_fail;
3591 swig_obj[0] = args;
3592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, SWIG_POINTER_DISOWN | 0 );
3593 if (!SWIG_IsOK(res1)) {
3594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObject" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3595 }
3596 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3597 {
3598 PyThreadState* __tstate = wxPyBeginAllowThreads();
3599 delete arg1;
3600
3601 wxPyEndAllowThreads(__tstate);
3602 if (PyErr_Occurred()) SWIG_fail;
3603 }
3604 resultobj = SWIG_Py_Void();
3605 return resultobj;
3606 fail:
3607 return NULL;
3608 }
3609
3610
3611 SWIGINTERN PyObject *_wrap_GDIObject_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3612 PyObject *resultobj = 0;
3613 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
3614 bool result;
3615 void *argp1 = 0 ;
3616 int res1 = 0 ;
3617 PyObject *swig_obj[1] ;
3618
3619 if (!args) SWIG_fail;
3620 swig_obj[0] = args;
3621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObject, 0 | 0 );
3622 if (!SWIG_IsOK(res1)) {
3623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GDIObject_IsNull" "', expected argument " "1"" of type '" "wxGDIObject *""'");
3624 }
3625 arg1 = reinterpret_cast< wxGDIObject * >(argp1);
3626 {
3627 PyThreadState* __tstate = wxPyBeginAllowThreads();
3628 result = (bool)(arg1)->IsNull();
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 {
3633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3634 }
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 SWIGINTERN PyObject *GDIObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3642 PyObject *obj;
3643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3644 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObject, SWIG_NewClientData(obj));
3645 return SWIG_Py_Void();
3646 }
3647
3648 SWIGINTERN PyObject *GDIObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3649 return SWIG_Python_InitShadowInstance(args);
3650 }
3651
3652 SWIGINTERN PyObject *_wrap_new_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3653 PyObject *resultobj = 0;
3654 byte arg1 = (byte) 0 ;
3655 byte arg2 = (byte) 0 ;
3656 byte arg3 = (byte) 0 ;
3657 byte arg4 = (byte) wxALPHA_OPAQUE ;
3658 wxColour *result = 0 ;
3659 unsigned char val1 ;
3660 int ecode1 = 0 ;
3661 unsigned char val2 ;
3662 int ecode2 = 0 ;
3663 unsigned char val3 ;
3664 int ecode3 = 0 ;
3665 unsigned char val4 ;
3666 int ecode4 = 0 ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 PyObject * obj2 = 0 ;
3670 PyObject * obj3 = 0 ;
3671 char * kwnames[] = {
3672 (char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
3673 };
3674
3675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Colour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3676 if (obj0) {
3677 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
3678 if (!SWIG_IsOK(ecode1)) {
3679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Colour" "', expected argument " "1"" of type '" "byte""'");
3680 }
3681 arg1 = static_cast< byte >(val1);
3682 }
3683 if (obj1) {
3684 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3685 if (!SWIG_IsOK(ecode2)) {
3686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Colour" "', expected argument " "2"" of type '" "byte""'");
3687 }
3688 arg2 = static_cast< byte >(val2);
3689 }
3690 if (obj2) {
3691 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3692 if (!SWIG_IsOK(ecode3)) {
3693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Colour" "', expected argument " "3"" of type '" "byte""'");
3694 }
3695 arg3 = static_cast< byte >(val3);
3696 }
3697 if (obj3) {
3698 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3699 if (!SWIG_IsOK(ecode4)) {
3700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Colour" "', expected argument " "4"" of type '" "byte""'");
3701 }
3702 arg4 = static_cast< byte >(val4);
3703 }
3704 {
3705 PyThreadState* __tstate = wxPyBeginAllowThreads();
3706 result = (wxColour *)new wxColour(arg1,arg2,arg3,arg4);
3707 wxPyEndAllowThreads(__tstate);
3708 if (PyErr_Occurred()) SWIG_fail;
3709 }
3710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_NEW | 0 );
3711 return resultobj;
3712 fail:
3713 return NULL;
3714 }
3715
3716
3717 SWIGINTERN PyObject *_wrap_new_NamedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3718 PyObject *resultobj = 0;
3719 wxString *arg1 = 0 ;
3720 wxColour *result = 0 ;
3721 bool temp1 = false ;
3722 PyObject * obj0 = 0 ;
3723 char * kwnames[] = {
3724 (char *) "colorName", NULL
3725 };
3726
3727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) SWIG_fail;
3728 {
3729 arg1 = wxString_in_helper(obj0);
3730 if (arg1 == NULL) SWIG_fail;
3731 temp1 = true;
3732 }
3733 {
3734 if (!wxPyCheckForApp()) SWIG_fail;
3735 PyThreadState* __tstate = wxPyBeginAllowThreads();
3736 result = (wxColour *)new wxColour((wxString const &)*arg1);
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3741 {
3742 if (temp1)
3743 delete arg1;
3744 }
3745 return resultobj;
3746 fail:
3747 {
3748 if (temp1)
3749 delete arg1;
3750 }
3751 return NULL;
3752 }
3753
3754
3755 SWIGINTERN PyObject *_wrap_new_ColourRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj = 0;
3757 unsigned long arg1 ;
3758 wxColour *result = 0 ;
3759 unsigned long val1 ;
3760 int ecode1 = 0 ;
3761 PyObject * obj0 = 0 ;
3762 char * kwnames[] = {
3763 (char *) "colRGB", NULL
3764 };
3765
3766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) SWIG_fail;
3767 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
3768 if (!SWIG_IsOK(ecode1)) {
3769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourRGB" "', expected argument " "1"" of type '" "unsigned long""'");
3770 }
3771 arg1 = static_cast< unsigned long >(val1);
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 result = (wxColour *)new wxColour(arg1);
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 SWIGINTERN PyObject *_wrap_delete_Colour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3786 PyObject *resultobj = 0;
3787 wxColour *arg1 = (wxColour *) 0 ;
3788 void *argp1 = 0 ;
3789 int res1 = 0 ;
3790 PyObject *swig_obj[1] ;
3791
3792 if (!args) SWIG_fail;
3793 swig_obj[0] = args;
3794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, SWIG_POINTER_DISOWN | 0 );
3795 if (!SWIG_IsOK(res1)) {
3796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Colour" "', expected argument " "1"" of type '" "wxColour *""'");
3797 }
3798 arg1 = reinterpret_cast< wxColour * >(argp1);
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 delete arg1;
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 resultobj = SWIG_Py_Void();
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 SWIGINTERN PyObject *_wrap_Colour_Red(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3814 PyObject *resultobj = 0;
3815 wxColour *arg1 = (wxColour *) 0 ;
3816 byte result;
3817 void *argp1 = 0 ;
3818 int res1 = 0 ;
3819 PyObject *swig_obj[1] ;
3820
3821 if (!args) SWIG_fail;
3822 swig_obj[0] = args;
3823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3824 if (!SWIG_IsOK(res1)) {
3825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Red" "', expected argument " "1"" of type '" "wxColour *""'");
3826 }
3827 arg1 = reinterpret_cast< wxColour * >(argp1);
3828 {
3829 PyThreadState* __tstate = wxPyBeginAllowThreads();
3830 result = (byte)(arg1)->Red();
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 SWIGINTERN PyObject *_wrap_Colour_Green(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3842 PyObject *resultobj = 0;
3843 wxColour *arg1 = (wxColour *) 0 ;
3844 byte result;
3845 void *argp1 = 0 ;
3846 int res1 = 0 ;
3847 PyObject *swig_obj[1] ;
3848
3849 if (!args) SWIG_fail;
3850 swig_obj[0] = args;
3851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3852 if (!SWIG_IsOK(res1)) {
3853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Green" "', expected argument " "1"" of type '" "wxColour *""'");
3854 }
3855 arg1 = reinterpret_cast< wxColour * >(argp1);
3856 {
3857 PyThreadState* __tstate = wxPyBeginAllowThreads();
3858 result = (byte)(arg1)->Green();
3859 wxPyEndAllowThreads(__tstate);
3860 if (PyErr_Occurred()) SWIG_fail;
3861 }
3862 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 SWIGINTERN PyObject *_wrap_Colour_Blue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3870 PyObject *resultobj = 0;
3871 wxColour *arg1 = (wxColour *) 0 ;
3872 byte result;
3873 void *argp1 = 0 ;
3874 int res1 = 0 ;
3875 PyObject *swig_obj[1] ;
3876
3877 if (!args) SWIG_fail;
3878 swig_obj[0] = args;
3879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3880 if (!SWIG_IsOK(res1)) {
3881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Blue" "', expected argument " "1"" of type '" "wxColour *""'");
3882 }
3883 arg1 = reinterpret_cast< wxColour * >(argp1);
3884 {
3885 PyThreadState* __tstate = wxPyBeginAllowThreads();
3886 result = (byte)(arg1)->Blue();
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 SWIGINTERN PyObject *_wrap_Colour_Alpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3898 PyObject *resultobj = 0;
3899 wxColour *arg1 = (wxColour *) 0 ;
3900 byte result;
3901 void *argp1 = 0 ;
3902 int res1 = 0 ;
3903 PyObject *swig_obj[1] ;
3904
3905 if (!args) SWIG_fail;
3906 swig_obj[0] = args;
3907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3908 if (!SWIG_IsOK(res1)) {
3909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Alpha" "', expected argument " "1"" of type '" "wxColour *""'");
3910 }
3911 arg1 = reinterpret_cast< wxColour * >(argp1);
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (byte)(arg1)->Alpha();
3915 wxPyEndAllowThreads(__tstate);
3916 if (PyErr_Occurred()) SWIG_fail;
3917 }
3918 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 SWIGINTERN PyObject *_wrap_Colour_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3926 PyObject *resultobj = 0;
3927 wxColour *arg1 = (wxColour *) 0 ;
3928 bool result;
3929 void *argp1 = 0 ;
3930 int res1 = 0 ;
3931 PyObject *swig_obj[1] ;
3932
3933 if (!args) SWIG_fail;
3934 swig_obj[0] = args;
3935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3936 if (!SWIG_IsOK(res1)) {
3937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Ok" "', expected argument " "1"" of type '" "wxColour *""'");
3938 }
3939 arg1 = reinterpret_cast< wxColour * >(argp1);
3940 {
3941 PyThreadState* __tstate = wxPyBeginAllowThreads();
3942 result = (bool)(arg1)->Ok();
3943 wxPyEndAllowThreads(__tstate);
3944 if (PyErr_Occurred()) SWIG_fail;
3945 }
3946 {
3947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3948 }
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 SWIGINTERN PyObject *_wrap_Colour_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj = 0;
3957 wxColour *arg1 = (wxColour *) 0 ;
3958 byte arg2 ;
3959 byte arg3 ;
3960 byte arg4 ;
3961 byte arg5 = (byte) wxALPHA_OPAQUE ;
3962 void *argp1 = 0 ;
3963 int res1 = 0 ;
3964 unsigned char val2 ;
3965 int ecode2 = 0 ;
3966 unsigned char val3 ;
3967 int ecode3 = 0 ;
3968 unsigned char val4 ;
3969 int ecode4 = 0 ;
3970 unsigned char val5 ;
3971 int ecode5 = 0 ;
3972 PyObject * obj0 = 0 ;
3973 PyObject * obj1 = 0 ;
3974 PyObject * obj2 = 0 ;
3975 PyObject * obj3 = 0 ;
3976 PyObject * obj4 = 0 ;
3977 char * kwnames[] = {
3978 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
3979 };
3980
3981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
3982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
3983 if (!SWIG_IsOK(res1)) {
3984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Set" "', expected argument " "1"" of type '" "wxColour *""'");
3985 }
3986 arg1 = reinterpret_cast< wxColour * >(argp1);
3987 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
3988 if (!SWIG_IsOK(ecode2)) {
3989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Set" "', expected argument " "2"" of type '" "byte""'");
3990 }
3991 arg2 = static_cast< byte >(val2);
3992 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
3993 if (!SWIG_IsOK(ecode3)) {
3994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Colour_Set" "', expected argument " "3"" of type '" "byte""'");
3995 }
3996 arg3 = static_cast< byte >(val3);
3997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
3998 if (!SWIG_IsOK(ecode4)) {
3999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Colour_Set" "', expected argument " "4"" of type '" "byte""'");
4000 }
4001 arg4 = static_cast< byte >(val4);
4002 if (obj4) {
4003 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
4004 if (!SWIG_IsOK(ecode5)) {
4005 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Colour_Set" "', expected argument " "5"" of type '" "byte""'");
4006 }
4007 arg5 = static_cast< byte >(val5);
4008 }
4009 {
4010 PyThreadState* __tstate = wxPyBeginAllowThreads();
4011 (arg1)->Set(arg2,arg3,arg4,arg5);
4012 wxPyEndAllowThreads(__tstate);
4013 if (PyErr_Occurred()) SWIG_fail;
4014 }
4015 resultobj = SWIG_Py_Void();
4016 return resultobj;
4017 fail:
4018 return NULL;
4019 }
4020
4021
4022 SWIGINTERN PyObject *_wrap_Colour_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4023 PyObject *resultobj = 0;
4024 wxColour *arg1 = (wxColour *) 0 ;
4025 unsigned long arg2 ;
4026 void *argp1 = 0 ;
4027 int res1 = 0 ;
4028 unsigned long val2 ;
4029 int ecode2 = 0 ;
4030 PyObject * obj0 = 0 ;
4031 PyObject * obj1 = 0 ;
4032 char * kwnames[] = {
4033 (char *) "self",(char *) "colRGB", NULL
4034 };
4035
4036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4038 if (!SWIG_IsOK(res1)) {
4039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4040 }
4041 arg1 = reinterpret_cast< wxColour * >(argp1);
4042 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
4043 if (!SWIG_IsOK(ecode2)) {
4044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_SetRGB" "', expected argument " "2"" of type '" "unsigned long""'");
4045 }
4046 arg2 = static_cast< unsigned long >(val2);
4047 {
4048 PyThreadState* __tstate = wxPyBeginAllowThreads();
4049 (arg1)->Set(arg2);
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 resultobj = SWIG_Py_Void();
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 SWIGINTERN PyObject *_wrap_Colour_SetFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj = 0;
4062 wxColour *arg1 = (wxColour *) 0 ;
4063 wxString *arg2 = 0 ;
4064 void *argp1 = 0 ;
4065 int res1 = 0 ;
4066 bool temp2 = false ;
4067 PyObject * obj0 = 0 ;
4068 PyObject * obj1 = 0 ;
4069 char * kwnames[] = {
4070 (char *) "self",(char *) "colourName", NULL
4071 };
4072
4073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) SWIG_fail;
4074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4075 if (!SWIG_IsOK(res1)) {
4076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_SetFromName" "', expected argument " "1"" of type '" "wxColour *""'");
4077 }
4078 arg1 = reinterpret_cast< wxColour * >(argp1);
4079 {
4080 arg2 = wxString_in_helper(obj1);
4081 if (arg2 == NULL) SWIG_fail;
4082 temp2 = true;
4083 }
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 (arg1)->InitFromName((wxString const &)*arg2);
4087 wxPyEndAllowThreads(__tstate);
4088 if (PyErr_Occurred()) SWIG_fail;
4089 }
4090 resultobj = SWIG_Py_Void();
4091 {
4092 if (temp2)
4093 delete arg2;
4094 }
4095 return resultobj;
4096 fail:
4097 {
4098 if (temp2)
4099 delete arg2;
4100 }
4101 return NULL;
4102 }
4103
4104
4105 SWIGINTERN PyObject *_wrap_Colour_GetAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4106 PyObject *resultobj = 0;
4107 wxColour *arg1 = (wxColour *) 0 ;
4108 long arg2 = (long) wxC2S_NAME|wxC2S_CSS_SYNTAX ;
4109 wxString result;
4110 void *argp1 = 0 ;
4111 int res1 = 0 ;
4112 long val2 ;
4113 int ecode2 = 0 ;
4114 PyObject * obj0 = 0 ;
4115 PyObject * obj1 = 0 ;
4116 char * kwnames[] = {
4117 (char *) "self",(char *) "flags", NULL
4118 };
4119
4120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_GetAsString",kwnames,&obj0,&obj1)) SWIG_fail;
4121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4122 if (!SWIG_IsOK(res1)) {
4123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetAsString" "', expected argument " "1"" of type '" "wxColour const *""'");
4124 }
4125 arg1 = reinterpret_cast< wxColour * >(argp1);
4126 if (obj1) {
4127 ecode2 = SWIG_AsVal_long(obj1, &val2);
4128 if (!SWIG_IsOK(ecode2)) {
4129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_GetAsString" "', expected argument " "2"" of type '" "long""'");
4130 }
4131 arg2 = static_cast< long >(val2);
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 result = ((wxColour const *)arg1)->GetAsString(arg2);
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 #if wxUSE_UNICODE
4141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4142 #else
4143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4144 #endif
4145 }
4146 return resultobj;
4147 fail:
4148 return NULL;
4149 }
4150
4151
4152 SWIGINTERN PyObject *_wrap_Colour_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4153 PyObject *resultobj = 0;
4154 wxColour *arg1 = (wxColour *) 0 ;
4155 long result;
4156 void *argp1 = 0 ;
4157 int res1 = 0 ;
4158 PyObject *swig_obj[1] ;
4159
4160 if (!args) SWIG_fail;
4161 swig_obj[0] = args;
4162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4163 if (!SWIG_IsOK(res1)) {
4164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetPixel" "', expected argument " "1"" of type '" "wxColour const *""'");
4165 }
4166 arg1 = reinterpret_cast< wxColour * >(argp1);
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (long)((wxColour const *)arg1)->GetPixel();
4170 wxPyEndAllowThreads(__tstate);
4171 if (PyErr_Occurred()) SWIG_fail;
4172 }
4173 resultobj = SWIG_From_long(static_cast< long >(result));
4174 return resultobj;
4175 fail:
4176 return NULL;
4177 }
4178
4179
4180 SWIGINTERN PyObject *_wrap_Colour___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4181 PyObject *resultobj = 0;
4182 wxColour *arg1 = (wxColour *) 0 ;
4183 PyObject *arg2 = (PyObject *) 0 ;
4184 bool result;
4185 void *argp1 = 0 ;
4186 int res1 = 0 ;
4187 PyObject * obj0 = 0 ;
4188 PyObject * obj1 = 0 ;
4189 char * kwnames[] = {
4190 (char *) "self",(char *) "other", NULL
4191 };
4192
4193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4195 if (!SWIG_IsOK(res1)) {
4196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___eq__" "', expected argument " "1"" of type '" "wxColour *""'");
4197 }
4198 arg1 = reinterpret_cast< wxColour * >(argp1);
4199 arg2 = obj1;
4200 {
4201 result = (bool)wxColour___eq__(arg1,arg2);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 {
4205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 SWIGINTERN PyObject *_wrap_Colour___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj = 0;
4215 wxColour *arg1 = (wxColour *) 0 ;
4216 PyObject *arg2 = (PyObject *) 0 ;
4217 bool result;
4218 void *argp1 = 0 ;
4219 int res1 = 0 ;
4220 PyObject * obj0 = 0 ;
4221 PyObject * obj1 = 0 ;
4222 char * kwnames[] = {
4223 (char *) "self",(char *) "other", NULL
4224 };
4225
4226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4228 if (!SWIG_IsOK(res1)) {
4229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour___ne__" "', expected argument " "1"" of type '" "wxColour *""'");
4230 }
4231 arg1 = reinterpret_cast< wxColour * >(argp1);
4232 arg2 = obj1;
4233 {
4234 result = (bool)wxColour___ne__(arg1,arg2);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 {
4238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4239 }
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 SWIGINTERN PyObject *_wrap_Colour_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4247 PyObject *resultobj = 0;
4248 wxColour *arg1 = (wxColour *) 0 ;
4249 bool arg2 = (bool) false ;
4250 PyObject *result = 0 ;
4251 void *argp1 = 0 ;
4252 int res1 = 0 ;
4253 bool val2 ;
4254 int ecode2 = 0 ;
4255 PyObject * obj0 = 0 ;
4256 PyObject * obj1 = 0 ;
4257 char * kwnames[] = {
4258 (char *) "self",(char *) "includeAlpha", NULL
4259 };
4260
4261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Colour_Get",kwnames,&obj0,&obj1)) SWIG_fail;
4262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4263 if (!SWIG_IsOK(res1)) {
4264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_Get" "', expected argument " "1"" of type '" "wxColour *""'");
4265 }
4266 arg1 = reinterpret_cast< wxColour * >(argp1);
4267 if (obj1) {
4268 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4269 if (!SWIG_IsOK(ecode2)) {
4270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Colour_Get" "', expected argument " "2"" of type '" "bool""'");
4271 }
4272 arg2 = static_cast< bool >(val2);
4273 }
4274 {
4275 result = (PyObject *)wxColour_Get(arg1,arg2);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = result;
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *_wrap_Colour_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4286 PyObject *resultobj = 0;
4287 wxColour *arg1 = (wxColour *) 0 ;
4288 unsigned long result;
4289 void *argp1 = 0 ;
4290 int res1 = 0 ;
4291 PyObject *swig_obj[1] ;
4292
4293 if (!args) SWIG_fail;
4294 swig_obj[0] = args;
4295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColour, 0 | 0 );
4296 if (!SWIG_IsOK(res1)) {
4297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Colour_GetRGB" "', expected argument " "1"" of type '" "wxColour *""'");
4298 }
4299 arg1 = reinterpret_cast< wxColour * >(argp1);
4300 {
4301 result = (unsigned long)wxColour_GetRGB(arg1);
4302 if (PyErr_Occurred()) SWIG_fail;
4303 }
4304 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 SWIGINTERN PyObject *Colour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4312 PyObject *obj;
4313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4314 SWIG_TypeNewClientData(SWIGTYPE_p_wxColour, SWIG_NewClientData(obj));
4315 return SWIG_Py_Void();
4316 }
4317
4318 SWIGINTERN PyObject *Colour_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4319 return SWIG_Python_InitShadowInstance(args);
4320 }
4321
4322 SWIGINTERN PyObject *_wrap_new_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = 0;
4324 int arg1 ;
4325 unsigned char *arg2 = (unsigned char *) 0 ;
4326 unsigned char *arg3 = (unsigned char *) 0 ;
4327 unsigned char *arg4 = (unsigned char *) 0 ;
4328 wxPalette *result = 0 ;
4329 int val1 ;
4330 int ecode1 = 0 ;
4331 void *argp2 = 0 ;
4332 int res2 = 0 ;
4333 void *argp3 = 0 ;
4334 int res3 = 0 ;
4335 void *argp4 = 0 ;
4336 int res4 = 0 ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 PyObject * obj2 = 0 ;
4340 PyObject * obj3 = 0 ;
4341 char * kwnames[] = {
4342 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
4343 };
4344
4345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4346 ecode1 = SWIG_AsVal_int(obj0, &val1);
4347 if (!SWIG_IsOK(ecode1)) {
4348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Palette" "', expected argument " "1"" of type '" "int""'");
4349 }
4350 arg1 = static_cast< int >(val1);
4351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4352 if (!SWIG_IsOK(res2)) {
4353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Palette" "', expected argument " "2"" of type '" "unsigned char const *""'");
4354 }
4355 arg2 = reinterpret_cast< unsigned char * >(argp2);
4356 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
4357 if (!SWIG_IsOK(res3)) {
4358 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Palette" "', expected argument " "3"" of type '" "unsigned char const *""'");
4359 }
4360 arg3 = reinterpret_cast< unsigned char * >(argp3);
4361 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
4362 if (!SWIG_IsOK(res4)) {
4363 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Palette" "', expected argument " "4"" of type '" "unsigned char const *""'");
4364 }
4365 arg4 = reinterpret_cast< unsigned char * >(argp4);
4366 {
4367 if (!wxPyCheckForApp()) SWIG_fail;
4368 PyThreadState* __tstate = wxPyBeginAllowThreads();
4369 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
4370 wxPyEndAllowThreads(__tstate);
4371 if (PyErr_Occurred()) SWIG_fail;
4372 }
4373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, SWIG_POINTER_NEW | 0 );
4374 return resultobj;
4375 fail:
4376 return NULL;
4377 }
4378
4379
4380 SWIGINTERN PyObject *_wrap_delete_Palette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4381 PyObject *resultobj = 0;
4382 wxPalette *arg1 = (wxPalette *) 0 ;
4383 void *argp1 = 0 ;
4384 int res1 = 0 ;
4385 PyObject *swig_obj[1] ;
4386
4387 if (!args) SWIG_fail;
4388 swig_obj[0] = args;
4389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, SWIG_POINTER_DISOWN | 0 );
4390 if (!SWIG_IsOK(res1)) {
4391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Palette" "', expected argument " "1"" of type '" "wxPalette *""'");
4392 }
4393 arg1 = reinterpret_cast< wxPalette * >(argp1);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 delete arg1;
4397
4398 wxPyEndAllowThreads(__tstate);
4399 if (PyErr_Occurred()) SWIG_fail;
4400 }
4401 resultobj = SWIG_Py_Void();
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 SWIGINTERN PyObject *_wrap_Palette_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj = 0;
4410 wxPalette *arg1 = (wxPalette *) 0 ;
4411 byte arg2 ;
4412 byte arg3 ;
4413 byte arg4 ;
4414 int result;
4415 void *argp1 = 0 ;
4416 int res1 = 0 ;
4417 unsigned char val2 ;
4418 int ecode2 = 0 ;
4419 unsigned char val3 ;
4420 int ecode3 = 0 ;
4421 unsigned char val4 ;
4422 int ecode4 = 0 ;
4423 PyObject * obj0 = 0 ;
4424 PyObject * obj1 = 0 ;
4425 PyObject * obj2 = 0 ;
4426 PyObject * obj3 = 0 ;
4427 char * kwnames[] = {
4428 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
4429 };
4430
4431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4433 if (!SWIG_IsOK(res1)) {
4434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetPixel" "', expected argument " "1"" of type '" "wxPalette *""'");
4435 }
4436 arg1 = reinterpret_cast< wxPalette * >(argp1);
4437 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
4438 if (!SWIG_IsOK(ecode2)) {
4439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetPixel" "', expected argument " "2"" of type '" "byte""'");
4440 }
4441 arg2 = static_cast< byte >(val2);
4442 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
4443 if (!SWIG_IsOK(ecode3)) {
4444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Palette_GetPixel" "', expected argument " "3"" of type '" "byte""'");
4445 }
4446 arg3 = static_cast< byte >(val3);
4447 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
4448 if (!SWIG_IsOK(ecode4)) {
4449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Palette_GetPixel" "', expected argument " "4"" of type '" "byte""'");
4450 }
4451 arg4 = static_cast< byte >(val4);
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 resultobj = SWIG_From_int(static_cast< int >(result));
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 SWIGINTERN PyObject *_wrap_Palette_GetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj = 0;
4467 wxPalette *arg1 = (wxPalette *) 0 ;
4468 int arg2 ;
4469 byte *arg3 = (byte *) 0 ;
4470 byte *arg4 = (byte *) 0 ;
4471 byte *arg5 = (byte *) 0 ;
4472 bool result;
4473 void *argp1 = 0 ;
4474 int res1 = 0 ;
4475 int val2 ;
4476 int ecode2 = 0 ;
4477 byte temp3 ;
4478 int res3 = SWIG_TMPOBJ ;
4479 byte temp4 ;
4480 int res4 = SWIG_TMPOBJ ;
4481 byte temp5 ;
4482 int res5 = SWIG_TMPOBJ ;
4483 PyObject * obj0 = 0 ;
4484 PyObject * obj1 = 0 ;
4485 char * kwnames[] = {
4486 (char *) "self",(char *) "pixel", NULL
4487 };
4488
4489 arg3 = &temp3;
4490 arg4 = &temp4;
4491 arg5 = &temp5;
4492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) SWIG_fail;
4493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4494 if (!SWIG_IsOK(res1)) {
4495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetRGB" "', expected argument " "1"" of type '" "wxPalette *""'");
4496 }
4497 arg1 = reinterpret_cast< wxPalette * >(argp1);
4498 ecode2 = SWIG_AsVal_int(obj1, &val2);
4499 if (!SWIG_IsOK(ecode2)) {
4500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Palette_GetRGB" "', expected argument " "2"" of type '" "int""'");
4501 }
4502 arg2 = static_cast< int >(val2);
4503 {
4504 PyThreadState* __tstate = wxPyBeginAllowThreads();
4505 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
4506 wxPyEndAllowThreads(__tstate);
4507 if (PyErr_Occurred()) SWIG_fail;
4508 }
4509 {
4510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4511 }
4512 if (SWIG_IsTmpObj(res3)) {
4513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
4514 } else {
4515 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
4517 }
4518 if (SWIG_IsTmpObj(res4)) {
4519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
4520 } else {
4521 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
4523 }
4524 if (SWIG_IsTmpObj(res5)) {
4525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg5)));
4526 } else {
4527 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, new_flags));
4529 }
4530 return resultobj;
4531 fail:
4532 return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_Palette_GetColoursCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537 PyObject *resultobj = 0;
4538 wxPalette *arg1 = (wxPalette *) 0 ;
4539 int result;
4540 void *argp1 = 0 ;
4541 int res1 = 0 ;
4542 PyObject *swig_obj[1] ;
4543
4544 if (!args) SWIG_fail;
4545 swig_obj[0] = args;
4546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4547 if (!SWIG_IsOK(res1)) {
4548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_GetColoursCount" "', expected argument " "1"" of type '" "wxPalette const *""'");
4549 }
4550 arg1 = reinterpret_cast< wxPalette * >(argp1);
4551 {
4552 PyThreadState* __tstate = wxPyBeginAllowThreads();
4553 result = (int)((wxPalette const *)arg1)->GetColoursCount();
4554 wxPyEndAllowThreads(__tstate);
4555 if (PyErr_Occurred()) SWIG_fail;
4556 }
4557 resultobj = SWIG_From_int(static_cast< int >(result));
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Palette_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxPalette *arg1 = (wxPalette *) 0 ;
4567 bool result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPalette, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Palette_Ok" "', expected argument " "1"" of type '" "wxPalette *""'");
4577 }
4578 arg1 = reinterpret_cast< wxPalette * >(argp1);
4579 {
4580 PyThreadState* __tstate = wxPyBeginAllowThreads();
4581 result = (bool)(arg1)->Ok();
4582 wxPyEndAllowThreads(__tstate);
4583 if (PyErr_Occurred()) SWIG_fail;
4584 }
4585 {
4586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4587 }
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *Palette_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *obj;
4596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4597 SWIG_TypeNewClientData(SWIGTYPE_p_wxPalette, SWIG_NewClientData(obj));
4598 return SWIG_Py_Void();
4599 }
4600
4601 SWIGINTERN PyObject *Palette_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4602 return SWIG_Python_InitShadowInstance(args);
4603 }
4604
4605 SWIGINTERN PyObject *_wrap_new_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4606 PyObject *resultobj = 0;
4607 wxColour *arg1 = 0 ;
4608 int arg2 = (int) 1 ;
4609 int arg3 = (int) wxSOLID ;
4610 wxPen *result = 0 ;
4611 wxColour temp1 ;
4612 int val2 ;
4613 int ecode2 = 0 ;
4614 int val3 ;
4615 int ecode3 = 0 ;
4616 PyObject * obj0 = 0 ;
4617 PyObject * obj1 = 0 ;
4618 PyObject * obj2 = 0 ;
4619 char * kwnames[] = {
4620 (char *) "colour",(char *) "width",(char *) "style", NULL
4621 };
4622
4623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4624 {
4625 arg1 = &temp1;
4626 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
4627 }
4628 if (obj1) {
4629 ecode2 = SWIG_AsVal_int(obj1, &val2);
4630 if (!SWIG_IsOK(ecode2)) {
4631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pen" "', expected argument " "2"" of type '" "int""'");
4632 }
4633 arg2 = static_cast< int >(val2);
4634 }
4635 if (obj2) {
4636 ecode3 = SWIG_AsVal_int(obj2, &val3);
4637 if (!SWIG_IsOK(ecode3)) {
4638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pen" "', expected argument " "3"" of type '" "int""'");
4639 }
4640 arg3 = static_cast< int >(val3);
4641 }
4642 {
4643 if (!wxPyCheckForApp()) SWIG_fail;
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
4646 wxPyEndAllowThreads(__tstate);
4647 if (PyErr_Occurred()) SWIG_fail;
4648 }
4649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, SWIG_POINTER_NEW | 0 );
4650 return resultobj;
4651 fail:
4652 return NULL;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_delete_Pen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4657 PyObject *resultobj = 0;
4658 wxPen *arg1 = (wxPen *) 0 ;
4659 void *argp1 = 0 ;
4660 int res1 = 0 ;
4661 PyObject *swig_obj[1] ;
4662
4663 if (!args) SWIG_fail;
4664 swig_obj[0] = args;
4665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, SWIG_POINTER_DISOWN | 0 );
4666 if (!SWIG_IsOK(res1)) {
4667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pen" "', expected argument " "1"" of type '" "wxPen *""'");
4668 }
4669 arg1 = reinterpret_cast< wxPen * >(argp1);
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 delete arg1;
4673
4674 wxPyEndAllowThreads(__tstate);
4675 if (PyErr_Occurred()) SWIG_fail;
4676 }
4677 resultobj = SWIG_Py_Void();
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 SWIGINTERN PyObject *_wrap_Pen_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4685 PyObject *resultobj = 0;
4686 wxPen *arg1 = (wxPen *) 0 ;
4687 int result;
4688 void *argp1 = 0 ;
4689 int res1 = 0 ;
4690 PyObject *swig_obj[1] ;
4691
4692 if (!args) SWIG_fail;
4693 swig_obj[0] = args;
4694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4695 if (!SWIG_IsOK(res1)) {
4696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4697 }
4698 arg1 = reinterpret_cast< wxPen * >(argp1);
4699 {
4700 PyThreadState* __tstate = wxPyBeginAllowThreads();
4701 result = (int)(arg1)->GetCap();
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 resultobj = SWIG_From_int(static_cast< int >(result));
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_Pen_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4713 PyObject *resultobj = 0;
4714 wxPen *arg1 = (wxPen *) 0 ;
4715 wxColour result;
4716 void *argp1 = 0 ;
4717 int res1 = 0 ;
4718 PyObject *swig_obj[1] ;
4719
4720 if (!args) SWIG_fail;
4721 swig_obj[0] = args;
4722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4723 if (!SWIG_IsOK(res1)) {
4724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4725 }
4726 arg1 = reinterpret_cast< wxPen * >(argp1);
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (arg1)->GetColour();
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_Pen_GetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4741 PyObject *resultobj = 0;
4742 wxPen *arg1 = (wxPen *) 0 ;
4743 int result;
4744 void *argp1 = 0 ;
4745 int res1 = 0 ;
4746 PyObject *swig_obj[1] ;
4747
4748 if (!args) SWIG_fail;
4749 swig_obj[0] = args;
4750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4751 if (!SWIG_IsOK(res1)) {
4752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4753 }
4754 arg1 = reinterpret_cast< wxPen * >(argp1);
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 result = (int)(arg1)->GetJoin();
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 resultobj = SWIG_From_int(static_cast< int >(result));
4762 return resultobj;
4763 fail:
4764 return NULL;
4765 }
4766
4767
4768 SWIGINTERN PyObject *_wrap_Pen_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4769 PyObject *resultobj = 0;
4770 wxPen *arg1 = (wxPen *) 0 ;
4771 int result;
4772 void *argp1 = 0 ;
4773 int res1 = 0 ;
4774 PyObject *swig_obj[1] ;
4775
4776 if (!args) SWIG_fail;
4777 swig_obj[0] = args;
4778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4781 }
4782 arg1 = reinterpret_cast< wxPen * >(argp1);
4783 {
4784 PyThreadState* __tstate = wxPyBeginAllowThreads();
4785 result = (int)(arg1)->GetStyle();
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 resultobj = SWIG_From_int(static_cast< int >(result));
4790 return resultobj;
4791 fail:
4792 return NULL;
4793 }
4794
4795
4796 SWIGINTERN PyObject *_wrap_Pen_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4797 PyObject *resultobj = 0;
4798 wxPen *arg1 = (wxPen *) 0 ;
4799 int result;
4800 void *argp1 = 0 ;
4801 int res1 = 0 ;
4802 PyObject *swig_obj[1] ;
4803
4804 if (!args) SWIG_fail;
4805 swig_obj[0] = args;
4806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4807 if (!SWIG_IsOK(res1)) {
4808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
4809 }
4810 arg1 = reinterpret_cast< wxPen * >(argp1);
4811 {
4812 PyThreadState* __tstate = wxPyBeginAllowThreads();
4813 result = (int)(arg1)->GetWidth();
4814 wxPyEndAllowThreads(__tstate);
4815 if (PyErr_Occurred()) SWIG_fail;
4816 }
4817 resultobj = SWIG_From_int(static_cast< int >(result));
4818 return resultobj;
4819 fail:
4820 return NULL;
4821 }
4822
4823
4824 SWIGINTERN PyObject *_wrap_Pen_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4825 PyObject *resultobj = 0;
4826 wxPen *arg1 = (wxPen *) 0 ;
4827 bool result;
4828 void *argp1 = 0 ;
4829 int res1 = 0 ;
4830 PyObject *swig_obj[1] ;
4831
4832 if (!args) SWIG_fail;
4833 swig_obj[0] = args;
4834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4835 if (!SWIG_IsOK(res1)) {
4836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_Ok" "', expected argument " "1"" of type '" "wxPen *""'");
4837 }
4838 arg1 = reinterpret_cast< wxPen * >(argp1);
4839 {
4840 PyThreadState* __tstate = wxPyBeginAllowThreads();
4841 result = (bool)(arg1)->Ok();
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 {
4846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4847 }
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Pen_SetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxPen *arg1 = (wxPen *) 0 ;
4857 int arg2 ;
4858 void *argp1 = 0 ;
4859 int res1 = 0 ;
4860 int val2 ;
4861 int ecode2 = 0 ;
4862 PyObject * obj0 = 0 ;
4863 PyObject * obj1 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "self",(char *) "cap_style", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) SWIG_fail;
4869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetCap" "', expected argument " "1"" of type '" "wxPen *""'");
4872 }
4873 arg1 = reinterpret_cast< wxPen * >(argp1);
4874 ecode2 = SWIG_AsVal_int(obj1, &val2);
4875 if (!SWIG_IsOK(ecode2)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetCap" "', expected argument " "2"" of type '" "int""'");
4877 }
4878 arg2 = static_cast< int >(val2);
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 (arg1)->SetCap(arg2);
4882 wxPyEndAllowThreads(__tstate);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 resultobj = SWIG_Py_Void();
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 SWIGINTERN PyObject *_wrap_Pen_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxPen *arg1 = (wxPen *) 0 ;
4895 wxColour *arg2 = 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 wxColour temp2 ;
4899 PyObject * obj0 = 0 ;
4900 PyObject * obj1 = 0 ;
4901 char * kwnames[] = {
4902 (char *) "self",(char *) "colour", NULL
4903 };
4904
4905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
4906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4907 if (!SWIG_IsOK(res1)) {
4908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetColour" "', expected argument " "1"" of type '" "wxPen *""'");
4909 }
4910 arg1 = reinterpret_cast< wxPen * >(argp1);
4911 {
4912 arg2 = &temp2;
4913 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 (arg1)->SetColour(*arg2);
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 resultobj = SWIG_Py_Void();
4922 return resultobj;
4923 fail:
4924 return NULL;
4925 }
4926
4927
4928 SWIGINTERN PyObject *_wrap_Pen_SetJoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4929 PyObject *resultobj = 0;
4930 wxPen *arg1 = (wxPen *) 0 ;
4931 int arg2 ;
4932 void *argp1 = 0 ;
4933 int res1 = 0 ;
4934 int val2 ;
4935 int ecode2 = 0 ;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "self",(char *) "join_style", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) SWIG_fail;
4943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4944 if (!SWIG_IsOK(res1)) {
4945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetJoin" "', expected argument " "1"" of type '" "wxPen *""'");
4946 }
4947 arg1 = reinterpret_cast< wxPen * >(argp1);
4948 ecode2 = SWIG_AsVal_int(obj1, &val2);
4949 if (!SWIG_IsOK(ecode2)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetJoin" "', expected argument " "2"" of type '" "int""'");
4951 }
4952 arg2 = static_cast< int >(val2);
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->SetJoin(arg2);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Pen_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxPen *arg1 = (wxPen *) 0 ;
4969 int arg2 ;
4970 void *argp1 = 0 ;
4971 int res1 = 0 ;
4972 int val2 ;
4973 int ecode2 = 0 ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 char * kwnames[] = {
4977 (char *) "self",(char *) "style", NULL
4978 };
4979
4980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
4981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
4982 if (!SWIG_IsOK(res1)) {
4983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStyle" "', expected argument " "1"" of type '" "wxPen *""'");
4984 }
4985 arg1 = reinterpret_cast< wxPen * >(argp1);
4986 ecode2 = SWIG_AsVal_int(obj1, &val2);
4987 if (!SWIG_IsOK(ecode2)) {
4988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetStyle" "', expected argument " "2"" of type '" "int""'");
4989 }
4990 arg2 = static_cast< int >(val2);
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 (arg1)->SetStyle(arg2);
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 resultobj = SWIG_Py_Void();
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Pen_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj = 0;
5006 wxPen *arg1 = (wxPen *) 0 ;
5007 int arg2 ;
5008 void *argp1 = 0 ;
5009 int res1 = 0 ;
5010 int val2 ;
5011 int ecode2 = 0 ;
5012 PyObject * obj0 = 0 ;
5013 PyObject * obj1 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "self",(char *) "width", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetWidth" "', expected argument " "1"" of type '" "wxPen *""'");
5022 }
5023 arg1 = reinterpret_cast< wxPen * >(argp1);
5024 ecode2 = SWIG_AsVal_int(obj1, &val2);
5025 if (!SWIG_IsOK(ecode2)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pen_SetWidth" "', expected argument " "2"" of type '" "int""'");
5027 }
5028 arg2 = static_cast< int >(val2);
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 (arg1)->SetWidth(arg2);
5032 wxPyEndAllowThreads(__tstate);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_Py_Void();
5036 return resultobj;
5037 fail:
5038 return NULL;
5039 }
5040
5041
5042 SWIGINTERN PyObject *_wrap_Pen_SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5043 PyObject *resultobj = 0;
5044 wxPen *arg1 = (wxPen *) 0 ;
5045 int arg2 ;
5046 wxDash *arg3 = (wxDash *) 0 ;
5047 void *argp1 = 0 ;
5048 int res1 = 0 ;
5049 PyObject * obj0 = 0 ;
5050 PyObject * obj1 = 0 ;
5051 char * kwnames[] = {
5052 (char *) "self",(char *) "dashes", NULL
5053 };
5054
5055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) SWIG_fail;
5056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5057 if (!SWIG_IsOK(res1)) {
5058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5059 }
5060 arg1 = reinterpret_cast< wxPen * >(argp1);
5061 {
5062 arg2 = PyList_Size(obj1);
5063 arg3 = (wxDash*)byte_LIST_helper(obj1);
5064 if (arg3 == NULL) SWIG_fail;
5065 }
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 (arg1)->SetDashes(arg2,arg3);
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_Py_Void();
5073 {
5074 if (arg3) delete [] arg3;
5075 }
5076 return resultobj;
5077 fail:
5078 {
5079 if (arg3) delete [] arg3;
5080 }
5081 return NULL;
5082 }
5083
5084
5085 SWIGINTERN PyObject *_wrap_Pen_GetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 wxPen *arg1 = (wxPen *) 0 ;
5088 PyObject *result = 0 ;
5089 void *argp1 = 0 ;
5090 int res1 = 0 ;
5091 PyObject *swig_obj[1] ;
5092
5093 if (!args) SWIG_fail;
5094 swig_obj[0] = args;
5095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5096 if (!SWIG_IsOK(res1)) {
5097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5098 }
5099 arg1 = reinterpret_cast< wxPen * >(argp1);
5100 {
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 result = (PyObject *)wxPen_GetDashes(arg1);
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 resultobj = result;
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *_wrap_Pen__SetDashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5114 PyObject *resultobj = 0;
5115 wxPen *arg1 = (wxPen *) 0 ;
5116 PyObject *arg2 = (PyObject *) 0 ;
5117 PyObject *arg3 = (PyObject *) 0 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 PyObject * obj0 = 0 ;
5121 PyObject * obj1 = 0 ;
5122 PyObject * obj2 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen__SetDashes" "', expected argument " "1"" of type '" "wxPen *""'");
5131 }
5132 arg1 = reinterpret_cast< wxPen * >(argp1);
5133 arg2 = obj1;
5134 arg3 = obj2;
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 wxPen__SetDashes(arg1,arg2,arg3);
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 resultobj = SWIG_Py_Void();
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_Pen_GetDashCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxPen *arg1 = (wxPen *) 0 ;
5151 int result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetDashCount" "', expected argument " "1"" of type '" "wxPen const *""'");
5161 }
5162 arg1 = reinterpret_cast< wxPen * >(argp1);
5163 {
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 result = (int)((wxPen const *)arg1)->GetDashCount();
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_From_int(static_cast< int >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Pen_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxPen *arg1 = (wxPen *) 0 ;
5179 wxBitmap *result = 0 ;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 PyObject *swig_obj[1] ;
5183
5184 if (!args) SWIG_fail;
5185 swig_obj[0] = args;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_GetStipple" "', expected argument " "1"" of type '" "wxPen *""'");
5189 }
5190 arg1 = reinterpret_cast< wxPen * >(argp1);
5191 {
5192 PyThreadState* __tstate = wxPyBeginAllowThreads();
5193 result = (wxBitmap *)(arg1)->GetStipple();
5194 wxPyEndAllowThreads(__tstate);
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 SWIGINTERN PyObject *_wrap_Pen_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5205 PyObject *resultobj = 0;
5206 wxPen *arg1 = (wxPen *) 0 ;
5207 wxBitmap *arg2 = 0 ;
5208 void *argp1 = 0 ;
5209 int res1 = 0 ;
5210 void *argp2 = 0 ;
5211 int res2 = 0 ;
5212 PyObject * obj0 = 0 ;
5213 PyObject * obj1 = 0 ;
5214 char * kwnames[] = {
5215 (char *) "self",(char *) "stipple", NULL
5216 };
5217
5218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5220 if (!SWIG_IsOK(res1)) {
5221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen_SetStipple" "', expected argument " "1"" of type '" "wxPen *""'");
5222 }
5223 arg1 = reinterpret_cast< wxPen * >(argp1);
5224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 );
5225 if (!SWIG_IsOK(res2)) {
5226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen_SetStipple" "', expected argument " "2"" of type '" "wxBitmap &""'");
5227 }
5228 if (!argp2) {
5229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pen_SetStipple" "', expected argument " "2"" of type '" "wxBitmap &""'");
5230 }
5231 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 (arg1)->SetStipple(*arg2);
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 resultobj = SWIG_Py_Void();
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 SWIGINTERN PyObject *_wrap_Pen___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj = 0;
5247 wxPen *arg1 = (wxPen *) 0 ;
5248 wxPen *arg2 = (wxPen *) 0 ;
5249 bool result;
5250 void *argp1 = 0 ;
5251 int res1 = 0 ;
5252 void *argp2 = 0 ;
5253 int res2 = 0 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "self",(char *) "other", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___eq__" "', expected argument " "1"" of type '" "wxPen *""'");
5264 }
5265 arg1 = reinterpret_cast< wxPen * >(argp1);
5266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5267 if (!SWIG_IsOK(res2)) {
5268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___eq__" "', expected argument " "2"" of type '" "wxPen const *""'");
5269 }
5270 arg2 = reinterpret_cast< wxPen * >(argp2);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 {
5278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5279 }
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *_wrap_Pen___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5287 PyObject *resultobj = 0;
5288 wxPen *arg1 = (wxPen *) 0 ;
5289 wxPen *arg2 = (wxPen *) 0 ;
5290 bool result;
5291 void *argp1 = 0 ;
5292 int res1 = 0 ;
5293 void *argp2 = 0 ;
5294 int res2 = 0 ;
5295 PyObject * obj0 = 0 ;
5296 PyObject * obj1 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "self",(char *) "other", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPen, 0 | 0 );
5303 if (!SWIG_IsOK(res1)) {
5304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pen___ne__" "', expected argument " "1"" of type '" "wxPen *""'");
5305 }
5306 arg1 = reinterpret_cast< wxPen * >(argp1);
5307 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
5308 if (!SWIG_IsOK(res2)) {
5309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pen___ne__" "', expected argument " "2"" of type '" "wxPen const *""'");
5310 }
5311 arg2 = reinterpret_cast< wxPen * >(argp2);
5312 {
5313 PyThreadState* __tstate = wxPyBeginAllowThreads();
5314 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
5315 wxPyEndAllowThreads(__tstate);
5316 if (PyErr_Occurred()) SWIG_fail;
5317 }
5318 {
5319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5320 }
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *Pen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *obj;
5329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5330 SWIG_TypeNewClientData(SWIGTYPE_p_wxPen, SWIG_NewClientData(obj));
5331 return SWIG_Py_Void();
5332 }
5333
5334 SWIGINTERN PyObject *Pen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 return SWIG_Python_InitShadowInstance(args);
5336 }
5337
5338 SWIGINTERN PyObject *_wrap_new_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5339 PyObject *resultobj = 0;
5340 wxColour *arg1 = 0 ;
5341 int arg2 = (int) wxSOLID ;
5342 wxBrush *result = 0 ;
5343 wxColour temp1 ;
5344 int val2 ;
5345 int ecode2 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 char * kwnames[] = {
5349 (char *) "colour",(char *) "style", NULL
5350 };
5351
5352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) SWIG_fail;
5353 {
5354 arg1 = &temp1;
5355 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
5356 }
5357 if (obj1) {
5358 ecode2 = SWIG_AsVal_int(obj1, &val2);
5359 if (!SWIG_IsOK(ecode2)) {
5360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Brush" "', expected argument " "2"" of type '" "int""'");
5361 }
5362 arg2 = static_cast< int >(val2);
5363 }
5364 {
5365 if (!wxPyCheckForApp()) SWIG_fail;
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_NEW | 0 );
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_new_BrushFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxBitmap *arg1 = 0 ;
5381 wxBrush *result = 0 ;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject * obj0 = 0 ;
5385 char * kwnames[] = {
5386 (char *) "stippleBitmap", NULL
5387 };
5388
5389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) SWIG_fail;
5390 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5393 }
5394 if (!argp1) {
5395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrushFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
5396 }
5397 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5398 {
5399 if (!wxPyCheckForApp()) SWIG_fail;
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
5402 wxPyEndAllowThreads(__tstate);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, SWIG_POINTER_OWN | 0 );
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_delete_Brush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *resultobj = 0;
5414 wxBrush *arg1 = (wxBrush *) 0 ;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 PyObject *swig_obj[1] ;
5418
5419 if (!args) SWIG_fail;
5420 swig_obj[0] = args;
5421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, SWIG_POINTER_DISOWN | 0 );
5422 if (!SWIG_IsOK(res1)) {
5423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brush" "', expected argument " "1"" of type '" "wxBrush *""'");
5424 }
5425 arg1 = reinterpret_cast< wxBrush * >(argp1);
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 delete arg1;
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 resultobj = SWIG_Py_Void();
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_Brush_SetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 wxBrush *arg1 = (wxBrush *) 0 ;
5443 wxColour *arg2 = 0 ;
5444 void *argp1 = 0 ;
5445 int res1 = 0 ;
5446 wxColour temp2 ;
5447 PyObject * obj0 = 0 ;
5448 PyObject * obj1 = 0 ;
5449 char * kwnames[] = {
5450 (char *) "self",(char *) "col", NULL
5451 };
5452
5453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) SWIG_fail;
5454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetColour" "', expected argument " "1"" of type '" "wxBrush *""'");
5457 }
5458 arg1 = reinterpret_cast< wxBrush * >(argp1);
5459 {
5460 arg2 = &temp2;
5461 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5462 }
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 (arg1)->SetColour((wxColour const &)*arg2);
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 resultobj = SWIG_Py_Void();
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_Brush_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj = 0;
5478 wxBrush *arg1 = (wxBrush *) 0 ;
5479 int arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 int val2 ;
5483 int ecode2 = 0 ;
5484 PyObject * obj0 = 0 ;
5485 PyObject * obj1 = 0 ;
5486 char * kwnames[] = {
5487 (char *) "self",(char *) "style", NULL
5488 };
5489
5490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
5491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5492 if (!SWIG_IsOK(res1)) {
5493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStyle" "', expected argument " "1"" of type '" "wxBrush *""'");
5494 }
5495 arg1 = reinterpret_cast< wxBrush * >(argp1);
5496 ecode2 = SWIG_AsVal_int(obj1, &val2);
5497 if (!SWIG_IsOK(ecode2)) {
5498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brush_SetStyle" "', expected argument " "2"" of type '" "int""'");
5499 }
5500 arg2 = static_cast< int >(val2);
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 (arg1)->SetStyle(arg2);
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 resultobj = SWIG_Py_Void();
5508 return resultobj;
5509 fail:
5510 return NULL;
5511 }
5512
5513
5514 SWIGINTERN PyObject *_wrap_Brush_SetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5515 PyObject *resultobj = 0;
5516 wxBrush *arg1 = (wxBrush *) 0 ;
5517 wxBitmap *arg2 = 0 ;
5518 void *argp1 = 0 ;
5519 int res1 = 0 ;
5520 void *argp2 = 0 ;
5521 int res2 = 0 ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char * kwnames[] = {
5525 (char *) "self",(char *) "stipple", NULL
5526 };
5527
5528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) SWIG_fail;
5529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5530 if (!SWIG_IsOK(res1)) {
5531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_SetStipple" "', expected argument " "1"" of type '" "wxBrush *""'");
5532 }
5533 arg1 = reinterpret_cast< wxBrush * >(argp1);
5534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
5535 if (!SWIG_IsOK(res2)) {
5536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5537 }
5538 if (!argp2) {
5539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Brush_SetStipple" "', expected argument " "2"" of type '" "wxBitmap const &""'");
5540 }
5541 arg2 = reinterpret_cast< wxBitmap * >(argp2);
5542 {
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 (arg1)->SetStipple((wxBitmap const &)*arg2);
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 resultobj = SWIG_Py_Void();
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_Brush_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxBrush *arg1 = (wxBrush *) 0 ;
5558 wxColour result;
5559 void *argp1 = 0 ;
5560 int res1 = 0 ;
5561 PyObject *swig_obj[1] ;
5562
5563 if (!args) SWIG_fail;
5564 swig_obj[0] = args;
5565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetColour" "', expected argument " "1"" of type '" "wxBrush const *""'");
5568 }
5569 arg1 = reinterpret_cast< wxBrush * >(argp1);
5570 {
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 result = ((wxBrush const *)arg1)->GetColour();
5573 wxPyEndAllowThreads(__tstate);
5574 if (PyErr_Occurred()) SWIG_fail;
5575 }
5576 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 SWIGINTERN PyObject *_wrap_Brush_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5584 PyObject *resultobj = 0;
5585 wxBrush *arg1 = (wxBrush *) 0 ;
5586 int result;
5587 void *argp1 = 0 ;
5588 int res1 = 0 ;
5589 PyObject *swig_obj[1] ;
5590
5591 if (!args) SWIG_fail;
5592 swig_obj[0] = args;
5593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5594 if (!SWIG_IsOK(res1)) {
5595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStyle" "', expected argument " "1"" of type '" "wxBrush const *""'");
5596 }
5597 arg1 = reinterpret_cast< wxBrush * >(argp1);
5598 {
5599 PyThreadState* __tstate = wxPyBeginAllowThreads();
5600 result = (int)((wxBrush const *)arg1)->GetStyle();
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 resultobj = SWIG_From_int(static_cast< int >(result));
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 SWIGINTERN PyObject *_wrap_Brush_GetStipple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5612 PyObject *resultobj = 0;
5613 wxBrush *arg1 = (wxBrush *) 0 ;
5614 wxBitmap *result = 0 ;
5615 void *argp1 = 0 ;
5616 int res1 = 0 ;
5617 PyObject *swig_obj[1] ;
5618
5619 if (!args) SWIG_fail;
5620 swig_obj[0] = args;
5621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5622 if (!SWIG_IsOK(res1)) {
5623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_GetStipple" "', expected argument " "1"" of type '" "wxBrush const *""'");
5624 }
5625 arg1 = reinterpret_cast< wxBrush * >(argp1);
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, 0 | 0 );
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_Brush_IsHatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5640 PyObject *resultobj = 0;
5641 wxBrush *arg1 = (wxBrush *) 0 ;
5642 bool result;
5643 void *argp1 = 0 ;
5644 int res1 = 0 ;
5645 PyObject *swig_obj[1] ;
5646
5647 if (!args) SWIG_fail;
5648 swig_obj[0] = args;
5649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5650 if (!SWIG_IsOK(res1)) {
5651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_IsHatch" "', expected argument " "1"" of type '" "wxBrush const *""'");
5652 }
5653 arg1 = reinterpret_cast< wxBrush * >(argp1);
5654 {
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 result = (bool)((wxBrush const *)arg1)->IsHatch();
5657 wxPyEndAllowThreads(__tstate);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 {
5661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5662 }
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 SWIGINTERN PyObject *_wrap_Brush_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5670 PyObject *resultobj = 0;
5671 wxBrush *arg1 = (wxBrush *) 0 ;
5672 bool result;
5673 void *argp1 = 0 ;
5674 int res1 = 0 ;
5675 PyObject *swig_obj[1] ;
5676
5677 if (!args) SWIG_fail;
5678 swig_obj[0] = args;
5679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBrush, 0 | 0 );
5680 if (!SWIG_IsOK(res1)) {
5681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brush_Ok" "', expected argument " "1"" of type '" "wxBrush *""'");
5682 }
5683 arg1 = reinterpret_cast< wxBrush * >(argp1);
5684 {
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 result = (bool)(arg1)->Ok();
5687 wxPyEndAllowThreads(__tstate);
5688 if (PyErr_Occurred()) SWIG_fail;
5689 }
5690 {
5691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5692 }
5693 return resultobj;
5694 fail:
5695 return NULL;
5696 }
5697
5698
5699 SWIGINTERN PyObject *Brush_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5700 PyObject *obj;
5701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5702 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrush, SWIG_NewClientData(obj));
5703 return SWIG_Py_Void();
5704 }
5705
5706 SWIGINTERN PyObject *Brush_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5707 return SWIG_Python_InitShadowInstance(args);
5708 }
5709
5710 SWIGINTERN PyObject *_wrap_new_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 wxString *arg1 = 0 ;
5713 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
5714 wxBitmap *result = 0 ;
5715 bool temp1 = false ;
5716 int val2 ;
5717 int ecode2 = 0 ;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 char * kwnames[] = {
5721 (char *) "name",(char *) "type", NULL
5722 };
5723
5724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) SWIG_fail;
5725 {
5726 arg1 = wxString_in_helper(obj0);
5727 if (arg1 == NULL) SWIG_fail;
5728 temp1 = true;
5729 }
5730 if (obj1) {
5731 ecode2 = SWIG_AsVal_int(obj1, &val2);
5732 if (!SWIG_IsOK(ecode2)) {
5733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Bitmap" "', expected argument " "2"" of type '" "wxBitmapType""'");
5734 }
5735 arg2 = static_cast< wxBitmapType >(val2);
5736 }
5737 {
5738 if (!wxPyCheckForApp()) SWIG_fail;
5739 PyThreadState* __tstate = wxPyBeginAllowThreads();
5740 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,arg2);
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_NEW | 0 );
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 return resultobj;
5750 fail:
5751 {
5752 if (temp1)
5753 delete arg1;
5754 }
5755 return NULL;
5756 }
5757
5758
5759 SWIGINTERN PyObject *_wrap_delete_Bitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5760 PyObject *resultobj = 0;
5761 wxBitmap *arg1 = (wxBitmap *) 0 ;
5762 void *argp1 = 0 ;
5763 int res1 = 0 ;
5764 PyObject *swig_obj[1] ;
5765
5766 if (!args) SWIG_fail;
5767 swig_obj[0] = args;
5768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, SWIG_POINTER_DISOWN | 0 );
5769 if (!SWIG_IsOK(res1)) {
5770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bitmap" "', expected argument " "1"" of type '" "wxBitmap *""'");
5771 }
5772 arg1 = reinterpret_cast< wxBitmap * >(argp1);
5773 {
5774 delete arg1;
5775
5776 if (PyErr_Occurred()) SWIG_fail;
5777 }
5778 resultobj = SWIG_Py_Void();
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 SWIGINTERN PyObject *_wrap_new_EmptyBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = 0;
5787 int arg1 ;
5788 int arg2 ;
5789 int arg3 = (int) -1 ;
5790 wxBitmap *result = 0 ;
5791 int val1 ;
5792 int ecode1 = 0 ;
5793 int val2 ;
5794 int ecode2 = 0 ;
5795 int val3 ;
5796 int ecode3 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 PyObject * obj2 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "width",(char *) "height",(char *) "depth", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5805 ecode1 = SWIG_AsVal_int(obj0, &val1);
5806 if (!SWIG_IsOK(ecode1)) {
5807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyBitmap" "', expected argument " "1"" of type '" "int""'");
5808 }
5809 arg1 = static_cast< int >(val1);
5810 ecode2 = SWIG_AsVal_int(obj1, &val2);
5811 if (!SWIG_IsOK(ecode2)) {
5812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyBitmap" "', expected argument " "2"" of type '" "int""'");
5813 }
5814 arg2 = static_cast< int >(val2);
5815 if (obj2) {
5816 ecode3 = SWIG_AsVal_int(obj2, &val3);
5817 if (!SWIG_IsOK(ecode3)) {
5818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyBitmap" "', expected argument " "3"" of type '" "int""'");
5819 }
5820 arg3 = static_cast< int >(val3);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5830 return resultobj;
5831 fail:
5832 return NULL;
5833 }
5834
5835
5836 SWIGINTERN PyObject *_wrap_new_BitmapFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5837 PyObject *resultobj = 0;
5838 wxIcon *arg1 = 0 ;
5839 wxBitmap *result = 0 ;
5840 void *argp1 = 0 ;
5841 int res1 = 0 ;
5842 PyObject * obj0 = 0 ;
5843 char * kwnames[] = {
5844 (char *) "icon", NULL
5845 };
5846
5847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) SWIG_fail;
5848 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
5849 if (!SWIG_IsOK(res1)) {
5850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5851 }
5852 if (!argp1) {
5853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
5854 }
5855 arg1 = reinterpret_cast< wxIcon * >(argp1);
5856 {
5857 if (!wxPyCheckForApp()) SWIG_fail;
5858 PyThreadState* __tstate = wxPyBeginAllowThreads();
5859 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
5860 wxPyEndAllowThreads(__tstate);
5861 if (PyErr_Occurred()) SWIG_fail;
5862 }
5863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 SWIGINTERN PyObject *_wrap_new_BitmapFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj = 0;
5872 wxImage *arg1 = 0 ;
5873 int arg2 = (int) -1 ;
5874 wxBitmap *result = 0 ;
5875 void *argp1 = 0 ;
5876 int res1 = 0 ;
5877 int val2 ;
5878 int ecode2 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 PyObject * obj1 = 0 ;
5881 char * kwnames[] = {
5882 (char *) "image",(char *) "depth", NULL
5883 };
5884
5885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) SWIG_fail;
5886 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
5887 if (!SWIG_IsOK(res1)) {
5888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5889 }
5890 if (!argp1) {
5891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
5892 }
5893 arg1 = reinterpret_cast< wxImage * >(argp1);
5894 if (obj1) {
5895 ecode2 = SWIG_AsVal_int(obj1, &val2);
5896 if (!SWIG_IsOK(ecode2)) {
5897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromImage" "', expected argument " "2"" of type '" "int""'");
5898 }
5899 arg2 = static_cast< int >(val2);
5900 }
5901 {
5902 if (!wxPyCheckForApp()) SWIG_fail;
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5909 return resultobj;
5910 fail:
5911 return NULL;
5912 }
5913
5914
5915 SWIGINTERN PyObject *_wrap_new_BitmapFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj = 0;
5917 PyObject *arg1 = (PyObject *) 0 ;
5918 wxBitmap *result = 0 ;
5919 PyObject * obj0 = 0 ;
5920 char * kwnames[] = {
5921 (char *) "listOfStrings", NULL
5922 };
5923
5924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) SWIG_fail;
5925 arg1 = obj0;
5926 {
5927 if (!wxPyCheckForApp()) SWIG_fail;
5928 PyThreadState* __tstate = wxPyBeginAllowThreads();
5929 result = (wxBitmap *)new_wxBitmap(arg1);
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 SWIGINTERN PyObject *_wrap_new_BitmapFromBits(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = 0;
5942 PyObject *arg1 = (PyObject *) 0 ;
5943 int arg2 ;
5944 int arg3 ;
5945 int arg4 = (int) 1 ;
5946 wxBitmap *result = 0 ;
5947 int val2 ;
5948 int ecode2 = 0 ;
5949 int val3 ;
5950 int ecode3 = 0 ;
5951 int val4 ;
5952 int ecode4 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 PyObject * obj2 = 0 ;
5956 PyObject * obj3 = 0 ;
5957 char * kwnames[] = {
5958 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
5959 };
5960
5961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5962 arg1 = obj0;
5963 ecode2 = SWIG_AsVal_int(obj1, &val2);
5964 if (!SWIG_IsOK(ecode2)) {
5965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BitmapFromBits" "', expected argument " "2"" of type '" "int""'");
5966 }
5967 arg2 = static_cast< int >(val2);
5968 ecode3 = SWIG_AsVal_int(obj2, &val3);
5969 if (!SWIG_IsOK(ecode3)) {
5970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BitmapFromBits" "', expected argument " "3"" of type '" "int""'");
5971 }
5972 arg3 = static_cast< int >(val3);
5973 if (obj3) {
5974 ecode4 = SWIG_AsVal_int(obj3, &val4);
5975 if (!SWIG_IsOK(ecode4)) {
5976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BitmapFromBits" "', expected argument " "4"" of type '" "int""'");
5977 }
5978 arg4 = static_cast< int >(val4);
5979 }
5980 {
5981 if (!wxPyCheckForApp()) SWIG_fail;
5982 PyThreadState* __tstate = wxPyBeginAllowThreads();
5983 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 SWIGINTERN PyObject *_wrap_Bitmap_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5995 PyObject *resultobj = 0;
5996 wxBitmap *arg1 = (wxBitmap *) 0 ;
5997 long result;
5998 void *argp1 = 0 ;
5999 int res1 = 0 ;
6000 PyObject *swig_obj[1] ;
6001
6002 if (!args) SWIG_fail;
6003 swig_obj[0] = args;
6004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHandle" "', expected argument " "1"" of type '" "wxBitmap *""'");
6007 }
6008 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6009 {
6010 result = (long)(arg1)->GetHandle();
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 resultobj = SWIG_From_long(static_cast< long >(result));
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 SWIGINTERN PyObject *_wrap_Bitmap_SetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = 0;
6022 wxBitmap *arg1 = (wxBitmap *) 0 ;
6023 long arg2 ;
6024 void *argp1 = 0 ;
6025 int res1 = 0 ;
6026 long val2 ;
6027 int ecode2 = 0 ;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 char * kwnames[] = {
6031 (char *) "self",(char *) "handle", NULL
6032 };
6033
6034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) SWIG_fail;
6035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6036 if (!SWIG_IsOK(res1)) {
6037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHandle" "', expected argument " "1"" of type '" "wxBitmap *""'");
6038 }
6039 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6040 ecode2 = SWIG_AsVal_long(obj1, &val2);
6041 if (!SWIG_IsOK(ecode2)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHandle" "', expected argument " "2"" of type '" "long""'");
6043 }
6044 arg2 = static_cast< long >(val2);
6045 {
6046 wxBitmap_SetHandle(arg1,arg2);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_Py_Void();
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_Bitmap_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6057 PyObject *resultobj = 0;
6058 wxBitmap *arg1 = (wxBitmap *) 0 ;
6059 bool result;
6060 void *argp1 = 0 ;
6061 int res1 = 0 ;
6062 PyObject *swig_obj[1] ;
6063
6064 if (!args) SWIG_fail;
6065 swig_obj[0] = args;
6066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6067 if (!SWIG_IsOK(res1)) {
6068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_Ok" "', expected argument " "1"" of type '" "wxBitmap *""'");
6069 }
6070 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6071 {
6072 result = (bool)(arg1)->Ok();
6073 if (PyErr_Occurred()) SWIG_fail;
6074 }
6075 {
6076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6077 }
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_Bitmap_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6085 PyObject *resultobj = 0;
6086 wxBitmap *arg1 = (wxBitmap *) 0 ;
6087 int result;
6088 void *argp1 = 0 ;
6089 int res1 = 0 ;
6090 PyObject *swig_obj[1] ;
6091
6092 if (!args) SWIG_fail;
6093 swig_obj[0] = args;
6094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6095 if (!SWIG_IsOK(res1)) {
6096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6097 }
6098 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6099 {
6100 result = (int)(arg1)->GetWidth();
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_From_int(static_cast< int >(result));
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 SWIGINTERN PyObject *_wrap_Bitmap_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6111 PyObject *resultobj = 0;
6112 wxBitmap *arg1 = (wxBitmap *) 0 ;
6113 int result;
6114 void *argp1 = 0 ;
6115 int res1 = 0 ;
6116 PyObject *swig_obj[1] ;
6117
6118 if (!args) SWIG_fail;
6119 swig_obj[0] = args;
6120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6121 if (!SWIG_IsOK(res1)) {
6122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6123 }
6124 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6125 {
6126 result = (int)(arg1)->GetHeight();
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_From_int(static_cast< int >(result));
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 SWIGINTERN PyObject *_wrap_Bitmap_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6137 PyObject *resultobj = 0;
6138 wxBitmap *arg1 = (wxBitmap *) 0 ;
6139 int result;
6140 void *argp1 = 0 ;
6141 int res1 = 0 ;
6142 PyObject *swig_obj[1] ;
6143
6144 if (!args) SWIG_fail;
6145 swig_obj[0] = args;
6146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6147 if (!SWIG_IsOK(res1)) {
6148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6149 }
6150 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6151 {
6152 result = (int)(arg1)->GetDepth();
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 resultobj = SWIG_From_int(static_cast< int >(result));
6156 return resultobj;
6157 fail:
6158 return NULL;
6159 }
6160
6161
6162 SWIGINTERN PyObject *_wrap_Bitmap_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6163 PyObject *resultobj = 0;
6164 wxBitmap *arg1 = (wxBitmap *) 0 ;
6165 wxSize result;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 PyObject *swig_obj[1] ;
6169
6170 if (!args) SWIG_fail;
6171 swig_obj[0] = args;
6172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6173 if (!SWIG_IsOK(res1)) {
6174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6175 }
6176 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6177 {
6178 result = wxBitmap_GetSize(arg1);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6182 return resultobj;
6183 fail:
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_Bitmap_ConvertToImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6189 PyObject *resultobj = 0;
6190 wxBitmap *arg1 = (wxBitmap *) 0 ;
6191 SwigValueWrapper<wxImage > result;
6192 void *argp1 = 0 ;
6193 int res1 = 0 ;
6194 PyObject *swig_obj[1] ;
6195
6196 if (!args) SWIG_fail;
6197 swig_obj[0] = args;
6198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6199 if (!SWIG_IsOK(res1)) {
6200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_ConvertToImage" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6201 }
6202 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6203 {
6204 result = ((wxBitmap const *)arg1)->ConvertToImage();
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
6208 return resultobj;
6209 fail:
6210 return NULL;
6211 }
6212
6213
6214 SWIGINTERN PyObject *_wrap_Bitmap_GetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6215 PyObject *resultobj = 0;
6216 wxBitmap *arg1 = (wxBitmap *) 0 ;
6217 wxMask *result = 0 ;
6218 void *argp1 = 0 ;
6219 int res1 = 0 ;
6220 PyObject *swig_obj[1] ;
6221
6222 if (!args) SWIG_fail;
6223 swig_obj[0] = args;
6224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6225 if (!SWIG_IsOK(res1)) {
6226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetMask" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6227 }
6228 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6229 {
6230 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
6231 if (PyErr_Occurred()) SWIG_fail;
6232 }
6233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, 0 | 0 );
6234 return resultobj;
6235 fail:
6236 return NULL;
6237 }
6238
6239
6240 SWIGINTERN PyObject *_wrap_Bitmap_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6241 PyObject *resultobj = 0;
6242 wxBitmap *arg1 = (wxBitmap *) 0 ;
6243 wxMask *arg2 = (wxMask *) 0 ;
6244 void *argp1 = 0 ;
6245 int res1 = 0 ;
6246 int res2 = 0 ;
6247 PyObject * obj0 = 0 ;
6248 PyObject * obj1 = 0 ;
6249 char * kwnames[] = {
6250 (char *) "self",(char *) "mask", NULL
6251 };
6252
6253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
6254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6255 if (!SWIG_IsOK(res1)) {
6256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMask" "', expected argument " "1"" of type '" "wxBitmap *""'");
6257 }
6258 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6259 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res2)) {
6261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetMask" "', expected argument " "2"" of type '" "wxMask *""'");
6262 }
6263 {
6264 (arg1)->SetMask(arg2);
6265 if (PyErr_Occurred()) SWIG_fail;
6266 }
6267 resultobj = SWIG_Py_Void();
6268 return resultobj;
6269 fail:
6270 return NULL;
6271 }
6272
6273
6274 SWIGINTERN PyObject *_wrap_Bitmap_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6275 PyObject *resultobj = 0;
6276 wxBitmap *arg1 = (wxBitmap *) 0 ;
6277 wxColour *arg2 = 0 ;
6278 void *argp1 = 0 ;
6279 int res1 = 0 ;
6280 wxColour temp2 ;
6281 PyObject * obj0 = 0 ;
6282 PyObject * obj1 = 0 ;
6283 char * kwnames[] = {
6284 (char *) "self",(char *) "colour", NULL
6285 };
6286
6287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) SWIG_fail;
6288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetMaskColour" "', expected argument " "1"" of type '" "wxBitmap *""'");
6291 }
6292 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6293 {
6294 arg2 = &temp2;
6295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6296 }
6297 {
6298 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
6299 if (PyErr_Occurred()) SWIG_fail;
6300 }
6301 resultobj = SWIG_Py_Void();
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 SWIGINTERN PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj = 0;
6310 wxBitmap *arg1 = (wxBitmap *) 0 ;
6311 wxRect *arg2 = 0 ;
6312 SwigValueWrapper<wxBitmap > result;
6313 void *argp1 = 0 ;
6314 int res1 = 0 ;
6315 wxRect temp2 ;
6316 PyObject * obj0 = 0 ;
6317 PyObject * obj1 = 0 ;
6318 char * kwnames[] = {
6319 (char *) "self",(char *) "rect", NULL
6320 };
6321
6322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
6323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6324 if (!SWIG_IsOK(res1)) {
6325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetSubBitmap" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6326 }
6327 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6328 {
6329 arg2 = &temp2;
6330 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6331 }
6332 {
6333 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Bitmap_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj = 0;
6345 wxBitmap *arg1 = (wxBitmap *) 0 ;
6346 wxString *arg2 = 0 ;
6347 wxBitmapType arg3 ;
6348 wxPalette *arg4 = (wxPalette *) NULL ;
6349 bool result;
6350 void *argp1 = 0 ;
6351 int res1 = 0 ;
6352 bool temp2 = false ;
6353 int val3 ;
6354 int ecode3 = 0 ;
6355 void *argp4 = 0 ;
6356 int res4 = 0 ;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 PyObject * obj2 = 0 ;
6360 PyObject * obj3 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SaveFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6369 }
6370 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6371 {
6372 arg2 = wxString_in_helper(obj1);
6373 if (arg2 == NULL) SWIG_fail;
6374 temp2 = true;
6375 }
6376 ecode3 = SWIG_AsVal_int(obj2, &val3);
6377 if (!SWIG_IsOK(ecode3)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_SaveFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6379 }
6380 arg3 = static_cast< wxBitmapType >(val3);
6381 if (obj3) {
6382 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxPalette, 0 | 0 );
6383 if (!SWIG_IsOK(res4)) {
6384 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Bitmap_SaveFile" "', expected argument " "4"" of type '" "wxPalette *""'");
6385 }
6386 arg4 = reinterpret_cast< wxPalette * >(argp4);
6387 }
6388 {
6389 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3,arg4);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 {
6393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6394 }
6395 {
6396 if (temp2)
6397 delete arg2;
6398 }
6399 return resultobj;
6400 fail:
6401 {
6402 if (temp2)
6403 delete arg2;
6404 }
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Bitmap_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxBitmap *arg1 = (wxBitmap *) 0 ;
6412 wxString *arg2 = 0 ;
6413 wxBitmapType arg3 ;
6414 bool result;
6415 void *argp1 = 0 ;
6416 int res1 = 0 ;
6417 bool temp2 = false ;
6418 int val3 ;
6419 int ecode3 = 0 ;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 PyObject * obj2 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "self",(char *) "name",(char *) "type", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6429 if (!SWIG_IsOK(res1)) {
6430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_LoadFile" "', expected argument " "1"" of type '" "wxBitmap *""'");
6431 }
6432 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6433 {
6434 arg2 = wxString_in_helper(obj1);
6435 if (arg2 == NULL) SWIG_fail;
6436 temp2 = true;
6437 }
6438 ecode3 = SWIG_AsVal_int(obj2, &val3);
6439 if (!SWIG_IsOK(ecode3)) {
6440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bitmap_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
6441 }
6442 arg3 = static_cast< wxBitmapType >(val3);
6443 {
6444 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
6445 if (PyErr_Occurred()) SWIG_fail;
6446 }
6447 {
6448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6449 }
6450 {
6451 if (temp2)
6452 delete arg2;
6453 }
6454 return resultobj;
6455 fail:
6456 {
6457 if (temp2)
6458 delete arg2;
6459 }
6460 return NULL;
6461 }
6462
6463
6464 SWIGINTERN PyObject *_wrap_Bitmap_GetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6465 PyObject *resultobj = 0;
6466 wxBitmap *arg1 = (wxBitmap *) 0 ;
6467 wxPalette *result = 0 ;
6468 void *argp1 = 0 ;
6469 int res1 = 0 ;
6470 PyObject *swig_obj[1] ;
6471
6472 if (!args) SWIG_fail;
6473 swig_obj[0] = args;
6474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6475 if (!SWIG_IsOK(res1)) {
6476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_GetPalette" "', expected argument " "1"" of type '" "wxBitmap const *""'");
6477 }
6478 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6479 {
6480 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPalette, 0 | 0 );
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_Bitmap_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj = 0;
6492 wxBitmap *arg1 = (wxBitmap *) 0 ;
6493 wxPalette *arg2 = 0 ;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 void *argp2 = 0 ;
6497 int res2 = 0 ;
6498 PyObject * obj0 = 0 ;
6499 PyObject * obj1 = 0 ;
6500 char * kwnames[] = {
6501 (char *) "self",(char *) "palette", NULL
6502 };
6503
6504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
6505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6506 if (!SWIG_IsOK(res1)) {
6507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetPalette" "', expected argument " "1"" of type '" "wxBitmap *""'");
6508 }
6509 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
6511 if (!SWIG_IsOK(res2)) {
6512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
6513 }
6514 if (!argp2) {
6515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
6516 }
6517 arg2 = reinterpret_cast< wxPalette * >(argp2);
6518 {
6519 (arg1)->SetPalette((wxPalette const &)*arg2);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 resultobj = SWIG_Py_Void();
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6530 PyObject *resultobj = 0;
6531 wxBitmap *arg1 = (wxBitmap *) 0 ;
6532 wxIcon *arg2 = 0 ;
6533 bool result;
6534 void *argp1 = 0 ;
6535 int res1 = 0 ;
6536 void *argp2 = 0 ;
6537 int res2 = 0 ;
6538 PyObject * obj0 = 0 ;
6539 PyObject * obj1 = 0 ;
6540 char * kwnames[] = {
6541 (char *) "self",(char *) "icon", NULL
6542 };
6543
6544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) SWIG_fail;
6545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6546 if (!SWIG_IsOK(res1)) {
6547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "1"" of type '" "wxBitmap *""'");
6548 }
6549 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
6551 if (!SWIG_IsOK(res2)) {
6552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6553 }
6554 if (!argp2) {
6555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
6556 }
6557 arg2 = reinterpret_cast< wxIcon * >(argp2);
6558 {
6559 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 {
6563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6564 }
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Bitmap_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj = 0;
6573 wxBitmap *arg1 = (wxBitmap *) 0 ;
6574 int arg2 ;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 int val2 ;
6578 int ecode2 = 0 ;
6579 PyObject * obj0 = 0 ;
6580 PyObject * obj1 = 0 ;
6581 char * kwnames[] = {
6582 (char *) "self",(char *) "height", NULL
6583 };
6584
6585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6587 if (!SWIG_IsOK(res1)) {
6588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetHeight" "', expected argument " "1"" of type '" "wxBitmap *""'");
6589 }
6590 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6591 ecode2 = SWIG_AsVal_int(obj1, &val2);
6592 if (!SWIG_IsOK(ecode2)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetHeight" "', expected argument " "2"" of type '" "int""'");
6594 }
6595 arg2 = static_cast< int >(val2);
6596 {
6597 (arg1)->SetHeight(arg2);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_Py_Void();
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_Bitmap_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6608 PyObject *resultobj = 0;
6609 wxBitmap *arg1 = (wxBitmap *) 0 ;
6610 int arg2 ;
6611 void *argp1 = 0 ;
6612 int res1 = 0 ;
6613 int val2 ;
6614 int ecode2 = 0 ;
6615 PyObject * obj0 = 0 ;
6616 PyObject * obj1 = 0 ;
6617 char * kwnames[] = {
6618 (char *) "self",(char *) "width", NULL
6619 };
6620
6621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6623 if (!SWIG_IsOK(res1)) {
6624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetWidth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6625 }
6626 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6627 ecode2 = SWIG_AsVal_int(obj1, &val2);
6628 if (!SWIG_IsOK(ecode2)) {
6629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetWidth" "', expected argument " "2"" of type '" "int""'");
6630 }
6631 arg2 = static_cast< int >(val2);
6632 {
6633 (arg1)->SetWidth(arg2);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 resultobj = SWIG_Py_Void();
6637 return resultobj;
6638 fail:
6639 return NULL;
6640 }
6641
6642
6643 SWIGINTERN PyObject *_wrap_Bitmap_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6644 PyObject *resultobj = 0;
6645 wxBitmap *arg1 = (wxBitmap *) 0 ;
6646 int arg2 ;
6647 void *argp1 = 0 ;
6648 int res1 = 0 ;
6649 int val2 ;
6650 int ecode2 = 0 ;
6651 PyObject * obj0 = 0 ;
6652 PyObject * obj1 = 0 ;
6653 char * kwnames[] = {
6654 (char *) "self",(char *) "depth", NULL
6655 };
6656
6657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
6658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6659 if (!SWIG_IsOK(res1)) {
6660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetDepth" "', expected argument " "1"" of type '" "wxBitmap *""'");
6661 }
6662 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6663 ecode2 = SWIG_AsVal_int(obj1, &val2);
6664 if (!SWIG_IsOK(ecode2)) {
6665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bitmap_SetDepth" "', expected argument " "2"" of type '" "int""'");
6666 }
6667 arg2 = static_cast< int >(val2);
6668 {
6669 (arg1)->SetDepth(arg2);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 resultobj = SWIG_Py_Void();
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 SWIGINTERN PyObject *_wrap_Bitmap_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj = 0;
6681 wxBitmap *arg1 = (wxBitmap *) 0 ;
6682 wxSize *arg2 = 0 ;
6683 void *argp1 = 0 ;
6684 int res1 = 0 ;
6685 wxSize temp2 ;
6686 PyObject * obj0 = 0 ;
6687 PyObject * obj1 = 0 ;
6688 char * kwnames[] = {
6689 (char *) "self",(char *) "size", NULL
6690 };
6691
6692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6694 if (!SWIG_IsOK(res1)) {
6695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_SetSize" "', expected argument " "1"" of type '" "wxBitmap *""'");
6696 }
6697 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6698 {
6699 arg2 = &temp2;
6700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6701 }
6702 {
6703 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_Py_Void();
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = 0;
6715 wxBitmap *arg1 = (wxBitmap *) 0 ;
6716 wxCursor *arg2 = 0 ;
6717 bool result;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 void *argp2 = 0 ;
6721 int res2 = 0 ;
6722 PyObject * obj0 = 0 ;
6723 PyObject * obj1 = 0 ;
6724 char * kwnames[] = {
6725 (char *) "self",(char *) "cursor", NULL
6726 };
6727
6728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) SWIG_fail;
6729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6730 if (!SWIG_IsOK(res1)) {
6731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap_CopyFromCursor" "', expected argument " "1"" of type '" "wxBitmap *""'");
6732 }
6733 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
6735 if (!SWIG_IsOK(res2)) {
6736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap_CopyFromCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
6737 }
6738 if (!argp2) {
6739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bitmap_CopyFromCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
6740 }
6741 arg2 = reinterpret_cast< wxCursor * >(argp2);
6742 {
6743 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 {
6747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6748 }
6749 return resultobj;
6750 fail:
6751 return NULL;
6752 }
6753
6754
6755 SWIGINTERN PyObject *_wrap_Bitmap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6756 PyObject *resultobj = 0;
6757 wxBitmap *arg1 = (wxBitmap *) 0 ;
6758 wxBitmap *arg2 = (wxBitmap *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 void *argp2 = 0 ;
6763 int res2 = 0 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char * kwnames[] = {
6767 (char *) "self",(char *) "other", NULL
6768 };
6769
6770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___eq__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6774 }
6775 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6777 if (!SWIG_IsOK(res2)) {
6778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___eq__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6779 }
6780 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6781 {
6782 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 {
6786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6787 }
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 SWIGINTERN PyObject *_wrap_Bitmap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj = 0;
6796 wxBitmap *arg1 = (wxBitmap *) 0 ;
6797 wxBitmap *arg2 = (wxBitmap *) 0 ;
6798 bool result;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 void *argp2 = 0 ;
6802 int res2 = 0 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 char * kwnames[] = {
6806 (char *) "self",(char *) "other", NULL
6807 };
6808
6809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmap, 0 | 0 );
6811 if (!SWIG_IsOK(res1)) {
6812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bitmap___ne__" "', expected argument " "1"" of type '" "wxBitmap *""'");
6813 }
6814 arg1 = reinterpret_cast< wxBitmap * >(argp1);
6815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBitmap, 0 | 0 );
6816 if (!SWIG_IsOK(res2)) {
6817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bitmap___ne__" "', expected argument " "2"" of type '" "wxBitmap const *""'");
6818 }
6819 arg2 = reinterpret_cast< wxBitmap * >(argp2);
6820 {
6821 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 {
6825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6826 }
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 SWIGINTERN PyObject *Bitmap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6834 PyObject *obj;
6835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6836 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmap, SWIG_NewClientData(obj));
6837 return SWIG_Py_Void();
6838 }
6839
6840 SWIGINTERN PyObject *Bitmap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 return SWIG_Python_InitShadowInstance(args);
6842 }
6843
6844 SWIGINTERN PyObject *_wrap__BitmapFromBufferAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6845 PyObject *resultobj = 0;
6846 int arg1 ;
6847 int arg2 ;
6848 buffer arg3 ;
6849 int arg4 ;
6850 buffer arg5 ;
6851 int arg6 ;
6852 wxBitmap *result = 0 ;
6853 int val1 ;
6854 int ecode1 = 0 ;
6855 int val2 ;
6856 int ecode2 = 0 ;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 PyObject * obj2 = 0 ;
6860 PyObject * obj3 = 0 ;
6861 char * kwnames[] = {
6862 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
6863 };
6864
6865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:_BitmapFromBufferAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6866 ecode1 = SWIG_AsVal_int(obj0, &val1);
6867 if (!SWIG_IsOK(ecode1)) {
6868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "1"" of type '" "int""'");
6869 }
6870 arg1 = static_cast< int >(val1);
6871 ecode2 = SWIG_AsVal_int(obj1, &val2);
6872 if (!SWIG_IsOK(ecode2)) {
6873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferAlpha" "', expected argument " "2"" of type '" "int""'");
6874 }
6875 arg2 = static_cast< int >(val2);
6876 {
6877 if (obj2 != Py_None) {
6878 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6879 }
6880 }
6881 {
6882 if (obj3 != Py_None) {
6883 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
6884 }
6885 }
6886 {
6887 result = (wxBitmap *)_BitmapFromBufferAlpha(arg1,arg2,arg3,arg4,arg5,arg6);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap__BitmapFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6898 PyObject *resultobj = 0;
6899 int arg1 ;
6900 int arg2 ;
6901 buffer arg3 ;
6902 int arg4 ;
6903 wxBitmap *result = 0 ;
6904 int val1 ;
6905 int ecode1 = 0 ;
6906 int val2 ;
6907 int ecode2 = 0 ;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 PyObject * obj2 = 0 ;
6911 char * kwnames[] = {
6912 (char *) "width",(char *) "height",(char *) "data", NULL
6913 };
6914
6915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBuffer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6916 ecode1 = SWIG_AsVal_int(obj0, &val1);
6917 if (!SWIG_IsOK(ecode1)) {
6918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBuffer" "', expected argument " "1"" of type '" "int""'");
6919 }
6920 arg1 = static_cast< int >(val1);
6921 ecode2 = SWIG_AsVal_int(obj1, &val2);
6922 if (!SWIG_IsOK(ecode2)) {
6923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBuffer" "', expected argument " "2"" of type '" "int""'");
6924 }
6925 arg2 = static_cast< int >(val2);
6926 {
6927 if (obj2 != Py_None) {
6928 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6929 }
6930 }
6931 {
6932 result = (wxBitmap *)_BitmapFromBuffer(arg1,arg2,arg3,arg4);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 SWIGINTERN PyObject *_wrap__BitmapFromBufferRGBA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6943 PyObject *resultobj = 0;
6944 int arg1 ;
6945 int arg2 ;
6946 buffer arg3 ;
6947 int arg4 ;
6948 wxBitmap *result = 0 ;
6949 int val1 ;
6950 int ecode1 = 0 ;
6951 int val2 ;
6952 int ecode2 = 0 ;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 PyObject * obj2 = 0 ;
6956 char * kwnames[] = {
6957 (char *) "width",(char *) "height",(char *) "data", NULL
6958 };
6959
6960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:_BitmapFromBufferRGBA",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6961 ecode1 = SWIG_AsVal_int(obj0, &val1);
6962 if (!SWIG_IsOK(ecode1)) {
6963 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "1"" of type '" "int""'");
6964 }
6965 arg1 = static_cast< int >(val1);
6966 ecode2 = SWIG_AsVal_int(obj1, &val2);
6967 if (!SWIG_IsOK(ecode2)) {
6968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_BitmapFromBufferRGBA" "', expected argument " "2"" of type '" "int""'");
6969 }
6970 arg2 = static_cast< int >(val2);
6971 {
6972 if (obj2 != Py_None) {
6973 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
6974 }
6975 }
6976 {
6977 result = (wxBitmap *)_BitmapFromBufferRGBA(arg1,arg2,arg3,arg4);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 SWIGINTERN PyObject *_wrap_PixelDataBase_GetOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6988 PyObject *resultobj = 0;
6989 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
6990 wxPoint result;
6991 void *argp1 = 0 ;
6992 int res1 = 0 ;
6993 PyObject *swig_obj[1] ;
6994
6995 if (!args) SWIG_fail;
6996 swig_obj[0] = args;
6997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetOrigin" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
7000 }
7001 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
7002 {
7003 result = ((wxPixelDataBase const *)arg1)->GetOrigin();
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_PixelDataBase_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7014 PyObject *resultobj = 0;
7015 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
7016 int result;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 PyObject *swig_obj[1] ;
7020
7021 if (!args) SWIG_fail;
7022 swig_obj[0] = args;
7023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
7024 if (!SWIG_IsOK(res1)) {
7025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetWidth" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
7026 }
7027 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
7028 {
7029 result = (int)((wxPixelDataBase const *)arg1)->GetWidth();
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_From_int(static_cast< int >(result));
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 SWIGINTERN PyObject *_wrap_PixelDataBase_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7040 PyObject *resultobj = 0;
7041 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
7042 int result;
7043 void *argp1 = 0 ;
7044 int res1 = 0 ;
7045 PyObject *swig_obj[1] ;
7046
7047 if (!args) SWIG_fail;
7048 swig_obj[0] = args;
7049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
7050 if (!SWIG_IsOK(res1)) {
7051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetHeight" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
7052 }
7053 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
7054 {
7055 result = (int)((wxPixelDataBase const *)arg1)->GetHeight();
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_From_int(static_cast< int >(result));
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_PixelDataBase_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7066 PyObject *resultobj = 0;
7067 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
7068 wxSize result;
7069 void *argp1 = 0 ;
7070 int res1 = 0 ;
7071 PyObject *swig_obj[1] ;
7072
7073 if (!args) SWIG_fail;
7074 swig_obj[0] = args;
7075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
7076 if (!SWIG_IsOK(res1)) {
7077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetSize" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
7078 }
7079 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
7080 {
7081 result = ((wxPixelDataBase const *)arg1)->GetSize();
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_PixelDataBase_GetRowStride(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7092 PyObject *resultobj = 0;
7093 wxPixelDataBase *arg1 = (wxPixelDataBase *) 0 ;
7094 int result;
7095 void *argp1 = 0 ;
7096 int res1 = 0 ;
7097 PyObject *swig_obj[1] ;
7098
7099 if (!args) SWIG_fail;
7100 swig_obj[0] = args;
7101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPixelDataBase, 0 | 0 );
7102 if (!SWIG_IsOK(res1)) {
7103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelDataBase_GetRowStride" "', expected argument " "1"" of type '" "wxPixelDataBase const *""'");
7104 }
7105 arg1 = reinterpret_cast< wxPixelDataBase * >(argp1);
7106 {
7107 result = (int)((wxPixelDataBase const *)arg1)->GetRowStride();
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 resultobj = SWIG_From_int(static_cast< int >(result));
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *PixelDataBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7118 PyObject *obj;
7119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7120 SWIG_TypeNewClientData(SWIGTYPE_p_wxPixelDataBase, SWIG_NewClientData(obj));
7121 return SWIG_Py_Void();
7122 }
7123
7124 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7125 PyObject *resultobj = 0;
7126 wxBitmap *arg1 = 0 ;
7127 wxNativePixelData *result = 0 ;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130
7131 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7133 if (!SWIG_IsOK(res1)) {
7134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7135 }
7136 if (!argp1) {
7137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7138 }
7139 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7140 {
7141 result = (wxNativePixelData *)new wxNativePixelData(*arg1);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7145 return resultobj;
7146 fail:
7147 return NULL;
7148 }
7149
7150
7151 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7152 PyObject *resultobj = 0;
7153 wxBitmap *arg1 = 0 ;
7154 wxRect *arg2 = 0 ;
7155 wxNativePixelData *result = 0 ;
7156 void *argp1 = 0 ;
7157 int res1 = 0 ;
7158 wxRect temp2 ;
7159
7160 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7162 if (!SWIG_IsOK(res1)) {
7163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7164 }
7165 if (!argp1) {
7166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7167 }
7168 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7169 {
7170 arg2 = &temp2;
7171 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
7172 }
7173 {
7174 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxRect const &)*arg2);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_new_NativePixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7185 PyObject *resultobj = 0;
7186 wxBitmap *arg1 = 0 ;
7187 wxPoint *arg2 = 0 ;
7188 wxSize *arg3 = 0 ;
7189 wxNativePixelData *result = 0 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 wxPoint temp2 ;
7193 wxSize temp3 ;
7194
7195 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7197 if (!SWIG_IsOK(res1)) {
7198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7199 }
7200 if (!argp1) {
7201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7202 }
7203 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7204 {
7205 arg2 = &temp2;
7206 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7207 }
7208 {
7209 arg3 = &temp3;
7210 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7211 }
7212 {
7213 result = (wxNativePixelData *)new wxNativePixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7214 if (PyErr_Occurred()) SWIG_fail;
7215 }
7216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_NEW | 0 );
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_new_NativePixelData(PyObject *self, PyObject *args) {
7224 int argc;
7225 PyObject *argv[4];
7226
7227 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData",0,3,argv))) SWIG_fail;
7228 --argc;
7229 if (argc == 1) {
7230 return _wrap_new_NativePixelData__SWIG_0(self, argc, argv);
7231 }
7232 if (argc == 2) {
7233 return _wrap_new_NativePixelData__SWIG_1(self, argc, argv);
7234 }
7235 if (argc == 3) {
7236 return _wrap_new_NativePixelData__SWIG_2(self, argc, argv);
7237 }
7238
7239 fail:
7240 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData'");
7241 return NULL;
7242 }
7243
7244
7245 SWIGINTERN PyObject *_wrap_delete_NativePixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7246 PyObject *resultobj = 0;
7247 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7248 void *argp1 = 0 ;
7249 int res1 = 0 ;
7250 PyObject *swig_obj[1] ;
7251
7252 if (!args) SWIG_fail;
7253 swig_obj[0] = args;
7254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, SWIG_POINTER_DISOWN | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7257 }
7258 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7259 {
7260 delete arg1;
7261
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = SWIG_Py_Void();
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 SWIGINTERN PyObject *_wrap_NativePixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7272 PyObject *resultobj = 0;
7273 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7274 wxNativePixelData_Accessor result;
7275 void *argp1 = 0 ;
7276 int res1 = 0 ;
7277 PyObject *swig_obj[1] ;
7278
7279 if (!args) SWIG_fail;
7280 swig_obj[0] = args;
7281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7282 if (!SWIG_IsOK(res1)) {
7283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_GetPixels" "', expected argument " "1"" of type '" "wxNativePixelData const *""'");
7284 }
7285 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7286 {
7287 result = ((wxNativePixelData const *)arg1)->GetPixels();
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 resultobj = SWIG_NewPointerObj((new wxNativePixelData_Accessor(static_cast< const wxNativePixelData_Accessor& >(result))), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_OWN | 0 );
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 SWIGINTERN PyObject *_wrap_NativePixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7298 PyObject *resultobj = 0;
7299 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 PyObject *swig_obj[1] ;
7303
7304 if (!args) SWIG_fail;
7305 swig_obj[0] = args;
7306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7307 if (!SWIG_IsOK(res1)) {
7308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_UseAlpha" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7309 }
7310 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7311 {
7312 (arg1)->UseAlpha();
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_Py_Void();
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 SWIGINTERN PyObject *_wrap_NativePixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7323 PyObject *resultobj = 0;
7324 wxNativePixelData *arg1 = (wxNativePixelData *) 0 ;
7325 bool result;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 PyObject *swig_obj[1] ;
7329
7330 if (!args) SWIG_fail;
7331 swig_obj[0] = args;
7332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData, 0 | 0 );
7333 if (!SWIG_IsOK(res1)) {
7334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData___nonzero__" "', expected argument " "1"" of type '" "wxNativePixelData *""'");
7335 }
7336 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7337 {
7338 result = (bool)wxNativePixelData___nonzero__(arg1);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 {
7342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7343 }
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *NativePixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *obj;
7352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7353 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData, SWIG_NewClientData(obj));
7354 return SWIG_Py_Void();
7355 }
7356
7357 SWIGINTERN PyObject *NativePixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7358 return SWIG_Python_InitShadowInstance(args);
7359 }
7360
7361 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7362 PyObject *resultobj = 0;
7363 wxNativePixelData *arg1 = 0 ;
7364 wxNativePixelData_Accessor *result = 0 ;
7365 void *argp1 = 0 ;
7366 int res1 = 0 ;
7367
7368 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxNativePixelData, 0 );
7370 if (!SWIG_IsOK(res1)) {
7371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7372 }
7373 if (!argp1) {
7374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData &""'");
7375 }
7376 arg1 = reinterpret_cast< wxNativePixelData * >(argp1);
7377 {
7378 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7389 PyObject *resultobj = 0;
7390 wxBitmap *arg1 = 0 ;
7391 wxNativePixelData *arg2 = 0 ;
7392 wxNativePixelData_Accessor *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 void *argp2 = 0 ;
7396 int res2 = 0 ;
7397
7398 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7400 if (!SWIG_IsOK(res1)) {
7401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7402 }
7403 if (!argp1) {
7404 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
7405 }
7406 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7407 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxNativePixelData, 0 );
7408 if (!SWIG_IsOK(res2)) {
7409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7410 }
7411 if (!argp2) {
7412 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NativePixelData_Accessor" "', expected argument " "2"" of type '" "wxNativePixelData &""'");
7413 }
7414 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7415 {
7416 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor(*arg1,*arg2);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
7427 PyObject *resultobj = 0;
7428 wxNativePixelData_Accessor *result = 0 ;
7429
7430 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
7431 {
7432 result = (wxNativePixelData_Accessor *)new wxNativePixelData_Accessor();
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_NEW | 0 );
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_new_NativePixelData_Accessor(PyObject *self, PyObject *args) {
7443 int argc;
7444 PyObject *argv[3];
7445
7446 if (!(argc = SWIG_Python_UnpackTuple(args,"new_NativePixelData_Accessor",0,2,argv))) SWIG_fail;
7447 --argc;
7448 if (argc == 0) {
7449 return _wrap_new_NativePixelData_Accessor__SWIG_2(self, argc, argv);
7450 }
7451 if (argc == 1) {
7452 return _wrap_new_NativePixelData_Accessor__SWIG_0(self, argc, argv);
7453 }
7454 if (argc == 2) {
7455 return _wrap_new_NativePixelData_Accessor__SWIG_1(self, argc, argv);
7456 }
7457
7458 fail:
7459 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_NativePixelData_Accessor'");
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_delete_NativePixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 PyObject *swig_obj[1] ;
7470
7471 if (!args) SWIG_fail;
7472 swig_obj[0] = args;
7473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
7474 if (!SWIG_IsOK(res1)) {
7475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativePixelData_Accessor" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7476 }
7477 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7478 {
7479 delete arg1;
7480
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 resultobj = SWIG_Py_Void();
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj = 0;
7492 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7493 wxNativePixelData *arg2 = 0 ;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 void *argp2 = 0 ;
7497 int res2 = 0 ;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char * kwnames[] = {
7501 (char *) "self",(char *) "data", NULL
7502 };
7503
7504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativePixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
7505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7508 }
7509 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7511 if (!SWIG_IsOK(res2)) {
7512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7513 }
7514 if (!argp2) {
7515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7516 }
7517 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7518 {
7519 (arg1)->Reset((wxNativePixelData const &)*arg2);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 resultobj = SWIG_Py_Void();
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7530 PyObject *resultobj = 0;
7531 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7532 bool result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 PyObject *swig_obj[1] ;
7536
7537 if (!args) SWIG_fail;
7538 swig_obj[0] = args;
7539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7540 if (!SWIG_IsOK(res1)) {
7541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor const *""'");
7542 }
7543 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7544 {
7545 result = (bool)((wxNativePixelData_Accessor const *)arg1)->IsOk();
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 {
7549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7550 }
7551 return resultobj;
7552 fail:
7553 return NULL;
7554 }
7555
7556
7557 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7558 PyObject *resultobj = 0;
7559 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 PyObject *swig_obj[1] ;
7563
7564 if (!args) SWIG_fail;
7565 swig_obj[0] = args;
7566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7569 }
7570 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7571 {
7572 wxNativePixelData_Accessor_nextPixel(arg1);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 resultobj = SWIG_Py_Void();
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7585 wxNativePixelData *arg2 = 0 ;
7586 int arg3 ;
7587 int arg4 ;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 void *argp2 = 0 ;
7591 int res2 = 0 ;
7592 int val3 ;
7593 int ecode3 = 0 ;
7594 int val4 ;
7595 int ecode4 = 0 ;
7596 PyObject * obj0 = 0 ;
7597 PyObject * obj1 = 0 ;
7598 PyObject * obj2 = 0 ;
7599 PyObject * obj3 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7608 }
7609 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7611 if (!SWIG_IsOK(res2)) {
7612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7613 }
7614 if (!argp2) {
7615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7616 }
7617 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7618 ecode3 = SWIG_AsVal_int(obj2, &val3);
7619 if (!SWIG_IsOK(ecode3)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
7621 }
7622 arg3 = static_cast< int >(val3);
7623 ecode4 = SWIG_AsVal_int(obj3, &val4);
7624 if (!SWIG_IsOK(ecode4)) {
7625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
7626 }
7627 arg4 = static_cast< int >(val4);
7628 {
7629 (arg1)->Offset((wxNativePixelData const &)*arg2,arg3,arg4);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 resultobj = SWIG_Py_Void();
7633 return resultobj;
7634 fail:
7635 return NULL;
7636 }
7637
7638
7639 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj = 0;
7641 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7642 wxNativePixelData *arg2 = 0 ;
7643 int arg3 ;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 void *argp2 = 0 ;
7647 int res2 = 0 ;
7648 int val3 ;
7649 int ecode3 = 0 ;
7650 PyObject * obj0 = 0 ;
7651 PyObject * obj1 = 0 ;
7652 PyObject * obj2 = 0 ;
7653 char * kwnames[] = {
7654 (char *) "self",(char *) "data",(char *) "x", NULL
7655 };
7656
7657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7659 if (!SWIG_IsOK(res1)) {
7660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7661 }
7662 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7663 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7664 if (!SWIG_IsOK(res2)) {
7665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7666 }
7667 if (!argp2) {
7668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7669 }
7670 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7671 ecode3 = SWIG_AsVal_int(obj2, &val3);
7672 if (!SWIG_IsOK(ecode3)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
7674 }
7675 arg3 = static_cast< int >(val3);
7676 {
7677 (arg1)->OffsetX((wxNativePixelData const &)*arg2,arg3);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 resultobj = SWIG_Py_Void();
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj = 0;
7689 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7690 wxNativePixelData *arg2 = 0 ;
7691 int arg3 ;
7692 void *argp1 = 0 ;
7693 int res1 = 0 ;
7694 void *argp2 = 0 ;
7695 int res2 = 0 ;
7696 int val3 ;
7697 int ecode3 = 0 ;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 PyObject * obj2 = 0 ;
7701 char * kwnames[] = {
7702 (char *) "self",(char *) "data",(char *) "y", NULL
7703 };
7704
7705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:NativePixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7707 if (!SWIG_IsOK(res1)) {
7708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7709 }
7710 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7711 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7712 if (!SWIG_IsOK(res2)) {
7713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7714 }
7715 if (!argp2) {
7716 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7717 }
7718 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7719 ecode3 = SWIG_AsVal_int(obj2, &val3);
7720 if (!SWIG_IsOK(ecode3)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
7722 }
7723 arg3 = static_cast< int >(val3);
7724 {
7725 (arg1)->OffsetY((wxNativePixelData const &)*arg2,arg3);
7726 if (PyErr_Occurred()) SWIG_fail;
7727 }
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7736 PyObject *resultobj = 0;
7737 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7738 wxNativePixelData *arg2 = 0 ;
7739 int arg3 ;
7740 int arg4 ;
7741 void *argp1 = 0 ;
7742 int res1 = 0 ;
7743 void *argp2 = 0 ;
7744 int res2 = 0 ;
7745 int val3 ;
7746 int ecode3 = 0 ;
7747 int val4 ;
7748 int ecode4 = 0 ;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 PyObject * obj2 = 0 ;
7752 PyObject * obj3 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7761 }
7762 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativePixelData, 0 | 0);
7764 if (!SWIG_IsOK(res2)) {
7765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7766 }
7767 if (!argp2) {
7768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxNativePixelData const &""'");
7769 }
7770 arg2 = reinterpret_cast< wxNativePixelData * >(argp2);
7771 ecode3 = SWIG_AsVal_int(obj2, &val3);
7772 if (!SWIG_IsOK(ecode3)) {
7773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
7774 }
7775 arg3 = static_cast< int >(val3);
7776 ecode4 = SWIG_AsVal_int(obj3, &val4);
7777 if (!SWIG_IsOK(ecode4)) {
7778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
7779 }
7780 arg4 = static_cast< int >(val4);
7781 {
7782 (arg1)->MoveTo((wxNativePixelData const &)*arg2,arg3,arg4);
7783 if (PyErr_Occurred()) SWIG_fail;
7784 }
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj = 0;
7794 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7795 byte arg2 ;
7796 byte arg3 ;
7797 byte arg4 ;
7798 void *argp1 = 0 ;
7799 int res1 = 0 ;
7800 unsigned char val2 ;
7801 int ecode2 = 0 ;
7802 unsigned char val3 ;
7803 int ecode3 = 0 ;
7804 unsigned char val4 ;
7805 int ecode4 = 0 ;
7806 PyObject * obj0 = 0 ;
7807 PyObject * obj1 = 0 ;
7808 PyObject * obj2 = 0 ;
7809 PyObject * obj3 = 0 ;
7810 char * kwnames[] = {
7811 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
7812 };
7813
7814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:NativePixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7816 if (!SWIG_IsOK(res1)) {
7817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7818 }
7819 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7820 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
7821 if (!SWIG_IsOK(ecode2)) {
7822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
7823 }
7824 arg2 = static_cast< byte >(val2);
7825 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7826 if (!SWIG_IsOK(ecode3)) {
7827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
7828 }
7829 arg3 = static_cast< byte >(val3);
7830 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
7831 if (!SWIG_IsOK(ecode4)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NativePixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
7833 }
7834 arg4 = static_cast< byte >(val4);
7835 {
7836 wxNativePixelData_Accessor_Set(arg1,arg2,arg3,arg4);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 resultobj = SWIG_Py_Void();
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_NativePixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7847 PyObject *resultobj = 0;
7848 wxNativePixelData_Accessor *arg1 = (wxNativePixelData_Accessor *) 0 ;
7849 PyObject *result = 0 ;
7850 void *argp1 = 0 ;
7851 int res1 = 0 ;
7852 PyObject *swig_obj[1] ;
7853
7854 if (!args) SWIG_fail;
7855 swig_obj[0] = args;
7856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativePixelData_Accessor, 0 | 0 );
7857 if (!SWIG_IsOK(res1)) {
7858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativePixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxNativePixelData_Accessor *""'");
7859 }
7860 arg1 = reinterpret_cast< wxNativePixelData_Accessor * >(argp1);
7861 {
7862 result = (PyObject *)wxNativePixelData_Accessor_Get(arg1);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = result;
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *NativePixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7873 PyObject *obj;
7874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7875 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativePixelData_Accessor, SWIG_NewClientData(obj));
7876 return SWIG_Py_Void();
7877 }
7878
7879 SWIGINTERN PyObject *NativePixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7880 return SWIG_Python_InitShadowInstance(args);
7881 }
7882
7883 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7884 PyObject *resultobj = 0;
7885 wxBitmap *arg1 = 0 ;
7886 wxAlphaPixelData *result = 0 ;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889
7890 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7892 if (!SWIG_IsOK(res1)) {
7893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7894 }
7895 if (!argp1) {
7896 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7897 }
7898 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7899 {
7900 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7911 PyObject *resultobj = 0;
7912 wxBitmap *arg1 = 0 ;
7913 wxRect *arg2 = 0 ;
7914 wxAlphaPixelData *result = 0 ;
7915 void *argp1 = 0 ;
7916 int res1 = 0 ;
7917 wxRect temp2 ;
7918
7919 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7921 if (!SWIG_IsOK(res1)) {
7922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7923 }
7924 if (!argp1) {
7925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7926 }
7927 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7928 {
7929 arg2 = &temp2;
7930 if ( ! wxRect_helper(swig_obj[1], &arg2)) SWIG_fail;
7931 }
7932 {
7933 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxRect const &)*arg2);
7934 if (PyErr_Occurred()) SWIG_fail;
7935 }
7936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *_wrap_new_AlphaPixelData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7944 PyObject *resultobj = 0;
7945 wxBitmap *arg1 = 0 ;
7946 wxPoint *arg2 = 0 ;
7947 wxSize *arg3 = 0 ;
7948 wxAlphaPixelData *result = 0 ;
7949 void *argp1 = 0 ;
7950 int res1 = 0 ;
7951 wxPoint temp2 ;
7952 wxSize temp3 ;
7953
7954 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
7955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7958 }
7959 if (!argp1) {
7960 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData" "', expected argument " "1"" of type '" "wxBitmap &""'");
7961 }
7962 arg1 = reinterpret_cast< wxBitmap * >(argp1);
7963 {
7964 arg2 = &temp2;
7965 if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;
7966 }
7967 {
7968 arg3 = &temp3;
7969 if ( ! wxSize_helper(swig_obj[2], &arg3)) SWIG_fail;
7970 }
7971 {
7972 result = (wxAlphaPixelData *)new wxAlphaPixelData(*arg1,(wxPoint const &)*arg2,(wxSize const &)*arg3);
7973 if (PyErr_Occurred()) SWIG_fail;
7974 }
7975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_NEW | 0 );
7976 return resultobj;
7977 fail:
7978 return NULL;
7979 }
7980
7981
7982 SWIGINTERN PyObject *_wrap_new_AlphaPixelData(PyObject *self, PyObject *args) {
7983 int argc;
7984 PyObject *argv[4];
7985
7986 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData",0,3,argv))) SWIG_fail;
7987 --argc;
7988 if (argc == 1) {
7989 return _wrap_new_AlphaPixelData__SWIG_0(self, argc, argv);
7990 }
7991 if (argc == 2) {
7992 return _wrap_new_AlphaPixelData__SWIG_1(self, argc, argv);
7993 }
7994 if (argc == 3) {
7995 return _wrap_new_AlphaPixelData__SWIG_2(self, argc, argv);
7996 }
7997
7998 fail:
7999 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData'");
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *resultobj = 0;
8006 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
8007 void *argp1 = 0 ;
8008 int res1 = 0 ;
8009 PyObject *swig_obj[1] ;
8010
8011 if (!args) SWIG_fail;
8012 swig_obj[0] = args;
8013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, SWIG_POINTER_DISOWN | 0 );
8014 if (!SWIG_IsOK(res1)) {
8015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
8016 }
8017 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
8018 {
8019 delete arg1;
8020
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 resultobj = SWIG_Py_Void();
8024 return resultobj;
8025 fail:
8026 return NULL;
8027 }
8028
8029
8030 SWIGINTERN PyObject *_wrap_AlphaPixelData_GetPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8031 PyObject *resultobj = 0;
8032 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
8033 wxAlphaPixelData_Accessor result;
8034 void *argp1 = 0 ;
8035 int res1 = 0 ;
8036 PyObject *swig_obj[1] ;
8037
8038 if (!args) SWIG_fail;
8039 swig_obj[0] = args;
8040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
8041 if (!SWIG_IsOK(res1)) {
8042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_GetPixels" "', expected argument " "1"" of type '" "wxAlphaPixelData const *""'");
8043 }
8044 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
8045 {
8046 result = ((wxAlphaPixelData const *)arg1)->GetPixels();
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_NewPointerObj((new wxAlphaPixelData_Accessor(static_cast< const wxAlphaPixelData_Accessor& >(result))), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_OWN | 0 );
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *_wrap_AlphaPixelData_UseAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8057 PyObject *resultobj = 0;
8058 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
8059 void *argp1 = 0 ;
8060 int res1 = 0 ;
8061 PyObject *swig_obj[1] ;
8062
8063 if (!args) SWIG_fail;
8064 swig_obj[0] = args;
8065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
8066 if (!SWIG_IsOK(res1)) {
8067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_UseAlpha" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
8068 }
8069 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
8070 {
8071 (arg1)->UseAlpha();
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_AlphaPixelData___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083 wxAlphaPixelData *arg1 = (wxAlphaPixelData *) 0 ;
8084 bool result;
8085 void *argp1 = 0 ;
8086 int res1 = 0 ;
8087 PyObject *swig_obj[1] ;
8088
8089 if (!args) SWIG_fail;
8090 swig_obj[0] = args;
8091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData___nonzero__" "', expected argument " "1"" of type '" "wxAlphaPixelData *""'");
8094 }
8095 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
8096 {
8097 result = (bool)wxAlphaPixelData___nonzero__(arg1);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 {
8101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 SWIGINTERN PyObject *AlphaPixelData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8110 PyObject *obj;
8111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8112 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData, SWIG_NewClientData(obj));
8113 return SWIG_Py_Void();
8114 }
8115
8116 SWIGINTERN PyObject *AlphaPixelData_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8117 return SWIG_Python_InitShadowInstance(args);
8118 }
8119
8120 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8121 PyObject *resultobj = 0;
8122 wxAlphaPixelData *arg1 = 0 ;
8123 wxAlphaPixelData_Accessor *result = 0 ;
8124 void *argp1 = 0 ;
8125 int res1 = 0 ;
8126
8127 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
8128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxAlphaPixelData, 0 );
8129 if (!SWIG_IsOK(res1)) {
8130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
8131 }
8132 if (!argp1) {
8133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData &""'");
8134 }
8135 arg1 = reinterpret_cast< wxAlphaPixelData * >(argp1);
8136 {
8137 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8148 PyObject *resultobj = 0;
8149 wxBitmap *arg1 = 0 ;
8150 wxAlphaPixelData *arg2 = 0 ;
8151 wxAlphaPixelData_Accessor *result = 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 void *argp2 = 0 ;
8155 int res2 = 0 ;
8156
8157 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxBitmap, 0 );
8159 if (!SWIG_IsOK(res1)) {
8160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
8161 }
8162 if (!argp1) {
8163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxBitmap &""'");
8164 }
8165 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8166 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 );
8167 if (!SWIG_IsOK(res2)) {
8168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
8169 }
8170 if (!argp2) {
8171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlphaPixelData_Accessor" "', expected argument " "2"" of type '" "wxAlphaPixelData &""'");
8172 }
8173 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8174 {
8175 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor(*arg1,*arg2);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
8186 PyObject *resultobj = 0;
8187 wxAlphaPixelData_Accessor *result = 0 ;
8188
8189 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
8190 {
8191 result = (wxAlphaPixelData_Accessor *)new wxAlphaPixelData_Accessor();
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_NEW | 0 );
8195 return resultobj;
8196 fail:
8197 return NULL;
8198 }
8199
8200
8201 SWIGINTERN PyObject *_wrap_new_AlphaPixelData_Accessor(PyObject *self, PyObject *args) {
8202 int argc;
8203 PyObject *argv[3];
8204
8205 if (!(argc = SWIG_Python_UnpackTuple(args,"new_AlphaPixelData_Accessor",0,2,argv))) SWIG_fail;
8206 --argc;
8207 if (argc == 0) {
8208 return _wrap_new_AlphaPixelData_Accessor__SWIG_2(self, argc, argv);
8209 }
8210 if (argc == 1) {
8211 return _wrap_new_AlphaPixelData_Accessor__SWIG_0(self, argc, argv);
8212 }
8213 if (argc == 2) {
8214 return _wrap_new_AlphaPixelData_Accessor__SWIG_1(self, argc, argv);
8215 }
8216
8217 fail:
8218 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_AlphaPixelData_Accessor'");
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_delete_AlphaPixelData_Accessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224 PyObject *resultobj = 0;
8225 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 PyObject *swig_obj[1] ;
8229
8230 if (!args) SWIG_fail;
8231 swig_obj[0] = args;
8232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_POINTER_DISOWN | 0 );
8233 if (!SWIG_IsOK(res1)) {
8234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaPixelData_Accessor" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8235 }
8236 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8237 {
8238 delete arg1;
8239
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 resultobj = SWIG_Py_Void();
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj = 0;
8251 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8252 wxAlphaPixelData *arg2 = 0 ;
8253 void *argp1 = 0 ;
8254 int res1 = 0 ;
8255 void *argp2 = 0 ;
8256 int res2 = 0 ;
8257 PyObject * obj0 = 0 ;
8258 PyObject * obj1 = 0 ;
8259 char * kwnames[] = {
8260 (char *) "self",(char *) "data", NULL
8261 };
8262
8263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AlphaPixelData_Accessor_Reset",kwnames,&obj0,&obj1)) SWIG_fail;
8264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8265 if (!SWIG_IsOK(res1)) {
8266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8267 }
8268 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8269 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8270 if (!SWIG_IsOK(res2)) {
8271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8272 }
8273 if (!argp2) {
8274 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Reset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8275 }
8276 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8277 {
8278 (arg1)->Reset((wxAlphaPixelData const &)*arg2);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8289 PyObject *resultobj = 0;
8290 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8291 bool result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 PyObject *swig_obj[1] ;
8295
8296 if (!args) SWIG_fail;
8297 swig_obj[0] = args;
8298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_IsOk" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor const *""'");
8301 }
8302 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8303 {
8304 result = (bool)((wxAlphaPixelData_Accessor const *)arg1)->IsOk();
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 {
8308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8309 }
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_nextPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 PyObject *resultobj = 0;
8318 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 PyObject *swig_obj[1] ;
8322
8323 if (!args) SWIG_fail;
8324 swig_obj[0] = args;
8325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_nextPixel" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8328 }
8329 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8330 {
8331 wxAlphaPixelData_Accessor_nextPixel(arg1);
8332 if (PyErr_Occurred()) SWIG_fail;
8333 }
8334 resultobj = SWIG_Py_Void();
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8342 PyObject *resultobj = 0;
8343 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8344 wxAlphaPixelData *arg2 = 0 ;
8345 int arg3 ;
8346 int arg4 ;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 void *argp2 = 0 ;
8350 int res2 = 0 ;
8351 int val3 ;
8352 int ecode3 = 0 ;
8353 int val4 ;
8354 int ecode4 = 0 ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 PyObject * obj3 = 0 ;
8359 char * kwnames[] = {
8360 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8361 };
8362
8363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_Offset",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8365 if (!SWIG_IsOK(res1)) {
8366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8367 }
8368 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8370 if (!SWIG_IsOK(res2)) {
8371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8372 }
8373 if (!argp2) {
8374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8375 }
8376 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8377 ecode3 = SWIG_AsVal_int(obj2, &val3);
8378 if (!SWIG_IsOK(ecode3)) {
8379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "3"" of type '" "int""'");
8380 }
8381 arg3 = static_cast< int >(val3);
8382 ecode4 = SWIG_AsVal_int(obj3, &val4);
8383 if (!SWIG_IsOK(ecode4)) {
8384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Offset" "', expected argument " "4"" of type '" "int""'");
8385 }
8386 arg4 = static_cast< int >(val4);
8387 {
8388 (arg1)->Offset((wxAlphaPixelData const &)*arg2,arg3,arg4);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8401 wxAlphaPixelData *arg2 = 0 ;
8402 int arg3 ;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 void *argp2 = 0 ;
8406 int res2 = 0 ;
8407 int val3 ;
8408 int ecode3 = 0 ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 PyObject * obj2 = 0 ;
8412 char * kwnames[] = {
8413 (char *) "self",(char *) "data",(char *) "x", NULL
8414 };
8415
8416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetX",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8418 if (!SWIG_IsOK(res1)) {
8419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8420 }
8421 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8423 if (!SWIG_IsOK(res2)) {
8424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8425 }
8426 if (!argp2) {
8427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8428 }
8429 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8430 ecode3 = SWIG_AsVal_int(obj2, &val3);
8431 if (!SWIG_IsOK(ecode3)) {
8432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetX" "', expected argument " "3"" of type '" "int""'");
8433 }
8434 arg3 = static_cast< int >(val3);
8435 {
8436 (arg1)->OffsetX((wxAlphaPixelData const &)*arg2,arg3);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 resultobj = SWIG_Py_Void();
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_OffsetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8447 PyObject *resultobj = 0;
8448 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8449 wxAlphaPixelData *arg2 = 0 ;
8450 int arg3 ;
8451 void *argp1 = 0 ;
8452 int res1 = 0 ;
8453 void *argp2 = 0 ;
8454 int res2 = 0 ;
8455 int val3 ;
8456 int ecode3 = 0 ;
8457 PyObject * obj0 = 0 ;
8458 PyObject * obj1 = 0 ;
8459 PyObject * obj2 = 0 ;
8460 char * kwnames[] = {
8461 (char *) "self",(char *) "data",(char *) "y", NULL
8462 };
8463
8464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:AlphaPixelData_Accessor_OffsetY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8468 }
8469 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8470 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8471 if (!SWIG_IsOK(res2)) {
8472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8473 }
8474 if (!argp2) {
8475 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8476 }
8477 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8478 ecode3 = SWIG_AsVal_int(obj2, &val3);
8479 if (!SWIG_IsOK(ecode3)) {
8480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_OffsetY" "', expected argument " "3"" of type '" "int""'");
8481 }
8482 arg3 = static_cast< int >(val3);
8483 {
8484 (arg1)->OffsetY((wxAlphaPixelData const &)*arg2,arg3);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_Py_Void();
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_MoveTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = 0;
8496 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8497 wxAlphaPixelData *arg2 = 0 ;
8498 int arg3 ;
8499 int arg4 ;
8500 void *argp1 = 0 ;
8501 int res1 = 0 ;
8502 void *argp2 = 0 ;
8503 int res2 = 0 ;
8504 int val3 ;
8505 int ecode3 = 0 ;
8506 int val4 ;
8507 int ecode4 = 0 ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 PyObject * obj2 = 0 ;
8511 PyObject * obj3 = 0 ;
8512 char * kwnames[] = {
8513 (char *) "self",(char *) "data",(char *) "x",(char *) "y", NULL
8514 };
8515
8516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AlphaPixelData_Accessor_MoveTo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8518 if (!SWIG_IsOK(res1)) {
8519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8520 }
8521 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAlphaPixelData, 0 | 0);
8523 if (!SWIG_IsOK(res2)) {
8524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8525 }
8526 if (!argp2) {
8527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "2"" of type '" "wxAlphaPixelData const &""'");
8528 }
8529 arg2 = reinterpret_cast< wxAlphaPixelData * >(argp2);
8530 ecode3 = SWIG_AsVal_int(obj2, &val3);
8531 if (!SWIG_IsOK(ecode3)) {
8532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "3"" of type '" "int""'");
8533 }
8534 arg3 = static_cast< int >(val3);
8535 ecode4 = SWIG_AsVal_int(obj3, &val4);
8536 if (!SWIG_IsOK(ecode4)) {
8537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_MoveTo" "', expected argument " "4"" of type '" "int""'");
8538 }
8539 arg4 = static_cast< int >(val4);
8540 {
8541 (arg1)->MoveTo((wxAlphaPixelData const &)*arg2,arg3,arg4);
8542 if (PyErr_Occurred()) SWIG_fail;
8543 }
8544 resultobj = SWIG_Py_Void();
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj = 0;
8553 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8554 byte arg2 ;
8555 byte arg3 ;
8556 byte arg4 ;
8557 byte arg5 ;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 unsigned char val2 ;
8561 int ecode2 = 0 ;
8562 unsigned char val3 ;
8563 int ecode3 = 0 ;
8564 unsigned char val4 ;
8565 int ecode4 = 0 ;
8566 unsigned char val5 ;
8567 int ecode5 = 0 ;
8568 PyObject * obj0 = 0 ;
8569 PyObject * obj1 = 0 ;
8570 PyObject * obj2 = 0 ;
8571 PyObject * obj3 = 0 ;
8572 PyObject * obj4 = 0 ;
8573 char * kwnames[] = {
8574 (char *) "self",(char *) "red",(char *) "green",(char *) "blue",(char *) "alpha", NULL
8575 };
8576
8577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:AlphaPixelData_Accessor_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8579 if (!SWIG_IsOK(res1)) {
8580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8581 }
8582 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8583 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8584 if (!SWIG_IsOK(ecode2)) {
8585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "2"" of type '" "byte""'");
8586 }
8587 arg2 = static_cast< byte >(val2);
8588 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
8589 if (!SWIG_IsOK(ecode3)) {
8590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "3"" of type '" "byte""'");
8591 }
8592 arg3 = static_cast< byte >(val3);
8593 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
8594 if (!SWIG_IsOK(ecode4)) {
8595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "4"" of type '" "byte""'");
8596 }
8597 arg4 = static_cast< byte >(val4);
8598 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
8599 if (!SWIG_IsOK(ecode5)) {
8600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AlphaPixelData_Accessor_Set" "', expected argument " "5"" of type '" "byte""'");
8601 }
8602 arg5 = static_cast< byte >(val5);
8603 {
8604 wxAlphaPixelData_Accessor_Set(arg1,arg2,arg3,arg4,arg5);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_Py_Void();
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_AlphaPixelData_Accessor_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8615 PyObject *resultobj = 0;
8616 wxAlphaPixelData_Accessor *arg1 = (wxAlphaPixelData_Accessor *) 0 ;
8617 PyObject *result = 0 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 PyObject *swig_obj[1] ;
8621
8622 if (!args) SWIG_fail;
8623 swig_obj[0] = args;
8624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAlphaPixelData_Accessor, 0 | 0 );
8625 if (!SWIG_IsOK(res1)) {
8626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaPixelData_Accessor_Get" "', expected argument " "1"" of type '" "wxAlphaPixelData_Accessor *""'");
8627 }
8628 arg1 = reinterpret_cast< wxAlphaPixelData_Accessor * >(argp1);
8629 {
8630 result = (PyObject *)wxAlphaPixelData_Accessor_Get(arg1);
8631 if (PyErr_Occurred()) SWIG_fail;
8632 }
8633 resultobj = result;
8634 return resultobj;
8635 fail:
8636 return NULL;
8637 }
8638
8639
8640 SWIGINTERN PyObject *AlphaPixelData_Accessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8641 PyObject *obj;
8642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8643 SWIG_TypeNewClientData(SWIGTYPE_p_wxAlphaPixelData_Accessor, SWIG_NewClientData(obj));
8644 return SWIG_Py_Void();
8645 }
8646
8647 SWIGINTERN PyObject *AlphaPixelData_Accessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8648 return SWIG_Python_InitShadowInstance(args);
8649 }
8650
8651 SWIGINTERN PyObject *_wrap_new_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = 0;
8653 wxBitmap *arg1 = 0 ;
8654 wxColour const &arg2_defvalue = wxNullColour ;
8655 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
8656 wxMask *result = 0 ;
8657 void *argp1 = 0 ;
8658 int res1 = 0 ;
8659 wxColour temp2 ;
8660 PyObject * obj0 = 0 ;
8661 PyObject * obj1 = 0 ;
8662 char * kwnames[] = {
8663 (char *) "bitmap",(char *) "colour", NULL
8664 };
8665
8666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) SWIG_fail;
8667 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8668 if (!SWIG_IsOK(res1)) {
8669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8670 }
8671 if (!argp1) {
8672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mask" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8673 }
8674 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8675 if (obj1) {
8676 {
8677 arg2 = &temp2;
8678 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
8679 }
8680 }
8681 {
8682 if (!wxPyCheckForApp()) SWIG_fail;
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
8685 wxPyEndAllowThreads(__tstate);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMask, SWIG_POINTER_NEW | 0 );
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_delete_Mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696 PyObject *resultobj = 0;
8697 wxMask *arg1 = (wxMask *) 0 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 PyObject *swig_obj[1] ;
8701
8702 if (!args) SWIG_fail;
8703 swig_obj[0] = args;
8704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMask, SWIG_POINTER_DISOWN | 0 );
8705 if (!SWIG_IsOK(res1)) {
8706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mask" "', expected argument " "1"" of type '" "wxMask *""'");
8707 }
8708 arg1 = reinterpret_cast< wxMask * >(argp1);
8709 {
8710 delete arg1;
8711
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_Py_Void();
8715 return resultobj;
8716 fail:
8717 return NULL;
8718 }
8719
8720
8721 SWIGINTERN PyObject *Mask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8722 PyObject *obj;
8723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8724 SWIG_TypeNewClientData(SWIGTYPE_p_wxMask, SWIG_NewClientData(obj));
8725 return SWIG_Py_Void();
8726 }
8727
8728 SWIGINTERN PyObject *Mask_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8729 return SWIG_Python_InitShadowInstance(args);
8730 }
8731
8732 SWIGINTERN PyObject *_wrap_new_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = 0;
8734 wxString *arg1 = 0 ;
8735 wxBitmapType arg2 ;
8736 int arg3 = (int) -1 ;
8737 int arg4 = (int) -1 ;
8738 wxIcon *result = 0 ;
8739 bool temp1 = false ;
8740 int val2 ;
8741 int ecode2 = 0 ;
8742 int val3 ;
8743 int ecode3 = 0 ;
8744 int val4 ;
8745 int ecode4 = 0 ;
8746 PyObject * obj0 = 0 ;
8747 PyObject * obj1 = 0 ;
8748 PyObject * obj2 = 0 ;
8749 PyObject * obj3 = 0 ;
8750 char * kwnames[] = {
8751 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
8752 };
8753
8754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8755 {
8756 arg1 = wxString_in_helper(obj0);
8757 if (arg1 == NULL) SWIG_fail;
8758 temp1 = true;
8759 }
8760 ecode2 = SWIG_AsVal_int(obj1, &val2);
8761 if (!SWIG_IsOK(ecode2)) {
8762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Icon" "', expected argument " "2"" of type '" "wxBitmapType""'");
8763 }
8764 arg2 = static_cast< wxBitmapType >(val2);
8765 if (obj2) {
8766 ecode3 = SWIG_AsVal_int(obj2, &val3);
8767 if (!SWIG_IsOK(ecode3)) {
8768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Icon" "', expected argument " "3"" of type '" "int""'");
8769 }
8770 arg3 = static_cast< int >(val3);
8771 }
8772 if (obj3) {
8773 ecode4 = SWIG_AsVal_int(obj3, &val4);
8774 if (!SWIG_IsOK(ecode4)) {
8775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Icon" "', expected argument " "4"" of type '" "int""'");
8776 }
8777 arg4 = static_cast< int >(val4);
8778 }
8779 {
8780 if (!wxPyCheckForApp()) SWIG_fail;
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 result = (wxIcon *)new wxIcon((wxString const &)*arg1,arg2,arg3,arg4);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_NEW | 0 );
8787 {
8788 if (temp1)
8789 delete arg1;
8790 }
8791 return resultobj;
8792 fail:
8793 {
8794 if (temp1)
8795 delete arg1;
8796 }
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_delete_Icon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *resultobj = 0;
8803 wxIcon *arg1 = (wxIcon *) 0 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 PyObject *swig_obj[1] ;
8807
8808 if (!args) SWIG_fail;
8809 swig_obj[0] = args;
8810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, SWIG_POINTER_DISOWN | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Icon" "', expected argument " "1"" of type '" "wxIcon *""'");
8813 }
8814 arg1 = reinterpret_cast< wxIcon * >(argp1);
8815 {
8816 PyThreadState* __tstate = wxPyBeginAllowThreads();
8817 delete arg1;
8818
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_new_EmptyIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8830 PyObject *resultobj = 0;
8831 wxIcon *result = 0 ;
8832
8833 if (!SWIG_Python_UnpackTuple(args,"new_EmptyIcon",0,0,0)) SWIG_fail;
8834 {
8835 if (!wxPyCheckForApp()) SWIG_fail;
8836 PyThreadState* __tstate = wxPyBeginAllowThreads();
8837 result = (wxIcon *)new wxIcon();
8838 wxPyEndAllowThreads(__tstate);
8839 if (PyErr_Occurred()) SWIG_fail;
8840 }
8841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 SWIGINTERN PyObject *_wrap_new_IconFromLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj = 0;
8850 wxIconLocation *arg1 = 0 ;
8851 wxIcon *result = 0 ;
8852 void *argp1 = 0 ;
8853 int res1 = 0 ;
8854 PyObject * obj0 = 0 ;
8855 char * kwnames[] = {
8856 (char *) "loc", NULL
8857 };
8858
8859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) SWIG_fail;
8860 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIconLocation, 0 | 0);
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8863 }
8864 if (!argp1) {
8865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromLocation" "', expected argument " "1"" of type '" "wxIconLocation const &""'");
8866 }
8867 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
8868 {
8869 if (!wxPyCheckForApp()) SWIG_fail;
8870 PyThreadState* __tstate = wxPyBeginAllowThreads();
8871 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
8872 wxPyEndAllowThreads(__tstate);
8873 if (PyErr_Occurred()) SWIG_fail;
8874 }
8875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_new_IconFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj = 0;
8884 wxBitmap *arg1 = 0 ;
8885 wxIcon *result = 0 ;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject * obj0 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "bmp", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) SWIG_fail;
8894 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8897 }
8898 if (!argp1) {
8899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
8900 }
8901 arg1 = reinterpret_cast< wxBitmap * >(argp1);
8902 {
8903 if (!wxPyCheckForApp()) SWIG_fail;
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_new_IconFromXPMData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj = 0;
8918 PyObject *arg1 = (PyObject *) 0 ;
8919 wxIcon *result = 0 ;
8920 PyObject * obj0 = 0 ;
8921 char * kwnames[] = {
8922 (char *) "listOfStrings", NULL
8923 };
8924
8925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) SWIG_fail;
8926 arg1 = obj0;
8927 {
8928 if (!wxPyCheckForApp()) SWIG_fail;
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 result = (wxIcon *)new_wxIcon(arg1);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_Icon_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8942 PyObject *resultobj = 0;
8943 wxIcon *arg1 = (wxIcon *) 0 ;
8944 wxString *arg2 = 0 ;
8945 wxBitmapType arg3 ;
8946 bool result;
8947 void *argp1 = 0 ;
8948 int res1 = 0 ;
8949 bool temp2 = false ;
8950 int val3 ;
8951 int ecode3 = 0 ;
8952 PyObject * obj0 = 0 ;
8953 PyObject * obj1 = 0 ;
8954 PyObject * obj2 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "self",(char *) "name",(char *) "type", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_LoadFile" "', expected argument " "1"" of type '" "wxIcon *""'");
8963 }
8964 arg1 = reinterpret_cast< wxIcon * >(argp1);
8965 {
8966 arg2 = wxString_in_helper(obj1);
8967 if (arg2 == NULL) SWIG_fail;
8968 temp2 = true;
8969 }
8970 ecode3 = SWIG_AsVal_int(obj2, &val3);
8971 if (!SWIG_IsOK(ecode3)) {
8972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Icon_LoadFile" "', expected argument " "3"" of type '" "wxBitmapType""'");
8973 }
8974 arg3 = static_cast< wxBitmapType >(val3);
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 {
8982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8983 }
8984 {
8985 if (temp2)
8986 delete arg2;
8987 }
8988 return resultobj;
8989 fail:
8990 {
8991 if (temp2)
8992 delete arg2;
8993 }
8994 return NULL;
8995 }
8996
8997
8998 SWIGINTERN PyObject *_wrap_Icon_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8999 PyObject *resultobj = 0;
9000 wxIcon *arg1 = (wxIcon *) 0 ;
9001 long result;
9002 void *argp1 = 0 ;
9003 int res1 = 0 ;
9004 PyObject *swig_obj[1] ;
9005
9006 if (!args) SWIG_fail;
9007 swig_obj[0] = args;
9008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9009 if (!SWIG_IsOK(res1)) {
9010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHandle" "', expected argument " "1"" of type '" "wxIcon *""'");
9011 }
9012 arg1 = reinterpret_cast< wxIcon * >(argp1);
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 result = (long)(arg1)->GetHandle();
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 resultobj = SWIG_From_long(static_cast< long >(result));
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *_wrap_Icon_SetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj = 0;
9028 wxIcon *arg1 = (wxIcon *) 0 ;
9029 long arg2 ;
9030 void *argp1 = 0 ;
9031 int res1 = 0 ;
9032 long val2 ;
9033 int ecode2 = 0 ;
9034 PyObject * obj0 = 0 ;
9035 PyObject * obj1 = 0 ;
9036 char * kwnames[] = {
9037 (char *) "self",(char *) "handle", NULL
9038 };
9039
9040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) SWIG_fail;
9041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHandle" "', expected argument " "1"" of type '" "wxIcon *""'");
9044 }
9045 arg1 = reinterpret_cast< wxIcon * >(argp1);
9046 ecode2 = SWIG_AsVal_long(obj1, &val2);
9047 if (!SWIG_IsOK(ecode2)) {
9048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHandle" "', expected argument " "2"" of type '" "long""'");
9049 }
9050 arg2 = static_cast< long >(val2);
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 wxIcon_SetHandle(arg1,arg2);
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 resultobj = SWIG_Py_Void();
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 SWIGINTERN PyObject *_wrap_Icon_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 PyObject *resultobj = 0;
9066 wxIcon *arg1 = (wxIcon *) 0 ;
9067 bool result;
9068 void *argp1 = 0 ;
9069 int res1 = 0 ;
9070 PyObject *swig_obj[1] ;
9071
9072 if (!args) SWIG_fail;
9073 swig_obj[0] = args;
9074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_Ok" "', expected argument " "1"" of type '" "wxIcon *""'");
9077 }
9078 arg1 = reinterpret_cast< wxIcon * >(argp1);
9079 {
9080 PyThreadState* __tstate = wxPyBeginAllowThreads();
9081 result = (bool)(arg1)->Ok();
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9087 }
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_Icon_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxIcon *arg1 = (wxIcon *) 0 ;
9097 int result;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
9107 }
9108 arg1 = reinterpret_cast< wxIcon * >(argp1);
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 result = (int)(arg1)->GetWidth();
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 resultobj = SWIG_From_int(static_cast< int >(result));
9116 return resultobj;
9117 fail:
9118 return NULL;
9119 }
9120
9121
9122 SWIGINTERN PyObject *_wrap_Icon_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9123 PyObject *resultobj = 0;
9124 wxIcon *arg1 = (wxIcon *) 0 ;
9125 int result;
9126 void *argp1 = 0 ;
9127 int res1 = 0 ;
9128 PyObject *swig_obj[1] ;
9129
9130 if (!args) SWIG_fail;
9131 swig_obj[0] = args;
9132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9133 if (!SWIG_IsOK(res1)) {
9134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
9135 }
9136 arg1 = reinterpret_cast< wxIcon * >(argp1);
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (int)(arg1)->GetHeight();
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_From_int(static_cast< int >(result));
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_Icon_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxIcon *arg1 = (wxIcon *) 0 ;
9153 int result;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 PyObject *swig_obj[1] ;
9157
9158 if (!args) SWIG_fail;
9159 swig_obj[0] = args;
9160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_GetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
9163 }
9164 arg1 = reinterpret_cast< wxIcon * >(argp1);
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (int)(arg1)->GetDepth();
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_From_int(static_cast< int >(result));
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *_wrap_Icon_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9179 PyObject *resultobj = 0;
9180 wxIcon *arg1 = (wxIcon *) 0 ;
9181 int arg2 ;
9182 void *argp1 = 0 ;
9183 int res1 = 0 ;
9184 int val2 ;
9185 int ecode2 = 0 ;
9186 PyObject * obj0 = 0 ;
9187 PyObject * obj1 = 0 ;
9188 char * kwnames[] = {
9189 (char *) "self",(char *) "w", NULL
9190 };
9191
9192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
9193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9194 if (!SWIG_IsOK(res1)) {
9195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetWidth" "', expected argument " "1"" of type '" "wxIcon *""'");
9196 }
9197 arg1 = reinterpret_cast< wxIcon * >(argp1);
9198 ecode2 = SWIG_AsVal_int(obj1, &val2);
9199 if (!SWIG_IsOK(ecode2)) {
9200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetWidth" "', expected argument " "2"" of type '" "int""'");
9201 }
9202 arg2 = static_cast< int >(val2);
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 (arg1)->SetWidth(arg2);
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_Py_Void();
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_Icon_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9217 PyObject *resultobj = 0;
9218 wxIcon *arg1 = (wxIcon *) 0 ;
9219 int arg2 ;
9220 void *argp1 = 0 ;
9221 int res1 = 0 ;
9222 int val2 ;
9223 int ecode2 = 0 ;
9224 PyObject * obj0 = 0 ;
9225 PyObject * obj1 = 0 ;
9226 char * kwnames[] = {
9227 (char *) "self",(char *) "h", NULL
9228 };
9229
9230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
9231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9232 if (!SWIG_IsOK(res1)) {
9233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetHeight" "', expected argument " "1"" of type '" "wxIcon *""'");
9234 }
9235 arg1 = reinterpret_cast< wxIcon * >(argp1);
9236 ecode2 = SWIG_AsVal_int(obj1, &val2);
9237 if (!SWIG_IsOK(ecode2)) {
9238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetHeight" "', expected argument " "2"" of type '" "int""'");
9239 }
9240 arg2 = static_cast< int >(val2);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 (arg1)->SetHeight(arg2);
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_Py_Void();
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_Icon_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9255 PyObject *resultobj = 0;
9256 wxIcon *arg1 = (wxIcon *) 0 ;
9257 int arg2 ;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 int val2 ;
9261 int ecode2 = 0 ;
9262 PyObject * obj0 = 0 ;
9263 PyObject * obj1 = 0 ;
9264 char * kwnames[] = {
9265 (char *) "self",(char *) "d", NULL
9266 };
9267
9268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
9269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9270 if (!SWIG_IsOK(res1)) {
9271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetDepth" "', expected argument " "1"" of type '" "wxIcon *""'");
9272 }
9273 arg1 = reinterpret_cast< wxIcon * >(argp1);
9274 ecode2 = SWIG_AsVal_int(obj1, &val2);
9275 if (!SWIG_IsOK(ecode2)) {
9276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Icon_SetDepth" "', expected argument " "2"" of type '" "int""'");
9277 }
9278 arg2 = static_cast< int >(val2);
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 (arg1)->SetDepth(arg2);
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 resultobj = SWIG_Py_Void();
9286 return resultobj;
9287 fail:
9288 return NULL;
9289 }
9290
9291
9292 SWIGINTERN PyObject *_wrap_Icon_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj = 0;
9294 wxIcon *arg1 = (wxIcon *) 0 ;
9295 wxSize *arg2 = 0 ;
9296 void *argp1 = 0 ;
9297 int res1 = 0 ;
9298 wxSize temp2 ;
9299 PyObject * obj0 = 0 ;
9300 PyObject * obj1 = 0 ;
9301 char * kwnames[] = {
9302 (char *) "self",(char *) "size", NULL
9303 };
9304
9305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
9306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_SetSize" "', expected argument " "1"" of type '" "wxIcon *""'");
9309 }
9310 arg1 = reinterpret_cast< wxIcon * >(argp1);
9311 {
9312 arg2 = &temp2;
9313 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9314 }
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 (arg1)->SetSize((wxSize const &)*arg2);
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_Py_Void();
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_Icon_CopyFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9329 PyObject *resultobj = 0;
9330 wxIcon *arg1 = (wxIcon *) 0 ;
9331 wxBitmap *arg2 = 0 ;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 void *argp2 = 0 ;
9335 int res2 = 0 ;
9336 PyObject * obj0 = 0 ;
9337 PyObject * obj1 = 0 ;
9338 char * kwnames[] = {
9339 (char *) "self",(char *) "bmp", NULL
9340 };
9341
9342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
9343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIcon, 0 | 0 );
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Icon_CopyFromBitmap" "', expected argument " "1"" of type '" "wxIcon *""'");
9346 }
9347 arg1 = reinterpret_cast< wxIcon * >(argp1);
9348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
9349 if (!SWIG_IsOK(res2)) {
9350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9351 }
9352 if (!argp2) {
9353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Icon_CopyFromBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
9354 }
9355 arg2 = reinterpret_cast< wxBitmap * >(argp2);
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_Py_Void();
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *Icon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *obj;
9371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9372 SWIG_TypeNewClientData(SWIGTYPE_p_wxIcon, SWIG_NewClientData(obj));
9373 return SWIG_Py_Void();
9374 }
9375
9376 SWIGINTERN PyObject *Icon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9377 return SWIG_Python_InitShadowInstance(args);
9378 }
9379
9380 SWIGINTERN PyObject *_wrap_new_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9381 PyObject *resultobj = 0;
9382 wxString *arg1 = (wxString *) &wxPyEmptyString ;
9383 int arg2 = (int) 0 ;
9384 wxIconLocation *result = 0 ;
9385 bool temp1 = false ;
9386 int val2 ;
9387 int ecode2 = 0 ;
9388 PyObject * obj0 = 0 ;
9389 PyObject * obj1 = 0 ;
9390 char * kwnames[] = {
9391 (char *) "filename",(char *) "num", NULL
9392 };
9393
9394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) SWIG_fail;
9395 if (obj0) {
9396 {
9397 arg1 = wxString_in_helper(obj0);
9398 if (arg1 == NULL) SWIG_fail;
9399 temp1 = true;
9400 }
9401 }
9402 if (obj1) {
9403 ecode2 = SWIG_AsVal_int(obj1, &val2);
9404 if (!SWIG_IsOK(ecode2)) {
9405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconLocation" "', expected argument " "2"" of type '" "int""'");
9406 }
9407 arg2 = static_cast< int >(val2);
9408 }
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconLocation, SWIG_POINTER_NEW | 0 );
9416 {
9417 if (temp1)
9418 delete arg1;
9419 }
9420 return resultobj;
9421 fail:
9422 {
9423 if (temp1)
9424 delete arg1;
9425 }
9426 return NULL;
9427 }
9428
9429
9430 SWIGINTERN PyObject *_wrap_delete_IconLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9431 PyObject *resultobj = 0;
9432 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 PyObject *swig_obj[1] ;
9436
9437 if (!args) SWIG_fail;
9438 swig_obj[0] = args;
9439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, SWIG_POINTER_DISOWN | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconLocation" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9442 }
9443 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 delete arg1;
9447
9448 wxPyEndAllowThreads(__tstate);
9449 if (PyErr_Occurred()) SWIG_fail;
9450 }
9451 resultobj = SWIG_Py_Void();
9452 return resultobj;
9453 fail:
9454 return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_IconLocation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459 PyObject *resultobj = 0;
9460 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9461 bool result;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 PyObject *swig_obj[1] ;
9465
9466 if (!args) SWIG_fail;
9467 swig_obj[0] = args;
9468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_IsOk" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9471 }
9472 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (bool)((wxIconLocation const *)arg1)->IsOk();
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_IconLocation_SetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9491 wxString *arg2 = 0 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 bool temp2 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 char * kwnames[] = {
9498 (char *) "self",(char *) "filename", NULL
9499 };
9500
9501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) SWIG_fail;
9502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9503 if (!SWIG_IsOK(res1)) {
9504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetFileName" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9505 }
9506 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9507 {
9508 arg2 = wxString_in_helper(obj1);
9509 if (arg2 == NULL) SWIG_fail;
9510 temp2 = true;
9511 }
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 (arg1)->SetFileName((wxString const &)*arg2);
9515 wxPyEndAllowThreads(__tstate);
9516 if (PyErr_Occurred()) SWIG_fail;
9517 }
9518 resultobj = SWIG_Py_Void();
9519 {
9520 if (temp2)
9521 delete arg2;
9522 }
9523 return resultobj;
9524 fail:
9525 {
9526 if (temp2)
9527 delete arg2;
9528 }
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_IconLocation_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 PyObject *resultobj = 0;
9535 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9536 wxString *result = 0 ;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 PyObject *swig_obj[1] ;
9540
9541 if (!args) SWIG_fail;
9542 swig_obj[0] = args;
9543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9544 if (!SWIG_IsOK(res1)) {
9545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetFileName" "', expected argument " "1"" of type '" "wxIconLocation const *""'");
9546 }
9547 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 {
9551 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
9552 result = (wxString *) &_result_ref;
9553 }
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 {
9558 #if wxUSE_UNICODE
9559 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9560 #else
9561 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9562 #endif
9563 }
9564 return resultobj;
9565 fail:
9566 return NULL;
9567 }
9568
9569
9570 SWIGINTERN PyObject *_wrap_IconLocation_SetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9571 PyObject *resultobj = 0;
9572 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9573 int arg2 ;
9574 void *argp1 = 0 ;
9575 int res1 = 0 ;
9576 int val2 ;
9577 int ecode2 = 0 ;
9578 PyObject * obj0 = 0 ;
9579 PyObject * obj1 = 0 ;
9580 char * kwnames[] = {
9581 (char *) "self",(char *) "num", NULL
9582 };
9583
9584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) SWIG_fail;
9585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9586 if (!SWIG_IsOK(res1)) {
9587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_SetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9588 }
9589 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9590 ecode2 = SWIG_AsVal_int(obj1, &val2);
9591 if (!SWIG_IsOK(ecode2)) {
9592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IconLocation_SetIndex" "', expected argument " "2"" of type '" "int""'");
9593 }
9594 arg2 = static_cast< int >(val2);
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 wxIconLocation_SetIndex(arg1,arg2);
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_Py_Void();
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *_wrap_IconLocation_GetIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *resultobj = 0;
9610 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
9611 int result;
9612 void *argp1 = 0 ;
9613 int res1 = 0 ;
9614 PyObject *swig_obj[1] ;
9615
9616 if (!args) SWIG_fail;
9617 swig_obj[0] = args;
9618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconLocation, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconLocation_GetIndex" "', expected argument " "1"" of type '" "wxIconLocation *""'");
9621 }
9622 arg1 = reinterpret_cast< wxIconLocation * >(argp1);
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (int)wxIconLocation_GetIndex(arg1);
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 resultobj = SWIG_From_int(static_cast< int >(result));
9630 return resultobj;
9631 fail:
9632 return NULL;
9633 }
9634
9635
9636 SWIGINTERN PyObject *IconLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9637 PyObject *obj;
9638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9639 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconLocation, SWIG_NewClientData(obj));
9640 return SWIG_Py_Void();
9641 }
9642
9643 SWIGINTERN PyObject *IconLocation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9644 return SWIG_Python_InitShadowInstance(args);
9645 }
9646
9647 SWIGINTERN PyObject *_wrap_new_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9648 PyObject *resultobj = 0;
9649 wxIconBundle *result = 0 ;
9650
9651 if (!SWIG_Python_UnpackTuple(args,"new_IconBundle",0,0,0)) SWIG_fail;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 result = (wxIconBundle *)new wxIconBundle();
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_NEW | 0 );
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_new_IconBundleFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj = 0;
9667 wxString *arg1 = 0 ;
9668 long arg2 ;
9669 wxIconBundle *result = 0 ;
9670 bool temp1 = false ;
9671 long val2 ;
9672 int ecode2 = 0 ;
9673 PyObject * obj0 = 0 ;
9674 PyObject * obj1 = 0 ;
9675 char * kwnames[] = {
9676 (char *) "file",(char *) "type", NULL
9677 };
9678
9679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) SWIG_fail;
9680 {
9681 arg1 = wxString_in_helper(obj0);
9682 if (arg1 == NULL) SWIG_fail;
9683 temp1 = true;
9684 }
9685 ecode2 = SWIG_AsVal_long(obj1, &val2);
9686 if (!SWIG_IsOK(ecode2)) {
9687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconBundleFromFile" "', expected argument " "2"" of type '" "long""'");
9688 }
9689 arg2 = static_cast< long >(val2);
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9697 {
9698 if (temp1)
9699 delete arg1;
9700 }
9701 return resultobj;
9702 fail:
9703 {
9704 if (temp1)
9705 delete arg1;
9706 }
9707 return NULL;
9708 }
9709
9710
9711 SWIGINTERN PyObject *_wrap_new_IconBundleFromIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj = 0;
9713 wxIcon *arg1 = 0 ;
9714 wxIconBundle *result = 0 ;
9715 void *argp1 = 0 ;
9716 int res1 = 0 ;
9717 PyObject * obj0 = 0 ;
9718 char * kwnames[] = {
9719 (char *) "icon", NULL
9720 };
9721
9722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) SWIG_fail;
9723 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxIcon, 0 | 0);
9724 if (!SWIG_IsOK(res1)) {
9725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9726 }
9727 if (!argp1) {
9728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IconBundleFromIcon" "', expected argument " "1"" of type '" "wxIcon const &""'");
9729 }
9730 arg1 = reinterpret_cast< wxIcon * >(argp1);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_delete_IconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconBundle, SWIG_POINTER_DISOWN | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IconBundle" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9756 }
9757 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 delete arg1;
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_IconBundle_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9775 wxIcon *arg2 = 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 void *argp2 = 0 ;
9779 int res2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "icon", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIcon" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9790 }
9791 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
9793 if (!SWIG_IsOK(res2)) {
9794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9795 }
9796 if (!argp2) {
9797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IconBundle_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
9798 }
9799 arg2 = reinterpret_cast< wxIcon * >(argp2);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 (arg1)->AddIcon((wxIcon const &)*arg2);
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 resultobj = SWIG_Py_Void();
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 SWIGINTERN PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj = 0;
9815 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9816 wxString *arg2 = 0 ;
9817 long arg3 ;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 bool temp2 = false ;
9821 long val3 ;
9822 int ecode3 = 0 ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 PyObject * obj2 = 0 ;
9826 char * kwnames[] = {
9827 (char *) "self",(char *) "file",(char *) "type", NULL
9828 };
9829
9830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9832 if (!SWIG_IsOK(res1)) {
9833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "1"" of type '" "wxIconBundle *""'");
9834 }
9835 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9836 {
9837 arg2 = wxString_in_helper(obj1);
9838 if (arg2 == NULL) SWIG_fail;
9839 temp2 = true;
9840 }
9841 ecode3 = SWIG_AsVal_long(obj2, &val3);
9842 if (!SWIG_IsOK(ecode3)) {
9843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IconBundle_AddIconFromFile" "', expected argument " "3"" of type '" "long""'");
9844 }
9845 arg3 = static_cast< long >(val3);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 (arg1)->AddIcon((wxString const &)*arg2,arg3);
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 resultobj = SWIG_Py_Void();
9853 {
9854 if (temp2)
9855 delete arg2;
9856 }
9857 return resultobj;
9858 fail:
9859 {
9860 if (temp2)
9861 delete arg2;
9862 }
9863 return NULL;
9864 }
9865
9866
9867 SWIGINTERN PyObject *_wrap_IconBundle_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9868 PyObject *resultobj = 0;
9869 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
9870 wxSize *arg2 = 0 ;
9871 wxIcon *result = 0 ;
9872 void *argp1 = 0 ;
9873 int res1 = 0 ;
9874 wxSize temp2 ;
9875 PyObject * obj0 = 0 ;
9876 PyObject * obj1 = 0 ;
9877 char * kwnames[] = {
9878 (char *) "self",(char *) "size", NULL
9879 };
9880
9881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
9882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIconBundle, 0 | 0 );
9883 if (!SWIG_IsOK(res1)) {
9884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconBundle_GetIcon" "', expected argument " "1"" of type '" "wxIconBundle const *""'");
9885 }
9886 arg1 = reinterpret_cast< wxIconBundle * >(argp1);
9887 {
9888 arg2 = &temp2;
9889 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
9890 }
9891 {
9892 PyThreadState* __tstate = wxPyBeginAllowThreads();
9893 {
9894 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
9895 result = (wxIcon *) &_result_ref;
9896 }
9897 wxPyEndAllowThreads(__tstate);
9898 if (PyErr_Occurred()) SWIG_fail;
9899 }
9900 {
9901 wxIcon* resultptr = new wxIcon(*result);
9902 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
9903 }
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 SWIGINTERN PyObject *IconBundle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9911 PyObject *obj;
9912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9913 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconBundle, SWIG_NewClientData(obj));
9914 return SWIG_Py_Void();
9915 }
9916
9917 SWIGINTERN PyObject *IconBundle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 return SWIG_Python_InitShadowInstance(args);
9919 }
9920
9921 SWIGINTERN PyObject *_wrap_new_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9922 PyObject *resultobj = 0;
9923 wxString *arg1 = 0 ;
9924 long arg2 ;
9925 int arg3 = (int) 0 ;
9926 int arg4 = (int) 0 ;
9927 wxCursor *result = 0 ;
9928 bool temp1 = false ;
9929 long val2 ;
9930 int ecode2 = 0 ;
9931 int val3 ;
9932 int ecode3 = 0 ;
9933 int val4 ;
9934 int ecode4 = 0 ;
9935 PyObject * obj0 = 0 ;
9936 PyObject * obj1 = 0 ;
9937 PyObject * obj2 = 0 ;
9938 PyObject * obj3 = 0 ;
9939 char * kwnames[] = {
9940 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
9941 };
9942
9943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9944 {
9945 arg1 = wxString_in_helper(obj0);
9946 if (arg1 == NULL) SWIG_fail;
9947 temp1 = true;
9948 }
9949 ecode2 = SWIG_AsVal_long(obj1, &val2);
9950 if (!SWIG_IsOK(ecode2)) {
9951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Cursor" "', expected argument " "2"" of type '" "long""'");
9952 }
9953 arg2 = static_cast< long >(val2);
9954 if (obj2) {
9955 ecode3 = SWIG_AsVal_int(obj2, &val3);
9956 if (!SWIG_IsOK(ecode3)) {
9957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Cursor" "', expected argument " "3"" of type '" "int""'");
9958 }
9959 arg3 = static_cast< int >(val3);
9960 }
9961 if (obj3) {
9962 ecode4 = SWIG_AsVal_int(obj3, &val4);
9963 if (!SWIG_IsOK(ecode4)) {
9964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Cursor" "', expected argument " "4"" of type '" "int""'");
9965 }
9966 arg4 = static_cast< int >(val4);
9967 }
9968 {
9969 if (!wxPyCheckForApp()) SWIG_fail;
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_NEW | 0 );
9976 {
9977 if (temp1)
9978 delete arg1;
9979 }
9980 return resultobj;
9981 fail:
9982 {
9983 if (temp1)
9984 delete arg1;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 SWIGINTERN PyObject *_wrap_delete_Cursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9991 PyObject *resultobj = 0;
9992 wxCursor *arg1 = (wxCursor *) 0 ;
9993 void *argp1 = 0 ;
9994 int res1 = 0 ;
9995 PyObject *swig_obj[1] ;
9996
9997 if (!args) SWIG_fail;
9998 swig_obj[0] = args;
9999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, SWIG_POINTER_DISOWN | 0 );
10000 if (!SWIG_IsOK(res1)) {
10001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cursor" "', expected argument " "1"" of type '" "wxCursor *""'");
10002 }
10003 arg1 = reinterpret_cast< wxCursor * >(argp1);
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 delete arg1;
10007
10008 wxPyEndAllowThreads(__tstate);
10009 if (PyErr_Occurred()) SWIG_fail;
10010 }
10011 resultobj = SWIG_Py_Void();
10012 return resultobj;
10013 fail:
10014 return NULL;
10015 }
10016
10017
10018 SWIGINTERN PyObject *_wrap_new_StockCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10019 PyObject *resultobj = 0;
10020 int arg1 ;
10021 wxCursor *result = 0 ;
10022 int val1 ;
10023 int ecode1 = 0 ;
10024 PyObject * obj0 = 0 ;
10025 char * kwnames[] = {
10026 (char *) "id", NULL
10027 };
10028
10029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) SWIG_fail;
10030 ecode1 = SWIG_AsVal_int(obj0, &val1);
10031 if (!SWIG_IsOK(ecode1)) {
10032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StockCursor" "', expected argument " "1"" of type '" "int""'");
10033 }
10034 arg1 = static_cast< int >(val1);
10035 {
10036 if (!wxPyCheckForApp()) SWIG_fail;
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 result = (wxCursor *)new wxCursor(arg1);
10039 wxPyEndAllowThreads(__tstate);
10040 if (PyErr_Occurred()) SWIG_fail;
10041 }
10042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
10043 return resultobj;
10044 fail:
10045 return NULL;
10046 }
10047
10048
10049 SWIGINTERN PyObject *_wrap_new_CursorFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj = 0;
10051 wxImage *arg1 = 0 ;
10052 wxCursor *result = 0 ;
10053 void *argp1 = 0 ;
10054 int res1 = 0 ;
10055 PyObject * obj0 = 0 ;
10056 char * kwnames[] = {
10057 (char *) "image", NULL
10058 };
10059
10060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) SWIG_fail;
10061 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
10062 if (!SWIG_IsOK(res1)) {
10063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
10064 }
10065 if (!argp1) {
10066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CursorFromImage" "', expected argument " "1"" of type '" "wxImage const &""'");
10067 }
10068 arg1 = reinterpret_cast< wxImage * >(argp1);
10069 {
10070 if (!wxPyCheckForApp()) SWIG_fail;
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
10077 return resultobj;
10078 fail:
10079 return NULL;
10080 }
10081
10082
10083 SWIGINTERN PyObject *_wrap_Cursor_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10084 PyObject *resultobj = 0;
10085 wxCursor *arg1 = (wxCursor *) 0 ;
10086 long result;
10087 void *argp1 = 0 ;
10088 int res1 = 0 ;
10089 PyObject *swig_obj[1] ;
10090
10091 if (!args) SWIG_fail;
10092 swig_obj[0] = args;
10093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10094 if (!SWIG_IsOK(res1)) {
10095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_GetHandle" "', expected argument " "1"" of type '" "wxCursor *""'");
10096 }
10097 arg1 = reinterpret_cast< wxCursor * >(argp1);
10098 {
10099 PyThreadState* __tstate = wxPyBeginAllowThreads();
10100 result = (long)(arg1)->GetHandle();
10101 wxPyEndAllowThreads(__tstate);
10102 if (PyErr_Occurred()) SWIG_fail;
10103 }
10104 resultobj = SWIG_From_long(static_cast< long >(result));
10105 return resultobj;
10106 fail:
10107 return NULL;
10108 }
10109
10110
10111 SWIGINTERN PyObject *_wrap_Cursor_SetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10112 PyObject *resultobj = 0;
10113 wxCursor *arg1 = (wxCursor *) 0 ;
10114 long arg2 ;
10115 void *argp1 = 0 ;
10116 int res1 = 0 ;
10117 long val2 ;
10118 int ecode2 = 0 ;
10119 PyObject * obj0 = 0 ;
10120 PyObject * obj1 = 0 ;
10121 char * kwnames[] = {
10122 (char *) "self",(char *) "handle", NULL
10123 };
10124
10125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) SWIG_fail;
10126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10127 if (!SWIG_IsOK(res1)) {
10128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_SetHandle" "', expected argument " "1"" of type '" "wxCursor *""'");
10129 }
10130 arg1 = reinterpret_cast< wxCursor * >(argp1);
10131 ecode2 = SWIG_AsVal_long(obj1, &val2);
10132 if (!SWIG_IsOK(ecode2)) {
10133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cursor_SetHandle" "', expected argument " "2"" of type '" "long""'");
10134 }
10135 arg2 = static_cast< long >(val2);
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 wxCursor_SetHandle(arg1,arg2);
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 resultobj = SWIG_Py_Void();
10143 return resultobj;
10144 fail:
10145 return NULL;
10146 }
10147
10148
10149 SWIGINTERN PyObject *_wrap_Cursor_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10150 PyObject *resultobj = 0;
10151 wxCursor *arg1 = (wxCursor *) 0 ;
10152 bool result;
10153 void *argp1 = 0 ;
10154 int res1 = 0 ;
10155 PyObject *swig_obj[1] ;
10156
10157 if (!args) SWIG_fail;
10158 swig_obj[0] = args;
10159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10160 if (!SWIG_IsOK(res1)) {
10161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_Ok" "', expected argument " "1"" of type '" "wxCursor *""'");
10162 }
10163 arg1 = reinterpret_cast< wxCursor * >(argp1);
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 result = (bool)(arg1)->Ok();
10167 wxPyEndAllowThreads(__tstate);
10168 if (PyErr_Occurred()) SWIG_fail;
10169 }
10170 {
10171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10172 }
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 SWIGINTERN PyObject *_wrap_Cursor_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10180 PyObject *resultobj = 0;
10181 wxCursor *arg1 = (wxCursor *) 0 ;
10182 int result;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 PyObject *swig_obj[1] ;
10186
10187 if (!args) SWIG_fail;
10188 swig_obj[0] = args;
10189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10190 if (!SWIG_IsOK(res1)) {
10191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_GetWidth" "', expected argument " "1"" of type '" "wxCursor *""'");
10192 }
10193 arg1 = reinterpret_cast< wxCursor * >(argp1);
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 result = (int)(arg1)->GetWidth();
10197 wxPyEndAllowThreads(__tstate);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 resultobj = SWIG_From_int(static_cast< int >(result));
10201 return resultobj;
10202 fail:
10203 return NULL;
10204 }
10205
10206
10207 SWIGINTERN PyObject *_wrap_Cursor_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10208 PyObject *resultobj = 0;
10209 wxCursor *arg1 = (wxCursor *) 0 ;
10210 int result;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 PyObject *swig_obj[1] ;
10214
10215 if (!args) SWIG_fail;
10216 swig_obj[0] = args;
10217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_GetHeight" "', expected argument " "1"" of type '" "wxCursor *""'");
10220 }
10221 arg1 = reinterpret_cast< wxCursor * >(argp1);
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (int)(arg1)->GetHeight();
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 resultobj = SWIG_From_int(static_cast< int >(result));
10229 return resultobj;
10230 fail:
10231 return NULL;
10232 }
10233
10234
10235 SWIGINTERN PyObject *_wrap_Cursor_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10236 PyObject *resultobj = 0;
10237 wxCursor *arg1 = (wxCursor *) 0 ;
10238 int result;
10239 void *argp1 = 0 ;
10240 int res1 = 0 ;
10241 PyObject *swig_obj[1] ;
10242
10243 if (!args) SWIG_fail;
10244 swig_obj[0] = args;
10245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_GetDepth" "', expected argument " "1"" of type '" "wxCursor *""'");
10248 }
10249 arg1 = reinterpret_cast< wxCursor * >(argp1);
10250 {
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 result = (int)(arg1)->GetDepth();
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 resultobj = SWIG_From_int(static_cast< int >(result));
10257 return resultobj;
10258 fail:
10259 return NULL;
10260 }
10261
10262
10263 SWIGINTERN PyObject *_wrap_Cursor_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10264 PyObject *resultobj = 0;
10265 wxCursor *arg1 = (wxCursor *) 0 ;
10266 int arg2 ;
10267 void *argp1 = 0 ;
10268 int res1 = 0 ;
10269 int val2 ;
10270 int ecode2 = 0 ;
10271 PyObject * obj0 = 0 ;
10272 PyObject * obj1 = 0 ;
10273 char * kwnames[] = {
10274 (char *) "self",(char *) "w", NULL
10275 };
10276
10277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
10278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10279 if (!SWIG_IsOK(res1)) {
10280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_SetWidth" "', expected argument " "1"" of type '" "wxCursor *""'");
10281 }
10282 arg1 = reinterpret_cast< wxCursor * >(argp1);
10283 ecode2 = SWIG_AsVal_int(obj1, &val2);
10284 if (!SWIG_IsOK(ecode2)) {
10285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cursor_SetWidth" "', expected argument " "2"" of type '" "int""'");
10286 }
10287 arg2 = static_cast< int >(val2);
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 (arg1)->SetWidth(arg2);
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 resultobj = SWIG_Py_Void();
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_Cursor_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxCursor *arg1 = (wxCursor *) 0 ;
10304 int arg2 ;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 int val2 ;
10308 int ecode2 = 0 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "h", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_SetHeight" "', expected argument " "1"" of type '" "wxCursor *""'");
10319 }
10320 arg1 = reinterpret_cast< wxCursor * >(argp1);
10321 ecode2 = SWIG_AsVal_int(obj1, &val2);
10322 if (!SWIG_IsOK(ecode2)) {
10323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cursor_SetHeight" "', expected argument " "2"" of type '" "int""'");
10324 }
10325 arg2 = static_cast< int >(val2);
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 (arg1)->SetHeight(arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 resultobj = SWIG_Py_Void();
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_Cursor_SetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10340 PyObject *resultobj = 0;
10341 wxCursor *arg1 = (wxCursor *) 0 ;
10342 int arg2 ;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 int val2 ;
10346 int ecode2 = 0 ;
10347 PyObject * obj0 = 0 ;
10348 PyObject * obj1 = 0 ;
10349 char * kwnames[] = {
10350 (char *) "self",(char *) "d", NULL
10351 };
10352
10353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) SWIG_fail;
10354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10355 if (!SWIG_IsOK(res1)) {
10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_SetDepth" "', expected argument " "1"" of type '" "wxCursor *""'");
10357 }
10358 arg1 = reinterpret_cast< wxCursor * >(argp1);
10359 ecode2 = SWIG_AsVal_int(obj1, &val2);
10360 if (!SWIG_IsOK(ecode2)) {
10361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cursor_SetDepth" "', expected argument " "2"" of type '" "int""'");
10362 }
10363 arg2 = static_cast< int >(val2);
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 (arg1)->SetDepth(arg2);
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 resultobj = SWIG_Py_Void();
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 SWIGINTERN PyObject *_wrap_Cursor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj = 0;
10379 wxCursor *arg1 = (wxCursor *) 0 ;
10380 wxSize *arg2 = 0 ;
10381 void *argp1 = 0 ;
10382 int res1 = 0 ;
10383 wxSize temp2 ;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 char * kwnames[] = {
10387 (char *) "self",(char *) "size", NULL
10388 };
10389
10390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
10391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
10392 if (!SWIG_IsOK(res1)) {
10393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cursor_SetSize" "', expected argument " "1"" of type '" "wxCursor *""'");
10394 }
10395 arg1 = reinterpret_cast< wxCursor * >(argp1);
10396 {
10397 arg2 = &temp2;
10398 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10399 }
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 (arg1)->SetSize((wxSize const &)*arg2);
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 resultobj = SWIG_Py_Void();
10407 return resultobj;
10408 fail:
10409 return NULL;
10410 }
10411
10412
10413 SWIGINTERN PyObject *Cursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10414 PyObject *obj;
10415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10416 SWIG_TypeNewClientData(SWIGTYPE_p_wxCursor, SWIG_NewClientData(obj));
10417 return SWIG_Py_Void();
10418 }
10419
10420 SWIGINTERN PyObject *Cursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10421 return SWIG_Python_InitShadowInstance(args);
10422 }
10423
10424 SWIGINTERN PyObject *_wrap_new_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = 0;
10426 int arg1 = (int) 0 ;
10427 int arg2 = (int) 0 ;
10428 int arg3 = (int) 0 ;
10429 int arg4 = (int) 0 ;
10430 wxRegion *result = 0 ;
10431 int val1 ;
10432 int ecode1 = 0 ;
10433 int val2 ;
10434 int ecode2 = 0 ;
10435 int val3 ;
10436 int ecode3 = 0 ;
10437 int val4 ;
10438 int ecode4 = 0 ;
10439 PyObject * obj0 = 0 ;
10440 PyObject * obj1 = 0 ;
10441 PyObject * obj2 = 0 ;
10442 PyObject * obj3 = 0 ;
10443 char * kwnames[] = {
10444 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10445 };
10446
10447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10448 if (obj0) {
10449 ecode1 = SWIG_AsVal_int(obj0, &val1);
10450 if (!SWIG_IsOK(ecode1)) {
10451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Region" "', expected argument " "1"" of type '" "int""'");
10452 }
10453 arg1 = static_cast< int >(val1);
10454 }
10455 if (obj1) {
10456 ecode2 = SWIG_AsVal_int(obj1, &val2);
10457 if (!SWIG_IsOK(ecode2)) {
10458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Region" "', expected argument " "2"" of type '" "int""'");
10459 }
10460 arg2 = static_cast< int >(val2);
10461 }
10462 if (obj2) {
10463 ecode3 = SWIG_AsVal_int(obj2, &val3);
10464 if (!SWIG_IsOK(ecode3)) {
10465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Region" "', expected argument " "3"" of type '" "int""'");
10466 }
10467 arg3 = static_cast< int >(val3);
10468 }
10469 if (obj3) {
10470 ecode4 = SWIG_AsVal_int(obj3, &val4);
10471 if (!SWIG_IsOK(ecode4)) {
10472 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Region" "', expected argument " "4"" of type '" "int""'");
10473 }
10474 arg4 = static_cast< int >(val4);
10475 }
10476 {
10477 if (!wxPyCheckForApp()) SWIG_fail;
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_NEW | 0 );
10484 return resultobj;
10485 fail:
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_new_RegionFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxBitmap *arg1 = 0 ;
10493 wxRegion *result = 0 ;
10494 void *argp1 = 0 ;
10495 int res1 = 0 ;
10496 PyObject * obj0 = 0 ;
10497 char * kwnames[] = {
10498 (char *) "bmp", NULL
10499 };
10500
10501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) SWIG_fail;
10502 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
10503 if (!SWIG_IsOK(res1)) {
10504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
10505 }
10506 if (!argp1) {
10507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
10508 }
10509 arg1 = reinterpret_cast< wxBitmap * >(argp1);
10510 {
10511 if (!wxPyCheckForApp()) SWIG_fail;
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 SWIGINTERN PyObject *_wrap_new_RegionFromBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj = 0;
10526 wxBitmap *arg1 = 0 ;
10527 wxColour *arg2 = 0 ;
10528 int arg3 = (int) 0 ;
10529 wxRegion *result = 0 ;
10530 void *argp1 = 0 ;
10531 int res1 = 0 ;
10532 wxColour temp2 ;
10533 int val3 ;
10534 int ecode3 = 0 ;
10535 PyObject * obj0 = 0 ;
10536 PyObject * obj1 = 0 ;
10537 PyObject * obj2 = 0 ;
10538 char * kwnames[] = {
10539 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
10540 };
10541
10542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10543 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
10544 if (!SWIG_IsOK(res1)) {
10545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
10546 }
10547 if (!argp1) {
10548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionFromBitmapColour" "', expected argument " "1"" of type '" "wxBitmap const &""'");
10549 }
10550 arg1 = reinterpret_cast< wxBitmap * >(argp1);
10551 {
10552 arg2 = &temp2;
10553 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10554 }
10555 if (obj2) {
10556 ecode3 = SWIG_AsVal_int(obj2, &val3);
10557 if (!SWIG_IsOK(ecode3)) {
10558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromBitmapColour" "', expected argument " "3"" of type '" "int""'");
10559 }
10560 arg3 = static_cast< int >(val3);
10561 }
10562 {
10563 if (!wxPyCheckForApp()) SWIG_fail;
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_new_RegionFromPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj = 0;
10578 int arg1 ;
10579 wxPoint *arg2 = (wxPoint *) 0 ;
10580 int arg3 = (int) wxWINDING_RULE ;
10581 wxRegion *result = 0 ;
10582 int val3 ;
10583 int ecode3 = 0 ;
10584 PyObject * obj0 = 0 ;
10585 PyObject * obj1 = 0 ;
10586 char * kwnames[] = {
10587 (char *) "points",(char *) "fillStyle", NULL
10588 };
10589
10590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) SWIG_fail;
10591 {
10592 arg2 = wxPoint_LIST_helper(obj0, &arg1);
10593 if (arg2 == NULL) SWIG_fail;
10594 }
10595 if (obj1) {
10596 ecode3 = SWIG_AsVal_int(obj1, &val3);
10597 if (!SWIG_IsOK(ecode3)) {
10598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RegionFromPoints" "', expected argument " "3"" of type '" "int""'");
10599 }
10600 arg3 = static_cast< int >(val3);
10601 }
10602 {
10603 if (!wxPyCheckForApp()) SWIG_fail;
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, SWIG_POINTER_OWN | 0 );
10610 {
10611 if (arg2) delete [] arg2;
10612 }
10613 return resultobj;
10614 fail:
10615 {
10616 if (arg2) delete [] arg2;
10617 }
10618 return NULL;
10619 }
10620
10621
10622 SWIGINTERN PyObject *_wrap_delete_Region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10623 PyObject *resultobj = 0;
10624 wxRegion *arg1 = (wxRegion *) 0 ;
10625 void *argp1 = 0 ;
10626 int res1 = 0 ;
10627 PyObject *swig_obj[1] ;
10628
10629 if (!args) SWIG_fail;
10630 swig_obj[0] = args;
10631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, SWIG_POINTER_DISOWN | 0 );
10632 if (!SWIG_IsOK(res1)) {
10633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', expected argument " "1"" of type '" "wxRegion *""'");
10634 }
10635 arg1 = reinterpret_cast< wxRegion * >(argp1);
10636 {
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 delete arg1;
10639
10640 wxPyEndAllowThreads(__tstate);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_Py_Void();
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_Region_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10651 PyObject *resultobj = 0;
10652 wxRegion *arg1 = (wxRegion *) 0 ;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject *swig_obj[1] ;
10656
10657 if (!args) SWIG_fail;
10658 swig_obj[0] = args;
10659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10660 if (!SWIG_IsOK(res1)) {
10661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Clear" "', expected argument " "1"" of type '" "wxRegion *""'");
10662 }
10663 arg1 = reinterpret_cast< wxRegion * >(argp1);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 (arg1)->Clear();
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 resultobj = SWIG_Py_Void();
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 SWIGINTERN PyObject *_wrap_Region_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj = 0;
10679 wxRegion *arg1 = (wxRegion *) 0 ;
10680 int arg2 ;
10681 int arg3 ;
10682 bool result;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 int val2 ;
10686 int ecode2 = 0 ;
10687 int val3 ;
10688 int ecode3 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char * kwnames[] = {
10693 (char *) "self",(char *) "x",(char *) "y", NULL
10694 };
10695
10696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10698 if (!SWIG_IsOK(res1)) {
10699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Offset" "', expected argument " "1"" of type '" "wxRegion *""'");
10700 }
10701 arg1 = reinterpret_cast< wxRegion * >(argp1);
10702 ecode2 = SWIG_AsVal_int(obj1, &val2);
10703 if (!SWIG_IsOK(ecode2)) {
10704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Offset" "', expected argument " "2"" of type '" "int""'");
10705 }
10706 arg2 = static_cast< int >(val2);
10707 ecode3 = SWIG_AsVal_int(obj2, &val3);
10708 if (!SWIG_IsOK(ecode3)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Offset" "', expected argument " "3"" of type '" "int""'");
10710 }
10711 arg3 = static_cast< int >(val3);
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = (bool)(arg1)->Offset(arg2,arg3);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10720 }
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_Region_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj = 0;
10729 wxRegion *arg1 = (wxRegion *) 0 ;
10730 int arg2 ;
10731 int arg3 ;
10732 wxRegionContain result;
10733 void *argp1 = 0 ;
10734 int res1 = 0 ;
10735 int val2 ;
10736 int ecode2 = 0 ;
10737 int val3 ;
10738 int ecode3 = 0 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 char * kwnames[] = {
10743 (char *) "self",(char *) "x",(char *) "y", NULL
10744 };
10745
10746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10748 if (!SWIG_IsOK(res1)) {
10749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Contains" "', expected argument " "1"" of type '" "wxRegion *""'");
10750 }
10751 arg1 = reinterpret_cast< wxRegion * >(argp1);
10752 ecode2 = SWIG_AsVal_int(obj1, &val2);
10753 if (!SWIG_IsOK(ecode2)) {
10754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Contains" "', expected argument " "2"" of type '" "int""'");
10755 }
10756 arg2 = static_cast< int >(val2);
10757 ecode3 = SWIG_AsVal_int(obj2, &val3);
10758 if (!SWIG_IsOK(ecode3)) {
10759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Contains" "', expected argument " "3"" of type '" "int""'");
10760 }
10761 arg3 = static_cast< int >(val3);
10762 {
10763 PyThreadState* __tstate = wxPyBeginAllowThreads();
10764 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_From_int(static_cast< int >(result));
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 SWIGINTERN PyObject *_wrap_Region_ContainsPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj = 0;
10777 wxRegion *arg1 = (wxRegion *) 0 ;
10778 wxPoint *arg2 = 0 ;
10779 wxRegionContain result;
10780 void *argp1 = 0 ;
10781 int res1 = 0 ;
10782 wxPoint temp2 ;
10783 PyObject * obj0 = 0 ;
10784 PyObject * obj1 = 0 ;
10785 char * kwnames[] = {
10786 (char *) "self",(char *) "pt", NULL
10787 };
10788
10789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) SWIG_fail;
10790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10791 if (!SWIG_IsOK(res1)) {
10792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsPoint" "', expected argument " "1"" of type '" "wxRegion *""'");
10793 }
10794 arg1 = reinterpret_cast< wxRegion * >(argp1);
10795 {
10796 arg2 = &temp2;
10797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
10798 }
10799 {
10800 PyThreadState* __tstate = wxPyBeginAllowThreads();
10801 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
10802 wxPyEndAllowThreads(__tstate);
10803 if (PyErr_Occurred()) SWIG_fail;
10804 }
10805 resultobj = SWIG_From_int(static_cast< int >(result));
10806 return resultobj;
10807 fail:
10808 return NULL;
10809 }
10810
10811
10812 SWIGINTERN PyObject *_wrap_Region_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj = 0;
10814 wxRegion *arg1 = (wxRegion *) 0 ;
10815 wxRect *arg2 = 0 ;
10816 wxRegionContain result;
10817 void *argp1 = 0 ;
10818 int res1 = 0 ;
10819 wxRect temp2 ;
10820 PyObject * obj0 = 0 ;
10821 PyObject * obj1 = 0 ;
10822 char * kwnames[] = {
10823 (char *) "self",(char *) "rect", NULL
10824 };
10825
10826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10828 if (!SWIG_IsOK(res1)) {
10829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRect" "', expected argument " "1"" of type '" "wxRegion *""'");
10830 }
10831 arg1 = reinterpret_cast< wxRegion * >(argp1);
10832 {
10833 arg2 = &temp2;
10834 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
10835 }
10836 {
10837 PyThreadState* __tstate = wxPyBeginAllowThreads();
10838 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 resultobj = SWIG_From_int(static_cast< int >(result));
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 SWIGINTERN PyObject *_wrap_Region_ContainsRectDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10850 PyObject *resultobj = 0;
10851 wxRegion *arg1 = (wxRegion *) 0 ;
10852 int arg2 ;
10853 int arg3 ;
10854 int arg4 ;
10855 int arg5 ;
10856 wxRegionContain result;
10857 void *argp1 = 0 ;
10858 int res1 = 0 ;
10859 int val2 ;
10860 int ecode2 = 0 ;
10861 int val3 ;
10862 int ecode3 = 0 ;
10863 int val4 ;
10864 int ecode4 = 0 ;
10865 int val5 ;
10866 int ecode5 = 0 ;
10867 PyObject * obj0 = 0 ;
10868 PyObject * obj1 = 0 ;
10869 PyObject * obj2 = 0 ;
10870 PyObject * obj3 = 0 ;
10871 PyObject * obj4 = 0 ;
10872 char * kwnames[] = {
10873 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
10874 };
10875
10876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10878 if (!SWIG_IsOK(res1)) {
10879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ContainsRectDim" "', expected argument " "1"" of type '" "wxRegion *""'");
10880 }
10881 arg1 = reinterpret_cast< wxRegion * >(argp1);
10882 ecode2 = SWIG_AsVal_int(obj1, &val2);
10883 if (!SWIG_IsOK(ecode2)) {
10884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_ContainsRectDim" "', expected argument " "2"" of type '" "int""'");
10885 }
10886 arg2 = static_cast< int >(val2);
10887 ecode3 = SWIG_AsVal_int(obj2, &val3);
10888 if (!SWIG_IsOK(ecode3)) {
10889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_ContainsRectDim" "', expected argument " "3"" of type '" "int""'");
10890 }
10891 arg3 = static_cast< int >(val3);
10892 ecode4 = SWIG_AsVal_int(obj3, &val4);
10893 if (!SWIG_IsOK(ecode4)) {
10894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_ContainsRectDim" "', expected argument " "4"" of type '" "int""'");
10895 }
10896 arg4 = static_cast< int >(val4);
10897 ecode5 = SWIG_AsVal_int(obj4, &val5);
10898 if (!SWIG_IsOK(ecode5)) {
10899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_ContainsRectDim" "', expected argument " "5"" of type '" "int""'");
10900 }
10901 arg5 = static_cast< int >(val5);
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_From_int(static_cast< int >(result));
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 SWIGINTERN PyObject *_wrap_Region_GetBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10916 PyObject *resultobj = 0;
10917 wxRegion *arg1 = (wxRegion *) 0 ;
10918 wxRect result;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 PyObject *swig_obj[1] ;
10922
10923 if (!args) SWIG_fail;
10924 swig_obj[0] = args;
10925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_GetBox" "', expected argument " "1"" of type '" "wxRegion *""'");
10928 }
10929 arg1 = reinterpret_cast< wxRegion * >(argp1);
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 result = (arg1)->GetBox();
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
10937 return resultobj;
10938 fail:
10939 return NULL;
10940 }
10941
10942
10943 SWIGINTERN PyObject *_wrap_Region_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj = 0;
10945 wxRegion *arg1 = (wxRegion *) 0 ;
10946 int arg2 ;
10947 int arg3 ;
10948 int arg4 ;
10949 int arg5 ;
10950 bool result;
10951 void *argp1 = 0 ;
10952 int res1 = 0 ;
10953 int val2 ;
10954 int ecode2 = 0 ;
10955 int val3 ;
10956 int ecode3 = 0 ;
10957 int val4 ;
10958 int ecode4 = 0 ;
10959 int val5 ;
10960 int ecode5 = 0 ;
10961 PyObject * obj0 = 0 ;
10962 PyObject * obj1 = 0 ;
10963 PyObject * obj2 = 0 ;
10964 PyObject * obj3 = 0 ;
10965 PyObject * obj4 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Intersect" "', expected argument " "1"" of type '" "wxRegion *""'");
10974 }
10975 arg1 = reinterpret_cast< wxRegion * >(argp1);
10976 ecode2 = SWIG_AsVal_int(obj1, &val2);
10977 if (!SWIG_IsOK(ecode2)) {
10978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Intersect" "', expected argument " "2"" of type '" "int""'");
10979 }
10980 arg2 = static_cast< int >(val2);
10981 ecode3 = SWIG_AsVal_int(obj2, &val3);
10982 if (!SWIG_IsOK(ecode3)) {
10983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Intersect" "', expected argument " "3"" of type '" "int""'");
10984 }
10985 arg3 = static_cast< int >(val3);
10986 ecode4 = SWIG_AsVal_int(obj3, &val4);
10987 if (!SWIG_IsOK(ecode4)) {
10988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Intersect" "', expected argument " "4"" of type '" "int""'");
10989 }
10990 arg4 = static_cast< int >(val4);
10991 ecode5 = SWIG_AsVal_int(obj4, &val5);
10992 if (!SWIG_IsOK(ecode5)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Intersect" "', expected argument " "5"" of type '" "int""'");
10994 }
10995 arg5 = static_cast< int >(val5);
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11004 }
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Region_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj = 0;
11013 wxRegion *arg1 = (wxRegion *) 0 ;
11014 wxRect *arg2 = 0 ;
11015 bool result;
11016 void *argp1 = 0 ;
11017 int res1 = 0 ;
11018 wxRect temp2 ;
11019 PyObject * obj0 = 0 ;
11020 PyObject * obj1 = 0 ;
11021 char * kwnames[] = {
11022 (char *) "self",(char *) "rect", NULL
11023 };
11024
11025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
11026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11027 if (!SWIG_IsOK(res1)) {
11028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRect" "', expected argument " "1"" of type '" "wxRegion *""'");
11029 }
11030 arg1 = reinterpret_cast< wxRegion * >(argp1);
11031 {
11032 arg2 = &temp2;
11033 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11043 }
11044 return resultobj;
11045 fail:
11046 return NULL;
11047 }
11048
11049
11050 SWIGINTERN PyObject *_wrap_Region_IntersectRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11051 PyObject *resultobj = 0;
11052 wxRegion *arg1 = (wxRegion *) 0 ;
11053 wxRegion *arg2 = 0 ;
11054 bool result;
11055 void *argp1 = 0 ;
11056 int res1 = 0 ;
11057 void *argp2 = 0 ;
11058 int res2 = 0 ;
11059 PyObject * obj0 = 0 ;
11060 PyObject * obj1 = 0 ;
11061 char * kwnames[] = {
11062 (char *) "self",(char *) "region", NULL
11063 };
11064
11065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) SWIG_fail;
11066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IntersectRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
11069 }
11070 arg1 = reinterpret_cast< wxRegion * >(argp1);
11071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
11072 if (!SWIG_IsOK(res2)) {
11073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11074 }
11075 if (!argp2) {
11076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_IntersectRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11077 }
11078 arg2 = reinterpret_cast< wxRegion * >(argp2);
11079 {
11080 PyThreadState* __tstate = wxPyBeginAllowThreads();
11081 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 {
11086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11087 }
11088 return resultobj;
11089 fail:
11090 return NULL;
11091 }
11092
11093
11094 SWIGINTERN PyObject *_wrap_Region_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11095 PyObject *resultobj = 0;
11096 wxRegion *arg1 = (wxRegion *) 0 ;
11097 bool result;
11098 void *argp1 = 0 ;
11099 int res1 = 0 ;
11100 PyObject *swig_obj[1] ;
11101
11102 if (!args) SWIG_fail;
11103 swig_obj[0] = args;
11104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11105 if (!SWIG_IsOK(res1)) {
11106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_IsEmpty" "', expected argument " "1"" of type '" "wxRegion *""'");
11107 }
11108 arg1 = reinterpret_cast< wxRegion * >(argp1);
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 result = (bool)(arg1)->IsEmpty();
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 {
11116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11117 }
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 SWIGINTERN PyObject *_wrap_Region_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11125 PyObject *resultobj = 0;
11126 wxRegion *arg1 = (wxRegion *) 0 ;
11127 int arg2 ;
11128 int arg3 ;
11129 int arg4 ;
11130 int arg5 ;
11131 bool result;
11132 void *argp1 = 0 ;
11133 int res1 = 0 ;
11134 int val2 ;
11135 int ecode2 = 0 ;
11136 int val3 ;
11137 int ecode3 = 0 ;
11138 int val4 ;
11139 int ecode4 = 0 ;
11140 int val5 ;
11141 int ecode5 = 0 ;
11142 PyObject * obj0 = 0 ;
11143 PyObject * obj1 = 0 ;
11144 PyObject * obj2 = 0 ;
11145 PyObject * obj3 = 0 ;
11146 PyObject * obj4 = 0 ;
11147 char * kwnames[] = {
11148 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11149 };
11150
11151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11153 if (!SWIG_IsOK(res1)) {
11154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Union" "', expected argument " "1"" of type '" "wxRegion *""'");
11155 }
11156 arg1 = reinterpret_cast< wxRegion * >(argp1);
11157 ecode2 = SWIG_AsVal_int(obj1, &val2);
11158 if (!SWIG_IsOK(ecode2)) {
11159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Union" "', expected argument " "2"" of type '" "int""'");
11160 }
11161 arg2 = static_cast< int >(val2);
11162 ecode3 = SWIG_AsVal_int(obj2, &val3);
11163 if (!SWIG_IsOK(ecode3)) {
11164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Union" "', expected argument " "3"" of type '" "int""'");
11165 }
11166 arg3 = static_cast< int >(val3);
11167 ecode4 = SWIG_AsVal_int(obj3, &val4);
11168 if (!SWIG_IsOK(ecode4)) {
11169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Union" "', expected argument " "4"" of type '" "int""'");
11170 }
11171 arg4 = static_cast< int >(val4);
11172 ecode5 = SWIG_AsVal_int(obj4, &val5);
11173 if (!SWIG_IsOK(ecode5)) {
11174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Union" "', expected argument " "5"" of type '" "int""'");
11175 }
11176 arg5 = static_cast< int >(val5);
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
11180 wxPyEndAllowThreads(__tstate);
11181 if (PyErr_Occurred()) SWIG_fail;
11182 }
11183 {
11184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11185 }
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 SWIGINTERN PyObject *_wrap_Region_UnionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj = 0;
11194 wxRegion *arg1 = (wxRegion *) 0 ;
11195 wxRect *arg2 = 0 ;
11196 bool result;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 wxRect temp2 ;
11200 PyObject * obj0 = 0 ;
11201 PyObject * obj1 = 0 ;
11202 char * kwnames[] = {
11203 (char *) "self",(char *) "rect", NULL
11204 };
11205
11206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) SWIG_fail;
11207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRect" "', expected argument " "1"" of type '" "wxRegion *""'");
11210 }
11211 arg1 = reinterpret_cast< wxRegion * >(argp1);
11212 {
11213 arg2 = &temp2;
11214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11215 }
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (bool)(arg1)->Union((wxRect const &)*arg2);
11219 wxPyEndAllowThreads(__tstate);
11220 if (PyErr_Occurred()) SWIG_fail;
11221 }
11222 {
11223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11224 }
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 SWIGINTERN PyObject *_wrap_Region_UnionRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj = 0;
11233 wxRegion *arg1 = (wxRegion *) 0 ;
11234 wxRegion *arg2 = 0 ;
11235 bool result;
11236 void *argp1 = 0 ;
11237 int res1 = 0 ;
11238 void *argp2 = 0 ;
11239 int res2 = 0 ;
11240 PyObject * obj0 = 0 ;
11241 PyObject * obj1 = 0 ;
11242 char * kwnames[] = {
11243 (char *) "self",(char *) "region", NULL
11244 };
11245
11246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) SWIG_fail;
11247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11248 if (!SWIG_IsOK(res1)) {
11249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
11250 }
11251 arg1 = reinterpret_cast< wxRegion * >(argp1);
11252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
11253 if (!SWIG_IsOK(res2)) {
11254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11255 }
11256 if (!argp2) {
11257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11258 }
11259 arg2 = reinterpret_cast< wxRegion * >(argp2);
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
11263 wxPyEndAllowThreads(__tstate);
11264 if (PyErr_Occurred()) SWIG_fail;
11265 }
11266 {
11267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11268 }
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 SWIGINTERN PyObject *_wrap_Region_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj = 0;
11277 wxRegion *arg1 = (wxRegion *) 0 ;
11278 int arg2 ;
11279 int arg3 ;
11280 int arg4 ;
11281 int arg5 ;
11282 bool result;
11283 void *argp1 = 0 ;
11284 int res1 = 0 ;
11285 int val2 ;
11286 int ecode2 = 0 ;
11287 int val3 ;
11288 int ecode3 = 0 ;
11289 int val4 ;
11290 int ecode4 = 0 ;
11291 int val5 ;
11292 int ecode5 = 0 ;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 PyObject * obj3 = 0 ;
11297 PyObject * obj4 = 0 ;
11298 char * kwnames[] = {
11299 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11300 };
11301
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11304 if (!SWIG_IsOK(res1)) {
11305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Subtract" "', expected argument " "1"" of type '" "wxRegion *""'");
11306 }
11307 arg1 = reinterpret_cast< wxRegion * >(argp1);
11308 ecode2 = SWIG_AsVal_int(obj1, &val2);
11309 if (!SWIG_IsOK(ecode2)) {
11310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Subtract" "', expected argument " "2"" of type '" "int""'");
11311 }
11312 arg2 = static_cast< int >(val2);
11313 ecode3 = SWIG_AsVal_int(obj2, &val3);
11314 if (!SWIG_IsOK(ecode3)) {
11315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Subtract" "', expected argument " "3"" of type '" "int""'");
11316 }
11317 arg3 = static_cast< int >(val3);
11318 ecode4 = SWIG_AsVal_int(obj3, &val4);
11319 if (!SWIG_IsOK(ecode4)) {
11320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Subtract" "', expected argument " "4"" of type '" "int""'");
11321 }
11322 arg4 = static_cast< int >(val4);
11323 ecode5 = SWIG_AsVal_int(obj4, &val5);
11324 if (!SWIG_IsOK(ecode5)) {
11325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Subtract" "', expected argument " "5"" of type '" "int""'");
11326 }
11327 arg5 = static_cast< int >(val5);
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
11331 wxPyEndAllowThreads(__tstate);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 }
11334 {
11335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11336 }
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *_wrap_Region_SubtractRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj = 0;
11345 wxRegion *arg1 = (wxRegion *) 0 ;
11346 wxRect *arg2 = 0 ;
11347 bool result;
11348 void *argp1 = 0 ;
11349 int res1 = 0 ;
11350 wxRect temp2 ;
11351 PyObject * obj0 = 0 ;
11352 PyObject * obj1 = 0 ;
11353 char * kwnames[] = {
11354 (char *) "self",(char *) "rect", NULL
11355 };
11356
11357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) SWIG_fail;
11358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11359 if (!SWIG_IsOK(res1)) {
11360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRect" "', expected argument " "1"" of type '" "wxRegion *""'");
11361 }
11362 arg1 = reinterpret_cast< wxRegion * >(argp1);
11363 {
11364 arg2 = &temp2;
11365 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11366 }
11367 {
11368 PyThreadState* __tstate = wxPyBeginAllowThreads();
11369 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
11370 wxPyEndAllowThreads(__tstate);
11371 if (PyErr_Occurred()) SWIG_fail;
11372 }
11373 {
11374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11375 }
11376 return resultobj;
11377 fail:
11378 return NULL;
11379 }
11380
11381
11382 SWIGINTERN PyObject *_wrap_Region_SubtractRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj = 0;
11384 wxRegion *arg1 = (wxRegion *) 0 ;
11385 wxRegion *arg2 = 0 ;
11386 bool result;
11387 void *argp1 = 0 ;
11388 int res1 = 0 ;
11389 void *argp2 = 0 ;
11390 int res2 = 0 ;
11391 PyObject * obj0 = 0 ;
11392 PyObject * obj1 = 0 ;
11393 char * kwnames[] = {
11394 (char *) "self",(char *) "region", NULL
11395 };
11396
11397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) SWIG_fail;
11398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11399 if (!SWIG_IsOK(res1)) {
11400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_SubtractRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
11401 }
11402 arg1 = reinterpret_cast< wxRegion * >(argp1);
11403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
11404 if (!SWIG_IsOK(res2)) {
11405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11406 }
11407 if (!argp2) {
11408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_SubtractRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11409 }
11410 arg2 = reinterpret_cast< wxRegion * >(argp2);
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 {
11418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11419 }
11420 return resultobj;
11421 fail:
11422 return NULL;
11423 }
11424
11425
11426 SWIGINTERN PyObject *_wrap_Region_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11427 PyObject *resultobj = 0;
11428 wxRegion *arg1 = (wxRegion *) 0 ;
11429 int arg2 ;
11430 int arg3 ;
11431 int arg4 ;
11432 int arg5 ;
11433 bool result;
11434 void *argp1 = 0 ;
11435 int res1 = 0 ;
11436 int val2 ;
11437 int ecode2 = 0 ;
11438 int val3 ;
11439 int ecode3 = 0 ;
11440 int val4 ;
11441 int ecode4 = 0 ;
11442 int val5 ;
11443 int ecode5 = 0 ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 PyObject * obj2 = 0 ;
11447 PyObject * obj3 = 0 ;
11448 PyObject * obj4 = 0 ;
11449 char * kwnames[] = {
11450 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11451 };
11452
11453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11455 if (!SWIG_IsOK(res1)) {
11456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_Xor" "', expected argument " "1"" of type '" "wxRegion *""'");
11457 }
11458 arg1 = reinterpret_cast< wxRegion * >(argp1);
11459 ecode2 = SWIG_AsVal_int(obj1, &val2);
11460 if (!SWIG_IsOK(ecode2)) {
11461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Region_Xor" "', expected argument " "2"" of type '" "int""'");
11462 }
11463 arg2 = static_cast< int >(val2);
11464 ecode3 = SWIG_AsVal_int(obj2, &val3);
11465 if (!SWIG_IsOK(ecode3)) {
11466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Region_Xor" "', expected argument " "3"" of type '" "int""'");
11467 }
11468 arg3 = static_cast< int >(val3);
11469 ecode4 = SWIG_AsVal_int(obj3, &val4);
11470 if (!SWIG_IsOK(ecode4)) {
11471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_Xor" "', expected argument " "4"" of type '" "int""'");
11472 }
11473 arg4 = static_cast< int >(val4);
11474 ecode5 = SWIG_AsVal_int(obj4, &val5);
11475 if (!SWIG_IsOK(ecode5)) {
11476 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Region_Xor" "', expected argument " "5"" of type '" "int""'");
11477 }
11478 arg5 = static_cast< int >(val5);
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 {
11486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11487 }
11488 return resultobj;
11489 fail:
11490 return NULL;
11491 }
11492
11493
11494 SWIGINTERN PyObject *_wrap_Region_XorRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11495 PyObject *resultobj = 0;
11496 wxRegion *arg1 = (wxRegion *) 0 ;
11497 wxRect *arg2 = 0 ;
11498 bool result;
11499 void *argp1 = 0 ;
11500 int res1 = 0 ;
11501 wxRect temp2 ;
11502 PyObject * obj0 = 0 ;
11503 PyObject * obj1 = 0 ;
11504 char * kwnames[] = {
11505 (char *) "self",(char *) "rect", NULL
11506 };
11507
11508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) SWIG_fail;
11509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11510 if (!SWIG_IsOK(res1)) {
11511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRect" "', expected argument " "1"" of type '" "wxRegion *""'");
11512 }
11513 arg1 = reinterpret_cast< wxRegion * >(argp1);
11514 {
11515 arg2 = &temp2;
11516 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11517 }
11518 {
11519 PyThreadState* __tstate = wxPyBeginAllowThreads();
11520 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
11521 wxPyEndAllowThreads(__tstate);
11522 if (PyErr_Occurred()) SWIG_fail;
11523 }
11524 {
11525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11526 }
11527 return resultobj;
11528 fail:
11529 return NULL;
11530 }
11531
11532
11533 SWIGINTERN PyObject *_wrap_Region_XorRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11534 PyObject *resultobj = 0;
11535 wxRegion *arg1 = (wxRegion *) 0 ;
11536 wxRegion *arg2 = 0 ;
11537 bool result;
11538 void *argp1 = 0 ;
11539 int res1 = 0 ;
11540 void *argp2 = 0 ;
11541 int res2 = 0 ;
11542 PyObject * obj0 = 0 ;
11543 PyObject * obj1 = 0 ;
11544 char * kwnames[] = {
11545 (char *) "self",(char *) "region", NULL
11546 };
11547
11548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) SWIG_fail;
11549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11550 if (!SWIG_IsOK(res1)) {
11551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_XorRegion" "', expected argument " "1"" of type '" "wxRegion *""'");
11552 }
11553 arg1 = reinterpret_cast< wxRegion * >(argp1);
11554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
11555 if (!SWIG_IsOK(res2)) {
11556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11557 }
11558 if (!argp2) {
11559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_XorRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
11560 }
11561 arg2 = reinterpret_cast< wxRegion * >(argp2);
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 {
11569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11570 }
11571 return resultobj;
11572 fail:
11573 return NULL;
11574 }
11575
11576
11577 SWIGINTERN PyObject *_wrap_Region_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11578 PyObject *resultobj = 0;
11579 wxRegion *arg1 = (wxRegion *) 0 ;
11580 SwigValueWrapper<wxBitmap > result;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 PyObject *swig_obj[1] ;
11584
11585 if (!args) SWIG_fail;
11586 swig_obj[0] = args;
11587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11588 if (!SWIG_IsOK(res1)) {
11589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_ConvertToBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
11590 }
11591 arg1 = reinterpret_cast< wxRegion * >(argp1);
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (arg1)->ConvertToBitmap();
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 SWIGINTERN PyObject *_wrap_Region_UnionBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj = 0;
11607 wxRegion *arg1 = (wxRegion *) 0 ;
11608 wxBitmap *arg2 = 0 ;
11609 bool result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 void *argp2 = 0 ;
11613 int res2 = 0 ;
11614 PyObject * obj0 = 0 ;
11615 PyObject * obj1 = 0 ;
11616 char * kwnames[] = {
11617 (char *) "self",(char *) "bmp", NULL
11618 };
11619
11620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
11621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11622 if (!SWIG_IsOK(res1)) {
11623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmap" "', expected argument " "1"" of type '" "wxRegion *""'");
11624 }
11625 arg1 = reinterpret_cast< wxRegion * >(argp1);
11626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11627 if (!SWIG_IsOK(res2)) {
11628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11629 }
11630 if (!argp2) {
11631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11632 }
11633 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11642 }
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 SWIGINTERN PyObject *_wrap_Region_UnionBitmapColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj = 0;
11651 wxRegion *arg1 = (wxRegion *) 0 ;
11652 wxBitmap *arg2 = 0 ;
11653 wxColour *arg3 = 0 ;
11654 int arg4 = (int) 0 ;
11655 bool result;
11656 void *argp1 = 0 ;
11657 int res1 = 0 ;
11658 void *argp2 = 0 ;
11659 int res2 = 0 ;
11660 wxColour temp3 ;
11661 int val4 ;
11662 int ecode4 = 0 ;
11663 PyObject * obj0 = 0 ;
11664 PyObject * obj1 = 0 ;
11665 PyObject * obj2 = 0 ;
11666 PyObject * obj3 = 0 ;
11667 char * kwnames[] = {
11668 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
11669 };
11670
11671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRegion, 0 | 0 );
11673 if (!SWIG_IsOK(res1)) {
11674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_UnionBitmapColour" "', expected argument " "1"" of type '" "wxRegion *""'");
11675 }
11676 arg1 = reinterpret_cast< wxRegion * >(argp1);
11677 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11678 if (!SWIG_IsOK(res2)) {
11679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11680 }
11681 if (!argp2) {
11682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Region_UnionBitmapColour" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11683 }
11684 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11685 {
11686 arg3 = &temp3;
11687 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
11688 }
11689 if (obj3) {
11690 ecode4 = SWIG_AsVal_int(obj3, &val4);
11691 if (!SWIG_IsOK(ecode4)) {
11692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Region_UnionBitmapColour" "', expected argument " "4"" of type '" "int""'");
11693 }
11694 arg4 = static_cast< int >(val4);
11695 }
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 {
11703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11704 }
11705 return resultobj;
11706 fail:
11707 return NULL;
11708 }
11709
11710
11711 SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712 PyObject *obj;
11713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11714 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegion, SWIG_NewClientData(obj));
11715 return SWIG_Py_Void();
11716 }
11717
11718 SWIGINTERN PyObject *Region_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 return SWIG_Python_InitShadowInstance(args);
11720 }
11721
11722 SWIGINTERN PyObject *_wrap_new_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11723 PyObject *resultobj = 0;
11724 wxRegion *arg1 = 0 ;
11725 wxRegionIterator *result = 0 ;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject * obj0 = 0 ;
11729 char * kwnames[] = {
11730 (char *) "region", NULL
11731 };
11732
11733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) SWIG_fail;
11734 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRegion, 0 | 0);
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11737 }
11738 if (!argp1) {
11739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegionIterator" "', expected argument " "1"" of type '" "wxRegion const &""'");
11740 }
11741 arg1 = reinterpret_cast< wxRegion * >(argp1);
11742 {
11743 if (!wxPyCheckForApp()) SWIG_fail;
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
11746 wxPyEndAllowThreads(__tstate);
11747 if (PyErr_Occurred()) SWIG_fail;
11748 }
11749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_NEW | 0 );
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 SWIGINTERN PyObject *_wrap_delete_RegionIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757 PyObject *resultobj = 0;
11758 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11759 void *argp1 = 0 ;
11760 int res1 = 0 ;
11761 PyObject *swig_obj[1] ;
11762
11763 if (!args) SWIG_fail;
11764 swig_obj[0] = args;
11765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_DISOWN | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegionIterator" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11768 }
11769 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 delete arg1;
11773
11774 wxPyEndAllowThreads(__tstate);
11775 if (PyErr_Occurred()) SWIG_fail;
11776 }
11777 resultobj = SWIG_Py_Void();
11778 return resultobj;
11779 fail:
11780 return NULL;
11781 }
11782
11783
11784 SWIGINTERN PyObject *_wrap_RegionIterator_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11785 PyObject *resultobj = 0;
11786 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11787 int result;
11788 void *argp1 = 0 ;
11789 int res1 = 0 ;
11790 PyObject *swig_obj[1] ;
11791
11792 if (!args) SWIG_fail;
11793 swig_obj[0] = args;
11794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11795 if (!SWIG_IsOK(res1)) {
11796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetX" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11797 }
11798 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (int)(arg1)->GetX();
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 resultobj = SWIG_From_int(static_cast< int >(result));
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_RegionIterator_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11813 PyObject *resultobj = 0;
11814 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11815 int result;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 PyObject *swig_obj[1] ;
11819
11820 if (!args) SWIG_fail;
11821 swig_obj[0] = args;
11822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11823 if (!SWIG_IsOK(res1)) {
11824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetY" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11825 }
11826 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11827 {
11828 PyThreadState* __tstate = wxPyBeginAllowThreads();
11829 result = (int)(arg1)->GetY();
11830 wxPyEndAllowThreads(__tstate);
11831 if (PyErr_Occurred()) SWIG_fail;
11832 }
11833 resultobj = SWIG_From_int(static_cast< int >(result));
11834 return resultobj;
11835 fail:
11836 return NULL;
11837 }
11838
11839
11840 SWIGINTERN PyObject *_wrap_RegionIterator_GetW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11841 PyObject *resultobj = 0;
11842 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11843 int result;
11844 void *argp1 = 0 ;
11845 int res1 = 0 ;
11846 PyObject *swig_obj[1] ;
11847
11848 if (!args) SWIG_fail;
11849 swig_obj[0] = args;
11850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11851 if (!SWIG_IsOK(res1)) {
11852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetW" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11853 }
11854 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = (int)(arg1)->GetW();
11858 wxPyEndAllowThreads(__tstate);
11859 if (PyErr_Occurred()) SWIG_fail;
11860 }
11861 resultobj = SWIG_From_int(static_cast< int >(result));
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_RegionIterator_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11869 PyObject *resultobj = 0;
11870 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11871 int result;
11872 void *argp1 = 0 ;
11873 int res1 = 0 ;
11874 PyObject *swig_obj[1] ;
11875
11876 if (!args) SWIG_fail;
11877 swig_obj[0] = args;
11878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11879 if (!SWIG_IsOK(res1)) {
11880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetWidth" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11881 }
11882 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 result = (int)(arg1)->GetWidth();
11886 wxPyEndAllowThreads(__tstate);
11887 if (PyErr_Occurred()) SWIG_fail;
11888 }
11889 resultobj = SWIG_From_int(static_cast< int >(result));
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *_wrap_RegionIterator_GetH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11897 PyObject *resultobj = 0;
11898 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11899 int result;
11900 void *argp1 = 0 ;
11901 int res1 = 0 ;
11902 PyObject *swig_obj[1] ;
11903
11904 if (!args) SWIG_fail;
11905 swig_obj[0] = args;
11906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11907 if (!SWIG_IsOK(res1)) {
11908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetH" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11909 }
11910 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (int)(arg1)->GetH();
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 resultobj = SWIG_From_int(static_cast< int >(result));
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_RegionIterator_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11925 PyObject *resultobj = 0;
11926 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11927 int result;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 PyObject *swig_obj[1] ;
11931
11932 if (!args) SWIG_fail;
11933 swig_obj[0] = args;
11934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11935 if (!SWIG_IsOK(res1)) {
11936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetHeight" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11937 }
11938 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (int)(arg1)->GetHeight();
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 resultobj = SWIG_From_int(static_cast< int >(result));
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 SWIGINTERN PyObject *_wrap_RegionIterator_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11953 PyObject *resultobj = 0;
11954 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11955 wxRect result;
11956 void *argp1 = 0 ;
11957 int res1 = 0 ;
11958 PyObject *swig_obj[1] ;
11959
11960 if (!args) SWIG_fail;
11961 swig_obj[0] = args;
11962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11963 if (!SWIG_IsOK(res1)) {
11964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_GetRect" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11965 }
11966 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 result = (arg1)->GetRect();
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *_wrap_RegionIterator_HaveRects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11981 PyObject *resultobj = 0;
11982 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
11983 bool result;
11984 void *argp1 = 0 ;
11985 int res1 = 0 ;
11986 PyObject *swig_obj[1] ;
11987
11988 if (!args) SWIG_fail;
11989 swig_obj[0] = args;
11990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_HaveRects" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
11993 }
11994 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 result = (bool)(arg1)->HaveRects();
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 {
12002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12003 }
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 SWIGINTERN PyObject *_wrap_RegionIterator_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12011 PyObject *resultobj = 0;
12012 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
12013 void *argp1 = 0 ;
12014 int res1 = 0 ;
12015 PyObject *swig_obj[1] ;
12016
12017 if (!args) SWIG_fail;
12018 swig_obj[0] = args;
12019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
12020 if (!SWIG_IsOK(res1)) {
12021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Reset" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
12022 }
12023 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 (arg1)->Reset();
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 resultobj = SWIG_Py_Void();
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 SWIGINTERN PyObject *_wrap_RegionIterator_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038 PyObject *resultobj = 0;
12039 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
12040 void *argp1 = 0 ;
12041 int res1 = 0 ;
12042 PyObject *swig_obj[1] ;
12043
12044 if (!args) SWIG_fail;
12045 swig_obj[0] = args;
12046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
12047 if (!SWIG_IsOK(res1)) {
12048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator_Next" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
12049 }
12050 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
12051 {
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 wxRegionIterator_Next(arg1);
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 resultobj = SWIG_Py_Void();
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 SWIGINTERN PyObject *_wrap_RegionIterator___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12065 PyObject *resultobj = 0;
12066 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
12067 bool result;
12068 void *argp1 = 0 ;
12069 int res1 = 0 ;
12070 PyObject *swig_obj[1] ;
12071
12072 if (!args) SWIG_fail;
12073 swig_obj[0] = args;
12074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRegionIterator, 0 | 0 );
12075 if (!SWIG_IsOK(res1)) {
12076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RegionIterator___nonzero__" "', expected argument " "1"" of type '" "wxRegionIterator *""'");
12077 }
12078 arg1 = reinterpret_cast< wxRegionIterator * >(argp1);
12079 {
12080 PyThreadState* __tstate = wxPyBeginAllowThreads();
12081 result = (bool)wxRegionIterator___nonzero__(arg1);
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 {
12086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *RegionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *obj;
12096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12097 SWIG_TypeNewClientData(SWIGTYPE_p_wxRegionIterator, SWIG_NewClientData(obj));
12098 return SWIG_Py_Void();
12099 }
12100
12101 SWIGINTERN PyObject *RegionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 return SWIG_Python_InitShadowInstance(args);
12103 }
12104
12105 SWIGINTERN PyObject *_wrap_new_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106 PyObject *resultobj = 0;
12107 wxNativeFontInfo *result = 0 ;
12108
12109 if (!SWIG_Python_UnpackTuple(args,"new_NativeFontInfo",0,0,0)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (wxNativeFontInfo *)new wxNativeFontInfo();
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_NEW | 0 );
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_delete_NativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12124 PyObject *resultobj = 0;
12125 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12126 void *argp1 = 0 ;
12127 int res1 = 0 ;
12128 PyObject *swig_obj[1] ;
12129
12130 if (!args) SWIG_fail;
12131 swig_obj[0] = args;
12132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_DISOWN | 0 );
12133 if (!SWIG_IsOK(res1)) {
12134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeFontInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12135 }
12136 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 delete arg1;
12140
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 resultobj = SWIG_Py_Void();
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 SWIGINTERN PyObject *_wrap_NativeFontInfo_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 PyObject *resultobj = 0;
12153 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12154 void *argp1 = 0 ;
12155 int res1 = 0 ;
12156 PyObject *swig_obj[1] ;
12157
12158 if (!args) SWIG_fail;
12159 swig_obj[0] = args;
12160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12161 if (!SWIG_IsOK(res1)) {
12162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_Init" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12163 }
12164 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 (arg1)->Init();
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 resultobj = SWIG_Py_Void();
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12181 wxFont *arg2 = 0 ;
12182 void *argp1 = 0 ;
12183 int res1 = 0 ;
12184 void *argp2 = 0 ;
12185 int res2 = 0 ;
12186 PyObject * obj0 = 0 ;
12187 PyObject * obj1 = 0 ;
12188 char * kwnames[] = {
12189 (char *) "self",(char *) "font", NULL
12190 };
12191
12192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) SWIG_fail;
12193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12194 if (!SWIG_IsOK(res1)) {
12195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12196 }
12197 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
12199 if (!SWIG_IsOK(res2)) {
12200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
12201 }
12202 if (!argp2) {
12203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NativeFontInfo_InitFromFont" "', expected argument " "2"" of type '" "wxFont const &""'");
12204 }
12205 arg2 = reinterpret_cast< wxFont * >(argp2);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 (arg1)->InitFromFont((wxFont const &)*arg2);
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 resultobj = SWIG_Py_Void();
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12220 PyObject *resultobj = 0;
12221 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12222 int result;
12223 void *argp1 = 0 ;
12224 int res1 = 0 ;
12225 PyObject *swig_obj[1] ;
12226
12227 if (!args) SWIG_fail;
12228 swig_obj[0] = args;
12229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12230 if (!SWIG_IsOK(res1)) {
12231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12232 }
12233 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12234 {
12235 PyThreadState* __tstate = wxPyBeginAllowThreads();
12236 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 resultobj = SWIG_From_int(static_cast< int >(result));
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12248 PyObject *resultobj = 0;
12249 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12250 wxSize result;
12251 void *argp1 = 0 ;
12252 int res1 = 0 ;
12253 PyObject *swig_obj[1] ;
12254
12255 if (!args) SWIG_fail;
12256 swig_obj[0] = args;
12257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12258 if (!SWIG_IsOK(res1)) {
12259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetPixelSize" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12260 }
12261 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12262 {
12263 PyThreadState* __tstate = wxPyBeginAllowThreads();
12264 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
12265 wxPyEndAllowThreads(__tstate);
12266 if (PyErr_Occurred()) SWIG_fail;
12267 }
12268 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12276 PyObject *resultobj = 0;
12277 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12278 wxFontStyle result;
12279 void *argp1 = 0 ;
12280 int res1 = 0 ;
12281 PyObject *swig_obj[1] ;
12282
12283 if (!args) SWIG_fail;
12284 swig_obj[0] = args;
12285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12286 if (!SWIG_IsOK(res1)) {
12287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12288 }
12289 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_From_int(static_cast< int >(result));
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12304 PyObject *resultobj = 0;
12305 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12306 wxFontWeight result;
12307 void *argp1 = 0 ;
12308 int res1 = 0 ;
12309 PyObject *swig_obj[1] ;
12310
12311 if (!args) SWIG_fail;
12312 swig_obj[0] = args;
12313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12314 if (!SWIG_IsOK(res1)) {
12315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12316 }
12317 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_From_int(static_cast< int >(result));
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12332 PyObject *resultobj = 0;
12333 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12334 bool result;
12335 void *argp1 = 0 ;
12336 int res1 = 0 ;
12337 PyObject *swig_obj[1] ;
12338
12339 if (!args) SWIG_fail;
12340 swig_obj[0] = args;
12341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12342 if (!SWIG_IsOK(res1)) {
12343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12344 }
12345 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 {
12353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12354 }
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362 PyObject *resultobj = 0;
12363 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12364 wxString result;
12365 void *argp1 = 0 ;
12366 int res1 = 0 ;
12367 PyObject *swig_obj[1] ;
12368
12369 if (!args) SWIG_fail;
12370 swig_obj[0] = args;
12371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12372 if (!SWIG_IsOK(res1)) {
12373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12374 }
12375 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 {
12383 #if wxUSE_UNICODE
12384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12385 #else
12386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12387 #endif
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *resultobj = 0;
12397 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12398 wxFontFamily result;
12399 void *argp1 = 0 ;
12400 int res1 = 0 ;
12401 PyObject *swig_obj[1] ;
12402
12403 if (!args) SWIG_fail;
12404 swig_obj[0] = args;
12405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12406 if (!SWIG_IsOK(res1)) {
12407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12408 }
12409 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
12413 wxPyEndAllowThreads(__tstate);
12414 if (PyErr_Occurred()) SWIG_fail;
12415 }
12416 resultobj = SWIG_From_int(static_cast< int >(result));
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 SWIGINTERN PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12424 PyObject *resultobj = 0;
12425 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12426 wxFontEncoding result;
12427 void *argp1 = 0 ;
12428 int res1 = 0 ;
12429 PyObject *swig_obj[1] ;
12430
12431 if (!args) SWIG_fail;
12432 swig_obj[0] = args;
12433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12434 if (!SWIG_IsOK(res1)) {
12435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_GetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12436 }
12437 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 resultobj = SWIG_From_int(static_cast< int >(result));
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj = 0;
12453 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12454 int arg2 ;
12455 void *argp1 = 0 ;
12456 int res1 = 0 ;
12457 int val2 ;
12458 int ecode2 = 0 ;
12459 PyObject * obj0 = 0 ;
12460 PyObject * obj1 = 0 ;
12461 char * kwnames[] = {
12462 (char *) "self",(char *) "pointsize", NULL
12463 };
12464
12465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
12466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12467 if (!SWIG_IsOK(res1)) {
12468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12469 }
12470 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12471 ecode2 = SWIG_AsVal_int(obj1, &val2);
12472 if (!SWIG_IsOK(ecode2)) {
12473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetPointSize" "', expected argument " "2"" of type '" "int""'");
12474 }
12475 arg2 = static_cast< int >(val2);
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 (arg1)->SetPointSize(arg2);
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 resultobj = SWIG_Py_Void();
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj = 0;
12491 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12492 wxSize *arg2 = 0 ;
12493 void *argp1 = 0 ;
12494 int res1 = 0 ;
12495 wxSize temp2 ;
12496 PyObject * obj0 = 0 ;
12497 PyObject * obj1 = 0 ;
12498 char * kwnames[] = {
12499 (char *) "self",(char *) "pixelSize", NULL
12500 };
12501
12502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
12503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12504 if (!SWIG_IsOK(res1)) {
12505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetPixelSize" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12506 }
12507 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12508 {
12509 arg2 = &temp2;
12510 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12511 }
12512 {
12513 PyThreadState* __tstate = wxPyBeginAllowThreads();
12514 (arg1)->SetPixelSize((wxSize const &)*arg2);
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 resultobj = SWIG_Py_Void();
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj = 0;
12527 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12528 wxFontStyle arg2 ;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 int val2 ;
12532 int ecode2 = 0 ;
12533 PyObject * obj0 = 0 ;
12534 PyObject * obj1 = 0 ;
12535 char * kwnames[] = {
12536 (char *) "self",(char *) "style", NULL
12537 };
12538
12539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
12540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12541 if (!SWIG_IsOK(res1)) {
12542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12543 }
12544 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12545 ecode2 = SWIG_AsVal_int(obj1, &val2);
12546 if (!SWIG_IsOK(ecode2)) {
12547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetStyle" "', expected argument " "2"" of type '" "wxFontStyle""'");
12548 }
12549 arg2 = static_cast< wxFontStyle >(val2);
12550 {
12551 PyThreadState* __tstate = wxPyBeginAllowThreads();
12552 (arg1)->SetStyle(arg2);
12553 wxPyEndAllowThreads(__tstate);
12554 if (PyErr_Occurred()) SWIG_fail;
12555 }
12556 resultobj = SWIG_Py_Void();
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12566 wxFontWeight arg2 ;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 int val2 ;
12570 int ecode2 = 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 char * kwnames[] = {
12574 (char *) "self",(char *) "weight", NULL
12575 };
12576
12577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12581 }
12582 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12583 ecode2 = SWIG_AsVal_int(obj1, &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetWeight" "', expected argument " "2"" of type '" "wxFontWeight""'");
12586 }
12587 arg2 = static_cast< wxFontWeight >(val2);
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 (arg1)->SetWeight(arg2);
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 resultobj = SWIG_Py_Void();
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj = 0;
12603 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12604 bool arg2 ;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 bool val2 ;
12608 int ecode2 = 0 ;
12609 PyObject * obj0 = 0 ;
12610 PyObject * obj1 = 0 ;
12611 char * kwnames[] = {
12612 (char *) "self",(char *) "underlined", NULL
12613 };
12614
12615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
12616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12617 if (!SWIG_IsOK(res1)) {
12618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12619 }
12620 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12621 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12622 if (!SWIG_IsOK(ecode2)) {
12623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
12624 }
12625 arg2 = static_cast< bool >(val2);
12626 {
12627 PyThreadState* __tstate = wxPyBeginAllowThreads();
12628 (arg1)->SetUnderlined(arg2);
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = SWIG_Py_Void();
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12642 wxString arg2 ;
12643 bool result;
12644 void *argp1 = 0 ;
12645 int res1 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 char * kwnames[] = {
12649 (char *) "self",(char *) "facename", NULL
12650 };
12651
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFaceName" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12656 }
12657 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12658 {
12659 wxString* sptr = wxString_in_helper(obj1);
12660 if (sptr == NULL) SWIG_fail;
12661 arg2 = *sptr;
12662 delete sptr;
12663 }
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (bool)(arg1)->SetFaceName(arg2);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12672 }
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj = 0;
12681 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12682 wxFontFamily arg2 ;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 int val2 ;
12686 int ecode2 = 0 ;
12687 PyObject * obj0 = 0 ;
12688 PyObject * obj1 = 0 ;
12689 char * kwnames[] = {
12690 (char *) "self",(char *) "family", NULL
12691 };
12692
12693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12697 }
12698 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12699 ecode2 = SWIG_AsVal_int(obj1, &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetFamily" "', expected argument " "2"" of type '" "wxFontFamily""'");
12702 }
12703 arg2 = static_cast< wxFontFamily >(val2);
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 (arg1)->SetFamily(arg2);
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 resultobj = SWIG_Py_Void();
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 SWIGINTERN PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12718 PyObject *resultobj = 0;
12719 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12720 wxFontEncoding arg2 ;
12721 void *argp1 = 0 ;
12722 int res1 = 0 ;
12723 int val2 ;
12724 int ecode2 = 0 ;
12725 PyObject * obj0 = 0 ;
12726 PyObject * obj1 = 0 ;
12727 char * kwnames[] = {
12728 (char *) "self",(char *) "encoding", NULL
12729 };
12730
12731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
12732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12735 }
12736 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12737 ecode2 = SWIG_AsVal_int(obj1, &val2);
12738 if (!SWIG_IsOK(ecode2)) {
12739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeFontInfo_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
12740 }
12741 arg2 = static_cast< wxFontEncoding >(val2);
12742 {
12743 PyThreadState* __tstate = wxPyBeginAllowThreads();
12744 (arg1)->SetEncoding(arg2);
12745 wxPyEndAllowThreads(__tstate);
12746 if (PyErr_Occurred()) SWIG_fail;
12747 }
12748 resultobj = SWIG_Py_Void();
12749 return resultobj;
12750 fail:
12751 return NULL;
12752 }
12753
12754
12755 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12756 PyObject *resultobj = 0;
12757 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12758 wxString *arg2 = 0 ;
12759 bool result;
12760 void *argp1 = 0 ;
12761 int res1 = 0 ;
12762 bool temp2 = false ;
12763 PyObject * obj0 = 0 ;
12764 PyObject * obj1 = 0 ;
12765 char * kwnames[] = {
12766 (char *) "self",(char *) "s", NULL
12767 };
12768
12769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
12770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12771 if (!SWIG_IsOK(res1)) {
12772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12773 }
12774 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12775 {
12776 arg2 = wxString_in_helper(obj1);
12777 if (arg2 == NULL) SWIG_fail;
12778 temp2 = true;
12779 }
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 result = (bool)(arg1)->FromString((wxString const &)*arg2);
12783 wxPyEndAllowThreads(__tstate);
12784 if (PyErr_Occurred()) SWIG_fail;
12785 }
12786 {
12787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12788 }
12789 {
12790 if (temp2)
12791 delete arg2;
12792 }
12793 return resultobj;
12794 fail:
12795 {
12796 if (temp2)
12797 delete arg2;
12798 }
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804 PyObject *resultobj = 0;
12805 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12806 wxString result;
12807 void *argp1 = 0 ;
12808 int res1 = 0 ;
12809 PyObject *swig_obj[1] ;
12810
12811 if (!args) SWIG_fail;
12812 swig_obj[0] = args;
12813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12814 if (!SWIG_IsOK(res1)) {
12815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12816 }
12817 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = ((wxNativeFontInfo const *)arg1)->ToString();
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 #if wxUSE_UNICODE
12826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12827 #else
12828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12829 #endif
12830 }
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 SWIGINTERN PyObject *_wrap_NativeFontInfo___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12838 PyObject *resultobj = 0;
12839 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12840 wxString result;
12841 void *argp1 = 0 ;
12842 int res1 = 0 ;
12843 PyObject *swig_obj[1] ;
12844
12845 if (!args) SWIG_fail;
12846 swig_obj[0] = args;
12847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12848 if (!SWIG_IsOK(res1)) {
12849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo___str__" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12850 }
12851 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 result = wxNativeFontInfo___str__(arg1);
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 {
12859 #if wxUSE_UNICODE
12860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12861 #else
12862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12863 #endif
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 SWIGINTERN PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj = 0;
12873 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12874 wxString *arg2 = 0 ;
12875 bool result;
12876 void *argp1 = 0 ;
12877 int res1 = 0 ;
12878 bool temp2 = false ;
12879 PyObject * obj0 = 0 ;
12880 PyObject * obj1 = 0 ;
12881 char * kwnames[] = {
12882 (char *) "self",(char *) "s", NULL
12883 };
12884
12885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) SWIG_fail;
12886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12887 if (!SWIG_IsOK(res1)) {
12888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_FromUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo *""'");
12889 }
12890 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12891 {
12892 arg2 = wxString_in_helper(obj1);
12893 if (arg2 == NULL) SWIG_fail;
12894 temp2 = true;
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 {
12903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12904 }
12905 {
12906 if (temp2)
12907 delete arg2;
12908 }
12909 return resultobj;
12910 fail:
12911 {
12912 if (temp2)
12913 delete arg2;
12914 }
12915 return NULL;
12916 }
12917
12918
12919 SWIGINTERN PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *resultobj = 0;
12921 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
12922 wxString result;
12923 void *argp1 = 0 ;
12924 int res1 = 0 ;
12925 PyObject *swig_obj[1] ;
12926
12927 if (!args) SWIG_fail;
12928 swig_obj[0] = args;
12929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
12930 if (!SWIG_IsOK(res1)) {
12931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeFontInfo_ToUserString" "', expected argument " "1"" of type '" "wxNativeFontInfo const *""'");
12932 }
12933 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
12934 {
12935 PyThreadState* __tstate = wxPyBeginAllowThreads();
12936 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 {
12941 #if wxUSE_UNICODE
12942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12943 #else
12944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12945 #endif
12946 }
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 SWIGINTERN PyObject *NativeFontInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12954 PyObject *obj;
12955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12956 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeFontInfo, SWIG_NewClientData(obj));
12957 return SWIG_Py_Void();
12958 }
12959
12960 SWIGINTERN PyObject *NativeFontInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 return SWIG_Python_InitShadowInstance(args);
12962 }
12963
12964 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
12967 wxString *arg2 = (wxString *) 0 ;
12968 void *argp1 = 0 ;
12969 int res1 = 0 ;
12970 bool temp2 = false ;
12971 PyObject *swig_obj[2] ;
12972
12973 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_facename_set",2,2,swig_obj)) SWIG_fail;
12974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
12975 if (!SWIG_IsOK(res1)) {
12976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
12977 }
12978 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
12979 {
12980 arg2 = wxString_in_helper(swig_obj[1]);
12981 if (arg2 == NULL) SWIG_fail;
12982 temp2 = true;
12983 }
12984 if (arg1) (arg1)->facename = *arg2;
12985
12986 resultobj = SWIG_Py_Void();
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *resultobj = 0;
13003 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13004 wxString *result = 0 ;
13005 void *argp1 = 0 ;
13006 int res1 = 0 ;
13007 PyObject *swig_obj[1] ;
13008
13009 if (!args) SWIG_fail;
13010 swig_obj[0] = args;
13011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_facename_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
13014 }
13015 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13016 result = (wxString *)& ((arg1)->facename);
13017 {
13018 #if wxUSE_UNICODE
13019 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13020 #else
13021 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13022 #endif
13023 }
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13033 wxFontEncoding arg2 ;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 int val2 ;
13037 int ecode2 = 0 ;
13038 PyObject *swig_obj[2] ;
13039
13040 if (!SWIG_Python_UnpackTuple(args,"NativeEncodingInfo_encoding_set",2,2,swig_obj)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
13044 }
13045 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13046 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13047 if (!SWIG_IsOK(ecode2)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NativeEncodingInfo_encoding_set" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13049 }
13050 arg2 = static_cast< wxFontEncoding >(val2);
13051 if (arg1) (arg1)->encoding = arg2;
13052
13053 resultobj = SWIG_Py_Void();
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13063 wxFontEncoding result;
13064 void *argp1 = 0 ;
13065 int res1 = 0 ;
13066 PyObject *swig_obj[1] ;
13067
13068 if (!args) SWIG_fail;
13069 swig_obj[0] = args;
13070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13071 if (!SWIG_IsOK(res1)) {
13072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_encoding_get" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
13073 }
13074 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13075 result = (wxFontEncoding) ((arg1)->encoding);
13076 resultobj = SWIG_From_int(static_cast< int >(result));
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_new_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxNativeEncodingInfo *result = 0 ;
13086
13087 if (!SWIG_Python_UnpackTuple(args,"new_NativeEncodingInfo",0,0,0)) SWIG_fail;
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_NEW | 0 );
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_delete_NativeEncodingInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *resultobj = 0;
13103 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13104 void *argp1 = 0 ;
13105 int res1 = 0 ;
13106 PyObject *swig_obj[1] ;
13107
13108 if (!args) SWIG_fail;
13109 swig_obj[0] = args;
13110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_DISOWN | 0 );
13111 if (!SWIG_IsOK(res1)) {
13112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NativeEncodingInfo" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
13113 }
13114 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 delete arg1;
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_Py_Void();
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj = 0;
13131 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13132 wxString *arg2 = 0 ;
13133 bool result;
13134 void *argp1 = 0 ;
13135 int res1 = 0 ;
13136 bool temp2 = false ;
13137 PyObject * obj0 = 0 ;
13138 PyObject * obj1 = 0 ;
13139 char * kwnames[] = {
13140 (char *) "self",(char *) "s", NULL
13141 };
13142
13143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
13144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13145 if (!SWIG_IsOK(res1)) {
13146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_FromString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo *""'");
13147 }
13148 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13149 {
13150 arg2 = wxString_in_helper(obj1);
13151 if (arg2 == NULL) SWIG_fail;
13152 temp2 = true;
13153 }
13154 {
13155 PyThreadState* __tstate = wxPyBeginAllowThreads();
13156 result = (bool)(arg1)->FromString((wxString const &)*arg2);
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 {
13161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13162 }
13163 {
13164 if (temp2)
13165 delete arg2;
13166 }
13167 return resultobj;
13168 fail:
13169 {
13170 if (temp2)
13171 delete arg2;
13172 }
13173 return NULL;
13174 }
13175
13176
13177 SWIGINTERN PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13178 PyObject *resultobj = 0;
13179 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
13180 wxString result;
13181 void *argp1 = 0 ;
13182 int res1 = 0 ;
13183 PyObject *swig_obj[1] ;
13184
13185 if (!args) SWIG_fail;
13186 swig_obj[0] = args;
13187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13188 if (!SWIG_IsOK(res1)) {
13189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NativeEncodingInfo_ToString" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const *""'");
13190 }
13191 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13192 {
13193 PyThreadState* __tstate = wxPyBeginAllowThreads();
13194 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 {
13199 #if wxUSE_UNICODE
13200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13201 #else
13202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13203 #endif
13204 }
13205 return resultobj;
13206 fail:
13207 return NULL;
13208 }
13209
13210
13211 SWIGINTERN PyObject *NativeEncodingInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13212 PyObject *obj;
13213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13214 SWIG_TypeNewClientData(SWIGTYPE_p_wxNativeEncodingInfo, SWIG_NewClientData(obj));
13215 return SWIG_Py_Void();
13216 }
13217
13218 SWIGINTERN PyObject *NativeEncodingInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13219 return SWIG_Python_InitShadowInstance(args);
13220 }
13221
13222 SWIGINTERN PyObject *_wrap_GetNativeFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13223 PyObject *resultobj = 0;
13224 wxFontEncoding arg1 ;
13225 wxNativeEncodingInfo *result = 0 ;
13226 int val1 ;
13227 int ecode1 = 0 ;
13228 PyObject * obj0 = 0 ;
13229 char * kwnames[] = {
13230 (char *) "encoding", NULL
13231 };
13232
13233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) SWIG_fail;
13234 ecode1 = SWIG_AsVal_int(obj0, &val1);
13235 if (!SWIG_IsOK(ecode1)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetNativeFontEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
13237 }
13238 arg1 = static_cast< wxFontEncoding >(val1);
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding(arg1);
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0 );
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_TestFontEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj = 0;
13254 wxNativeEncodingInfo *arg1 = 0 ;
13255 bool result;
13256 void *argp1 = 0 ;
13257 int res1 = 0 ;
13258 PyObject * obj0 = 0 ;
13259 char * kwnames[] = {
13260 (char *) "info", NULL
13261 };
13262
13263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) SWIG_fail;
13264 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeEncodingInfo, 0 | 0);
13265 if (!SWIG_IsOK(res1)) {
13266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
13267 }
13268 if (!argp1) {
13269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TestFontEncoding" "', expected argument " "1"" of type '" "wxNativeEncodingInfo const &""'");
13270 }
13271 arg1 = reinterpret_cast< wxNativeEncodingInfo * >(argp1);
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13280 }
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 SWIGINTERN PyObject *_wrap_new_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13288 PyObject *resultobj = 0;
13289 wxFontMapper *result = 0 ;
13290
13291 if (!SWIG_Python_UnpackTuple(args,"new_FontMapper",0,0,0)) SWIG_fail;
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (wxFontMapper *)new wxFontMapper();
13295 wxPyEndAllowThreads(__tstate);
13296 if (PyErr_Occurred()) SWIG_fail;
13297 }
13298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, SWIG_POINTER_NEW | 0 );
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_delete_FontMapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306 PyObject *resultobj = 0;
13307 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 PyObject *swig_obj[1] ;
13311
13312 if (!args) SWIG_fail;
13313 swig_obj[0] = args;
13314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFontMapper, SWIG_POINTER_DISOWN | 0 );
13315 if (!SWIG_IsOK(res1)) {
13316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontMapper" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13317 }
13318 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 delete arg1;
13322
13323 wxPyEndAllowThreads(__tstate);
13324 if (PyErr_Occurred()) SWIG_fail;
13325 }
13326 resultobj = SWIG_Py_Void();
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 SWIGINTERN PyObject *_wrap_FontMapper_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13334 PyObject *resultobj = 0;
13335 wxFontMapper *result = 0 ;
13336
13337 if (!SWIG_Python_UnpackTuple(args,"FontMapper_Get",0,0,0)) SWIG_fail;
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = (wxFontMapper *)wxFontMapper::Get();
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_FontMapper_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13354 wxFontMapper *result = 0 ;
13355 void *argp1 = 0 ;
13356 int res1 = 0 ;
13357 PyObject * obj0 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "mapper", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) SWIG_fail;
13363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_Set" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13366 }
13367 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 result = (wxFontMapper *)wxFontMapper::Set(arg1);
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontMapper, 0 | 0 );
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 SWIGINTERN PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj = 0;
13383 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13384 wxString *arg2 = 0 ;
13385 bool arg3 = (bool) true ;
13386 wxFontEncoding result;
13387 void *argp1 = 0 ;
13388 int res1 = 0 ;
13389 bool temp2 = false ;
13390 bool val3 ;
13391 int ecode3 = 0 ;
13392 PyObject * obj0 = 0 ;
13393 PyObject * obj1 = 0 ;
13394 PyObject * obj2 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "charset",(char *) "interactive", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13403 }
13404 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13405 {
13406 arg2 = wxString_in_helper(obj1);
13407 if (arg2 == NULL) SWIG_fail;
13408 temp2 = true;
13409 }
13410 if (obj2) {
13411 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13412 if (!SWIG_IsOK(ecode3)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontMapper_CharsetToEncoding" "', expected argument " "3"" of type '" "bool""'");
13414 }
13415 arg3 = static_cast< bool >(val3);
13416 }
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
13420 wxPyEndAllowThreads(__tstate);
13421 if (PyErr_Occurred()) SWIG_fail;
13422 }
13423 resultobj = SWIG_From_int(static_cast< int >(result));
13424 {
13425 if (temp2)
13426 delete arg2;
13427 }
13428 return resultobj;
13429 fail:
13430 {
13431 if (temp2)
13432 delete arg2;
13433 }
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 size_t result;
13441
13442 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetSupportedEncodingsCount",0,0,0)) SWIG_fail;
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13450 return resultobj;
13451 fail:
13452 return NULL;
13453 }
13454
13455
13456 SWIGINTERN PyObject *_wrap_FontMapper_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13457 PyObject *resultobj = 0;
13458 size_t arg1 ;
13459 wxFontEncoding result;
13460 size_t val1 ;
13461 int ecode1 = 0 ;
13462 PyObject * obj0 = 0 ;
13463 char * kwnames[] = {
13464 (char *) "n", NULL
13465 };
13466
13467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) SWIG_fail;
13468 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13469 if (!SWIG_IsOK(ecode1)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncoding" "', expected argument " "1"" of type '" "size_t""'");
13471 }
13472 arg1 = static_cast< size_t >(val1);
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 resultobj = SWIG_From_int(static_cast< int >(result));
13480 return resultobj;
13481 fail:
13482 return NULL;
13483 }
13484
13485
13486 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13487 PyObject *resultobj = 0;
13488 wxFontEncoding arg1 ;
13489 wxString result;
13490 int val1 ;
13491 int ecode1 = 0 ;
13492 PyObject * obj0 = 0 ;
13493 char * kwnames[] = {
13494 (char *) "encoding", NULL
13495 };
13496
13497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) SWIG_fail;
13498 ecode1 = SWIG_AsVal_int(obj0, &val1);
13499 if (!SWIG_IsOK(ecode1)) {
13500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingName" "', expected argument " "1"" of type '" "wxFontEncoding""'");
13501 }
13502 arg1 = static_cast< wxFontEncoding >(val1);
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = wxFontMapper::GetEncodingName(arg1);
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 {
13510 #if wxUSE_UNICODE
13511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13512 #else
13513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13514 #endif
13515 }
13516 return resultobj;
13517 fail:
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj = 0;
13524 wxFontEncoding arg1 ;
13525 wxString result;
13526 int val1 ;
13527 int ecode1 = 0 ;
13528 PyObject * obj0 = 0 ;
13529 char * kwnames[] = {
13530 (char *) "encoding", NULL
13531 };
13532
13533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) SWIG_fail;
13534 ecode1 = SWIG_AsVal_int(obj0, &val1);
13535 if (!SWIG_IsOK(ecode1)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FontMapper_GetEncodingDescription" "', expected argument " "1"" of type '" "wxFontEncoding""'");
13537 }
13538 arg1 = static_cast< wxFontEncoding >(val1);
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = wxFontMapper::GetEncodingDescription(arg1);
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 {
13546 #if wxUSE_UNICODE
13547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13548 #else
13549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13550 #endif
13551 }
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxString *arg1 = 0 ;
13561 wxFontEncoding result;
13562 bool temp1 = false ;
13563 PyObject * obj0 = 0 ;
13564 char * kwnames[] = {
13565 (char *) "name", NULL
13566 };
13567
13568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) SWIG_fail;
13569 {
13570 arg1 = wxString_in_helper(obj0);
13571 if (arg1 == NULL) SWIG_fail;
13572 temp1 = true;
13573 }
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 resultobj = SWIG_From_int(static_cast< int >(result));
13581 {
13582 if (temp1)
13583 delete arg1;
13584 }
13585 return resultobj;
13586 fail:
13587 {
13588 if (temp1)
13589 delete arg1;
13590 }
13591 return NULL;
13592 }
13593
13594
13595 SWIGINTERN PyObject *_wrap_FontMapper_SetConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj = 0;
13597 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13598 wxString *arg2 = 0 ;
13599 void *argp1 = 0 ;
13600 int res1 = 0 ;
13601 bool temp2 = false ;
13602 PyObject * obj0 = 0 ;
13603 PyObject * obj1 = 0 ;
13604 char * kwnames[] = {
13605 (char *) "self",(char *) "prefix", NULL
13606 };
13607
13608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) SWIG_fail;
13609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13610 if (!SWIG_IsOK(res1)) {
13611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetConfigPath" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13612 }
13613 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13614 {
13615 arg2 = wxString_in_helper(obj1);
13616 if (arg2 == NULL) SWIG_fail;
13617 temp2 = true;
13618 }
13619 {
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 (arg1)->SetConfigPath((wxString const &)*arg2);
13622 wxPyEndAllowThreads(__tstate);
13623 if (PyErr_Occurred()) SWIG_fail;
13624 }
13625 resultobj = SWIG_Py_Void();
13626 {
13627 if (temp2)
13628 delete arg2;
13629 }
13630 return resultobj;
13631 fail:
13632 {
13633 if (temp2)
13634 delete arg2;
13635 }
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13641 PyObject *resultobj = 0;
13642 wxString result;
13643
13644 if (!SWIG_Python_UnpackTuple(args,"FontMapper_GetDefaultConfigPath",0,0,0)) SWIG_fail;
13645 {
13646 PyThreadState* __tstate = wxPyBeginAllowThreads();
13647 result = wxFontMapper::GetDefaultConfigPath();
13648 wxPyEndAllowThreads(__tstate);
13649 if (PyErr_Occurred()) SWIG_fail;
13650 }
13651 {
13652 #if wxUSE_UNICODE
13653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13654 #else
13655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13656 #endif
13657 }
13658 return resultobj;
13659 fail:
13660 return NULL;
13661 }
13662
13663
13664 SWIGINTERN PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13665 PyObject *resultobj = 0;
13666 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13667 wxFontEncoding arg2 ;
13668 wxString const &arg3_defvalue = wxPyEmptyString ;
13669 wxString *arg3 = (wxString *) &arg3_defvalue ;
13670 bool arg4 = (bool) true ;
13671 PyObject *result = 0 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 int val2 ;
13675 int ecode2 = 0 ;
13676 bool temp3 = false ;
13677 bool val4 ;
13678 int ecode4 = 0 ;
13679 PyObject * obj0 = 0 ;
13680 PyObject * obj1 = 0 ;
13681 PyObject * obj2 = 0 ;
13682 PyObject * obj3 = 0 ;
13683 char * kwnames[] = {
13684 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
13685 };
13686
13687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13689 if (!SWIG_IsOK(res1)) {
13690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13691 }
13692 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13693 ecode2 = SWIG_AsVal_int(obj1, &val2);
13694 if (!SWIG_IsOK(ecode2)) {
13695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13696 }
13697 arg2 = static_cast< wxFontEncoding >(val2);
13698 if (obj2) {
13699 {
13700 arg3 = wxString_in_helper(obj2);
13701 if (arg3 == NULL) SWIG_fail;
13702 temp3 = true;
13703 }
13704 }
13705 if (obj3) {
13706 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13707 if (!SWIG_IsOK(ecode4)) {
13708 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontMapper_GetAltForEncoding" "', expected argument " "4"" of type '" "bool""'");
13709 }
13710 arg4 = static_cast< bool >(val4);
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,arg2,(wxString const &)*arg3,arg4);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = result;
13719 {
13720 if (temp3)
13721 delete arg3;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp3)
13727 delete arg3;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13736 wxFontEncoding arg2 ;
13737 wxString const &arg3_defvalue = wxPyEmptyString ;
13738 wxString *arg3 = (wxString *) &arg3_defvalue ;
13739 bool result;
13740 void *argp1 = 0 ;
13741 int res1 = 0 ;
13742 int val2 ;
13743 int ecode2 = 0 ;
13744 bool temp3 = false ;
13745 PyObject * obj0 = 0 ;
13746 PyObject * obj1 = 0 ;
13747 PyObject * obj2 = 0 ;
13748 char * kwnames[] = {
13749 (char *) "self",(char *) "encoding",(char *) "facename", NULL
13750 };
13751
13752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13754 if (!SWIG_IsOK(res1)) {
13755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13756 }
13757 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13758 ecode2 = SWIG_AsVal_int(obj1, &val2);
13759 if (!SWIG_IsOK(ecode2)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontMapper_IsEncodingAvailable" "', expected argument " "2"" of type '" "wxFontEncoding""'");
13761 }
13762 arg2 = static_cast< wxFontEncoding >(val2);
13763 if (obj2) {
13764 {
13765 arg3 = wxString_in_helper(obj2);
13766 if (arg3 == NULL) SWIG_fail;
13767 temp3 = true;
13768 }
13769 }
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 result = (bool)(arg1)->IsEncodingAvailable(arg2,(wxString const &)*arg3);
13773 wxPyEndAllowThreads(__tstate);
13774 if (PyErr_Occurred()) SWIG_fail;
13775 }
13776 {
13777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13778 }
13779 {
13780 if (temp3)
13781 delete arg3;
13782 }
13783 return resultobj;
13784 fail:
13785 {
13786 if (temp3)
13787 delete arg3;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13796 wxWindow *arg2 = (wxWindow *) 0 ;
13797 void *argp1 = 0 ;
13798 int res1 = 0 ;
13799 void *argp2 = 0 ;
13800 int res2 = 0 ;
13801 PyObject * obj0 = 0 ;
13802 PyObject * obj1 = 0 ;
13803 char * kwnames[] = {
13804 (char *) "self",(char *) "parent", NULL
13805 };
13806
13807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) SWIG_fail;
13808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13809 if (!SWIG_IsOK(res1)) {
13810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogParent" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13811 }
13812 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
13814 if (!SWIG_IsOK(res2)) {
13815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontMapper_SetDialogParent" "', expected argument " "2"" of type '" "wxWindow *""'");
13816 }
13817 arg2 = reinterpret_cast< wxWindow * >(argp2);
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 (arg1)->SetDialogParent(arg2);
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 resultobj = SWIG_Py_Void();
13825 return resultobj;
13826 fail:
13827 return NULL;
13828 }
13829
13830
13831 SWIGINTERN PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13832 PyObject *resultobj = 0;
13833 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
13834 wxString *arg2 = 0 ;
13835 void *argp1 = 0 ;
13836 int res1 = 0 ;
13837 bool temp2 = false ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "self",(char *) "title", NULL
13842 };
13843
13844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) SWIG_fail;
13845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontMapper, 0 | 0 );
13846 if (!SWIG_IsOK(res1)) {
13847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontMapper_SetDialogTitle" "', expected argument " "1"" of type '" "wxFontMapper *""'");
13848 }
13849 arg1 = reinterpret_cast< wxFontMapper * >(argp1);
13850 {
13851 arg2 = wxString_in_helper(obj1);
13852 if (arg2 == NULL) SWIG_fail;
13853 temp2 = true;
13854 }
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 (arg1)->SetDialogTitle((wxString const &)*arg2);
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_Py_Void();
13862 {
13863 if (temp2)
13864 delete arg2;
13865 }
13866 return resultobj;
13867 fail:
13868 {
13869 if (temp2)
13870 delete arg2;
13871 }
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *FontMapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13877 PyObject *obj;
13878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13879 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontMapper, SWIG_NewClientData(obj));
13880 return SWIG_Py_Void();
13881 }
13882
13883 SWIGINTERN PyObject *FontMapper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13884 return SWIG_Python_InitShadowInstance(args);
13885 }
13886
13887 SWIGINTERN PyObject *_wrap_new_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj = 0;
13889 int arg1 ;
13890 int arg2 ;
13891 int arg3 ;
13892 int arg4 ;
13893 bool arg5 = (bool) false ;
13894 wxString const &arg6_defvalue = wxPyEmptyString ;
13895 wxString *arg6 = (wxString *) &arg6_defvalue ;
13896 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
13897 wxFont *result = 0 ;
13898 int val1 ;
13899 int ecode1 = 0 ;
13900 int val2 ;
13901 int ecode2 = 0 ;
13902 int val3 ;
13903 int ecode3 = 0 ;
13904 int val4 ;
13905 int ecode4 = 0 ;
13906 bool val5 ;
13907 int ecode5 = 0 ;
13908 bool temp6 = false ;
13909 int val7 ;
13910 int ecode7 = 0 ;
13911 PyObject * obj0 = 0 ;
13912 PyObject * obj1 = 0 ;
13913 PyObject * obj2 = 0 ;
13914 PyObject * obj3 = 0 ;
13915 PyObject * obj4 = 0 ;
13916 PyObject * obj5 = 0 ;
13917 PyObject * obj6 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
13923 ecode1 = SWIG_AsVal_int(obj0, &val1);
13924 if (!SWIG_IsOK(ecode1)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Font" "', expected argument " "1"" of type '" "int""'");
13926 }
13927 arg1 = static_cast< int >(val1);
13928 ecode2 = SWIG_AsVal_int(obj1, &val2);
13929 if (!SWIG_IsOK(ecode2)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Font" "', expected argument " "2"" of type '" "int""'");
13931 }
13932 arg2 = static_cast< int >(val2);
13933 ecode3 = SWIG_AsVal_int(obj2, &val3);
13934 if (!SWIG_IsOK(ecode3)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Font" "', expected argument " "3"" of type '" "int""'");
13936 }
13937 arg3 = static_cast< int >(val3);
13938 ecode4 = SWIG_AsVal_int(obj3, &val4);
13939 if (!SWIG_IsOK(ecode4)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Font" "', expected argument " "4"" of type '" "int""'");
13941 }
13942 arg4 = static_cast< int >(val4);
13943 if (obj4) {
13944 ecode5 = SWIG_AsVal_bool(obj4, &val5);
13945 if (!SWIG_IsOK(ecode5)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Font" "', expected argument " "5"" of type '" "bool""'");
13947 }
13948 arg5 = static_cast< bool >(val5);
13949 }
13950 if (obj5) {
13951 {
13952 arg6 = wxString_in_helper(obj5);
13953 if (arg6 == NULL) SWIG_fail;
13954 temp6 = true;
13955 }
13956 }
13957 if (obj6) {
13958 ecode7 = SWIG_AsVal_int(obj6, &val7);
13959 if (!SWIG_IsOK(ecode7)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Font" "', expected argument " "7"" of type '" "wxFontEncoding""'");
13961 }
13962 arg7 = static_cast< wxFontEncoding >(val7);
13963 }
13964 {
13965 if (!wxPyCheckForApp()) SWIG_fail;
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_NEW | 0 );
13972 {
13973 if (temp6)
13974 delete arg6;
13975 }
13976 return resultobj;
13977 fail:
13978 {
13979 if (temp6)
13980 delete arg6;
13981 }
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_delete_Font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13987 PyObject *resultobj = 0;
13988 wxFont *arg1 = (wxFont *) 0 ;
13989 void *argp1 = 0 ;
13990 int res1 = 0 ;
13991 PyObject *swig_obj[1] ;
13992
13993 if (!args) SWIG_fail;
13994 swig_obj[0] = args;
13995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, SWIG_POINTER_DISOWN | 0 );
13996 if (!SWIG_IsOK(res1)) {
13997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Font" "', expected argument " "1"" of type '" "wxFont *""'");
13998 }
13999 arg1 = reinterpret_cast< wxFont * >(argp1);
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 delete arg1;
14003
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 resultobj = SWIG_Py_Void();
14008 return resultobj;
14009 fail:
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14015 PyObject *resultobj = 0;
14016 wxNativeFontInfo *arg1 = 0 ;
14017 wxFont *result = 0 ;
14018 void *argp1 = 0 ;
14019 int res1 = 0 ;
14020 PyObject * obj0 = 0 ;
14021 char * kwnames[] = {
14022 (char *) "info", NULL
14023 };
14024
14025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) SWIG_fail;
14026 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
14029 }
14030 if (!argp1) {
14031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FontFromNativeInfo" "', expected argument " "1"" of type '" "wxNativeFontInfo const &""'");
14032 }
14033 arg1 = reinterpret_cast< wxNativeFontInfo * >(argp1);
14034 {
14035 if (!wxPyCheckForApp()) SWIG_fail;
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
14038 wxPyEndAllowThreads(__tstate);
14039 if (PyErr_Occurred()) SWIG_fail;
14040 }
14041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 SWIGINTERN PyObject *_wrap_new_FontFromNativeInfoString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj = 0;
14050 wxString *arg1 = 0 ;
14051 wxFont *result = 0 ;
14052 bool temp1 = false ;
14053 PyObject * obj0 = 0 ;
14054 char * kwnames[] = {
14055 (char *) "info", NULL
14056 };
14057
14058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) SWIG_fail;
14059 {
14060 arg1 = wxString_in_helper(obj0);
14061 if (arg1 == NULL) SWIG_fail;
14062 temp1 = true;
14063 }
14064 {
14065 if (!wxPyCheckForApp()) SWIG_fail;
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 result = (wxFont *)new_wxFont((wxString const &)*arg1);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14072 {
14073 if (temp1)
14074 delete arg1;
14075 }
14076 return resultobj;
14077 fail:
14078 {
14079 if (temp1)
14080 delete arg1;
14081 }
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_new_FFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj = 0;
14088 int arg1 ;
14089 wxFontFamily arg2 ;
14090 int arg3 = (int) wxFONTFLAG_DEFAULT ;
14091 wxString const &arg4_defvalue = wxPyEmptyString ;
14092 wxString *arg4 = (wxString *) &arg4_defvalue ;
14093 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
14094 wxFont *result = 0 ;
14095 int val1 ;
14096 int ecode1 = 0 ;
14097 int val2 ;
14098 int ecode2 = 0 ;
14099 int val3 ;
14100 int ecode3 = 0 ;
14101 bool temp4 = false ;
14102 int val5 ;
14103 int ecode5 = 0 ;
14104 PyObject * obj0 = 0 ;
14105 PyObject * obj1 = 0 ;
14106 PyObject * obj2 = 0 ;
14107 PyObject * obj3 = 0 ;
14108 PyObject * obj4 = 0 ;
14109 char * kwnames[] = {
14110 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
14111 };
14112
14113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14114 ecode1 = SWIG_AsVal_int(obj0, &val1);
14115 if (!SWIG_IsOK(ecode1)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FFont" "', expected argument " "1"" of type '" "int""'");
14117 }
14118 arg1 = static_cast< int >(val1);
14119 ecode2 = SWIG_AsVal_int(obj1, &val2);
14120 if (!SWIG_IsOK(ecode2)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFont" "', expected argument " "2"" of type '" "wxFontFamily""'");
14122 }
14123 arg2 = static_cast< wxFontFamily >(val2);
14124 if (obj2) {
14125 ecode3 = SWIG_AsVal_int(obj2, &val3);
14126 if (!SWIG_IsOK(ecode3)) {
14127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFont" "', expected argument " "3"" of type '" "int""'");
14128 }
14129 arg3 = static_cast< int >(val3);
14130 }
14131 if (obj3) {
14132 {
14133 arg4 = wxString_in_helper(obj3);
14134 if (arg4 == NULL) SWIG_fail;
14135 temp4 = true;
14136 }
14137 }
14138 if (obj4) {
14139 ecode5 = SWIG_AsVal_int(obj4, &val5);
14140 if (!SWIG_IsOK(ecode5)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFont" "', expected argument " "5"" of type '" "wxFontEncoding""'");
14142 }
14143 arg5 = static_cast< wxFontEncoding >(val5);
14144 }
14145 {
14146 if (!wxPyCheckForApp()) SWIG_fail;
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (wxFont *)new_wxFont(arg1,arg2,arg3,(wxString const &)*arg4,arg5);
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14153 {
14154 if (temp4)
14155 delete arg4;
14156 }
14157 return resultobj;
14158 fail:
14159 {
14160 if (temp4)
14161 delete arg4;
14162 }
14163 return NULL;
14164 }
14165
14166
14167 SWIGINTERN PyObject *_wrap_new_FontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14168 PyObject *resultobj = 0;
14169 wxSize *arg1 = 0 ;
14170 int arg2 ;
14171 int arg3 ;
14172 int arg4 ;
14173 bool arg5 = (bool) false ;
14174 wxString const &arg6_defvalue = wxEmptyString ;
14175 wxString *arg6 = (wxString *) &arg6_defvalue ;
14176 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
14177 wxFont *result = 0 ;
14178 wxSize temp1 ;
14179 int val2 ;
14180 int ecode2 = 0 ;
14181 int val3 ;
14182 int ecode3 = 0 ;
14183 int val4 ;
14184 int ecode4 = 0 ;
14185 bool val5 ;
14186 int ecode5 = 0 ;
14187 bool temp6 = false ;
14188 int val7 ;
14189 int ecode7 = 0 ;
14190 PyObject * obj0 = 0 ;
14191 PyObject * obj1 = 0 ;
14192 PyObject * obj2 = 0 ;
14193 PyObject * obj3 = 0 ;
14194 PyObject * obj4 = 0 ;
14195 PyObject * obj5 = 0 ;
14196 PyObject * obj6 = 0 ;
14197 char * kwnames[] = {
14198 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
14199 };
14200
14201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14202 {
14203 arg1 = &temp1;
14204 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
14205 }
14206 ecode2 = SWIG_AsVal_int(obj1, &val2);
14207 if (!SWIG_IsOK(ecode2)) {
14208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FontFromPixelSize" "', expected argument " "2"" of type '" "int""'");
14209 }
14210 arg2 = static_cast< int >(val2);
14211 ecode3 = SWIG_AsVal_int(obj2, &val3);
14212 if (!SWIG_IsOK(ecode3)) {
14213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
14214 }
14215 arg3 = static_cast< int >(val3);
14216 ecode4 = SWIG_AsVal_int(obj3, &val4);
14217 if (!SWIG_IsOK(ecode4)) {
14218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FontFromPixelSize" "', expected argument " "4"" of type '" "int""'");
14219 }
14220 arg4 = static_cast< int >(val4);
14221 if (obj4) {
14222 ecode5 = SWIG_AsVal_bool(obj4, &val5);
14223 if (!SWIG_IsOK(ecode5)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FontFromPixelSize" "', expected argument " "5"" of type '" "bool""'");
14225 }
14226 arg5 = static_cast< bool >(val5);
14227 }
14228 if (obj5) {
14229 {
14230 arg6 = wxString_in_helper(obj5);
14231 if (arg6 == NULL) SWIG_fail;
14232 temp6 = true;
14233 }
14234 }
14235 if (obj6) {
14236 ecode7 = SWIG_AsVal_int(obj6, &val7);
14237 if (!SWIG_IsOK(ecode7)) {
14238 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FontFromPixelSize" "', expected argument " "7"" of type '" "wxFontEncoding""'");
14239 }
14240 arg7 = static_cast< wxFontEncoding >(val7);
14241 }
14242 {
14243 if (!wxPyCheckForApp()) SWIG_fail;
14244 PyThreadState* __tstate = wxPyBeginAllowThreads();
14245 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,arg7);
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14250 {
14251 if (temp6)
14252 delete arg6;
14253 }
14254 return resultobj;
14255 fail:
14256 {
14257 if (temp6)
14258 delete arg6;
14259 }
14260 return NULL;
14261 }
14262
14263
14264 SWIGINTERN PyObject *_wrap_new_FFontFromPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14265 PyObject *resultobj = 0;
14266 wxSize *arg1 = 0 ;
14267 wxFontFamily arg2 ;
14268 int arg3 = (int) wxFONTFLAG_DEFAULT ;
14269 wxString const &arg4_defvalue = wxEmptyString ;
14270 wxString *arg4 = (wxString *) &arg4_defvalue ;
14271 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
14272 wxFont *result = 0 ;
14273 wxSize temp1 ;
14274 int val2 ;
14275 int ecode2 = 0 ;
14276 int val3 ;
14277 int ecode3 = 0 ;
14278 bool temp4 = false ;
14279 int val5 ;
14280 int ecode5 = 0 ;
14281 PyObject * obj0 = 0 ;
14282 PyObject * obj1 = 0 ;
14283 PyObject * obj2 = 0 ;
14284 PyObject * obj3 = 0 ;
14285 PyObject * obj4 = 0 ;
14286 char * kwnames[] = {
14287 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
14288 };
14289
14290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14291 {
14292 arg1 = &temp1;
14293 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
14294 }
14295 ecode2 = SWIG_AsVal_int(obj1, &val2);
14296 if (!SWIG_IsOK(ecode2)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFontFromPixelSize" "', expected argument " "2"" of type '" "wxFontFamily""'");
14298 }
14299 arg2 = static_cast< wxFontFamily >(val2);
14300 if (obj2) {
14301 ecode3 = SWIG_AsVal_int(obj2, &val3);
14302 if (!SWIG_IsOK(ecode3)) {
14303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FFontFromPixelSize" "', expected argument " "3"" of type '" "int""'");
14304 }
14305 arg3 = static_cast< int >(val3);
14306 }
14307 if (obj3) {
14308 {
14309 arg4 = wxString_in_helper(obj3);
14310 if (arg4 == NULL) SWIG_fail;
14311 temp4 = true;
14312 }
14313 }
14314 if (obj4) {
14315 ecode5 = SWIG_AsVal_int(obj4, &val5);
14316 if (!SWIG_IsOK(ecode5)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FFontFromPixelSize" "', expected argument " "5"" of type '" "wxFontEncoding""'");
14318 }
14319 arg5 = static_cast< wxFontEncoding >(val5);
14320 }
14321 {
14322 if (!wxPyCheckForApp()) SWIG_fail;
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,(wxString const &)*arg4,arg5);
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14329 {
14330 if (temp4)
14331 delete arg4;
14332 }
14333 return resultobj;
14334 fail:
14335 {
14336 if (temp4)
14337 delete arg4;
14338 }
14339 return NULL;
14340 }
14341
14342
14343 SWIGINTERN PyObject *_wrap_Font_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14344 PyObject *resultobj = 0;
14345 wxFont *arg1 = (wxFont *) 0 ;
14346 bool result;
14347 void *argp1 = 0 ;
14348 int res1 = 0 ;
14349 PyObject *swig_obj[1] ;
14350
14351 if (!args) SWIG_fail;
14352 swig_obj[0] = args;
14353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14354 if (!SWIG_IsOK(res1)) {
14355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_Ok" "', expected argument " "1"" of type '" "wxFont const *""'");
14356 }
14357 arg1 = reinterpret_cast< wxFont * >(argp1);
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (bool)((wxFont const *)arg1)->Ok();
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 {
14365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14366 }
14367 return resultobj;
14368 fail:
14369 return NULL;
14370 }
14371
14372
14373 SWIGINTERN PyObject *_wrap_Font___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj = 0;
14375 wxFont *arg1 = (wxFont *) 0 ;
14376 wxFont *arg2 = (wxFont *) 0 ;
14377 bool result;
14378 void *argp1 = 0 ;
14379 int res1 = 0 ;
14380 void *argp2 = 0 ;
14381 int res2 = 0 ;
14382 PyObject * obj0 = 0 ;
14383 PyObject * obj1 = 0 ;
14384 char * kwnames[] = {
14385 (char *) "self",(char *) "other", NULL
14386 };
14387
14388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
14389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___eq__" "', expected argument " "1"" of type '" "wxFont *""'");
14392 }
14393 arg1 = reinterpret_cast< wxFont * >(argp1);
14394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
14395 if (!SWIG_IsOK(res2)) {
14396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___eq__" "', expected argument " "2"" of type '" "wxFont const *""'");
14397 }
14398 arg2 = reinterpret_cast< wxFont * >(argp2);
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 {
14406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14407 }
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Font___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = 0;
14416 wxFont *arg1 = (wxFont *) 0 ;
14417 wxFont *arg2 = (wxFont *) 0 ;
14418 bool result;
14419 void *argp1 = 0 ;
14420 int res1 = 0 ;
14421 void *argp2 = 0 ;
14422 int res2 = 0 ;
14423 PyObject * obj0 = 0 ;
14424 PyObject * obj1 = 0 ;
14425 char * kwnames[] = {
14426 (char *) "self",(char *) "other", NULL
14427 };
14428
14429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
14430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14431 if (!SWIG_IsOK(res1)) {
14432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font___ne__" "', expected argument " "1"" of type '" "wxFont *""'");
14433 }
14434 arg1 = reinterpret_cast< wxFont * >(argp1);
14435 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
14436 if (!SWIG_IsOK(res2)) {
14437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font___ne__" "', expected argument " "2"" of type '" "wxFont const *""'");
14438 }
14439 arg2 = reinterpret_cast< wxFont * >(argp2);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 {
14447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14448 }
14449 return resultobj;
14450 fail:
14451 return NULL;
14452 }
14453
14454
14455 SWIGINTERN PyObject *_wrap_Font_GetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14456 PyObject *resultobj = 0;
14457 wxFont *arg1 = (wxFont *) 0 ;
14458 int result;
14459 void *argp1 = 0 ;
14460 int res1 = 0 ;
14461 PyObject *swig_obj[1] ;
14462
14463 if (!args) SWIG_fail;
14464 swig_obj[0] = args;
14465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14466 if (!SWIG_IsOK(res1)) {
14467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPointSize" "', expected argument " "1"" of type '" "wxFont const *""'");
14468 }
14469 arg1 = reinterpret_cast< wxFont * >(argp1);
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 result = (int)((wxFont const *)arg1)->GetPointSize();
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = SWIG_From_int(static_cast< int >(result));
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 SWIGINTERN PyObject *_wrap_Font_GetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14484 PyObject *resultobj = 0;
14485 wxFont *arg1 = (wxFont *) 0 ;
14486 wxSize result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 PyObject *swig_obj[1] ;
14490
14491 if (!args) SWIG_fail;
14492 swig_obj[0] = args;
14493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14494 if (!SWIG_IsOK(res1)) {
14495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetPixelSize" "', expected argument " "1"" of type '" "wxFont const *""'");
14496 }
14497 arg1 = reinterpret_cast< wxFont * >(argp1);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = ((wxFont const *)arg1)->GetPixelSize();
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14512 PyObject *resultobj = 0;
14513 wxFont *arg1 = (wxFont *) 0 ;
14514 bool result;
14515 void *argp1 = 0 ;
14516 int res1 = 0 ;
14517 PyObject *swig_obj[1] ;
14518
14519 if (!args) SWIG_fail;
14520 swig_obj[0] = args;
14521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsUsingSizeInPixels" "', expected argument " "1"" of type '" "wxFont const *""'");
14524 }
14525 arg1 = reinterpret_cast< wxFont * >(argp1);
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14534 }
14535 return resultobj;
14536 fail:
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap_Font_GetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14542 PyObject *resultobj = 0;
14543 wxFont *arg1 = (wxFont *) 0 ;
14544 int result;
14545 void *argp1 = 0 ;
14546 int res1 = 0 ;
14547 PyObject *swig_obj[1] ;
14548
14549 if (!args) SWIG_fail;
14550 swig_obj[0] = args;
14551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamily" "', expected argument " "1"" of type '" "wxFont const *""'");
14554 }
14555 arg1 = reinterpret_cast< wxFont * >(argp1);
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 result = (int)((wxFont const *)arg1)->GetFamily();
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_From_int(static_cast< int >(result));
14563 return resultobj;
14564 fail:
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Font_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14570 PyObject *resultobj = 0;
14571 wxFont *arg1 = (wxFont *) 0 ;
14572 int result;
14573 void *argp1 = 0 ;
14574 int res1 = 0 ;
14575 PyObject *swig_obj[1] ;
14576
14577 if (!args) SWIG_fail;
14578 swig_obj[0] = args;
14579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14580 if (!SWIG_IsOK(res1)) {
14581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyle" "', expected argument " "1"" of type '" "wxFont const *""'");
14582 }
14583 arg1 = reinterpret_cast< wxFont * >(argp1);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (int)((wxFont const *)arg1)->GetStyle();
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 resultobj = SWIG_From_int(static_cast< int >(result));
14591 return resultobj;
14592 fail:
14593 return NULL;
14594 }
14595
14596
14597 SWIGINTERN PyObject *_wrap_Font_GetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14598 PyObject *resultobj = 0;
14599 wxFont *arg1 = (wxFont *) 0 ;
14600 int result;
14601 void *argp1 = 0 ;
14602 int res1 = 0 ;
14603 PyObject *swig_obj[1] ;
14604
14605 if (!args) SWIG_fail;
14606 swig_obj[0] = args;
14607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14608 if (!SWIG_IsOK(res1)) {
14609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeight" "', expected argument " "1"" of type '" "wxFont const *""'");
14610 }
14611 arg1 = reinterpret_cast< wxFont * >(argp1);
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (int)((wxFont const *)arg1)->GetWeight();
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 resultobj = SWIG_From_int(static_cast< int >(result));
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Font_GetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14626 PyObject *resultobj = 0;
14627 wxFont *arg1 = (wxFont *) 0 ;
14628 bool result;
14629 void *argp1 = 0 ;
14630 int res1 = 0 ;
14631 PyObject *swig_obj[1] ;
14632
14633 if (!args) SWIG_fail;
14634 swig_obj[0] = args;
14635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetUnderlined" "', expected argument " "1"" of type '" "wxFont const *""'");
14638 }
14639 arg1 = reinterpret_cast< wxFont * >(argp1);
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (bool)((wxFont const *)arg1)->GetUnderlined();
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 {
14647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14648 }
14649 return resultobj;
14650 fail:
14651 return NULL;
14652 }
14653
14654
14655 SWIGINTERN PyObject *_wrap_Font_GetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14656 PyObject *resultobj = 0;
14657 wxFont *arg1 = (wxFont *) 0 ;
14658 wxString result;
14659 void *argp1 = 0 ;
14660 int res1 = 0 ;
14661 PyObject *swig_obj[1] ;
14662
14663 if (!args) SWIG_fail;
14664 swig_obj[0] = args;
14665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFaceName" "', expected argument " "1"" of type '" "wxFont const *""'");
14668 }
14669 arg1 = reinterpret_cast< wxFont * >(argp1);
14670 {
14671 PyThreadState* __tstate = wxPyBeginAllowThreads();
14672 result = ((wxFont const *)arg1)->GetFaceName();
14673 wxPyEndAllowThreads(__tstate);
14674 if (PyErr_Occurred()) SWIG_fail;
14675 }
14676 {
14677 #if wxUSE_UNICODE
14678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14679 #else
14680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14681 #endif
14682 }
14683 return resultobj;
14684 fail:
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_Font_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14690 PyObject *resultobj = 0;
14691 wxFont *arg1 = (wxFont *) 0 ;
14692 wxFontEncoding result;
14693 void *argp1 = 0 ;
14694 int res1 = 0 ;
14695 PyObject *swig_obj[1] ;
14696
14697 if (!args) SWIG_fail;
14698 swig_obj[0] = args;
14699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14700 if (!SWIG_IsOK(res1)) {
14701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetEncoding" "', expected argument " "1"" of type '" "wxFont const *""'");
14702 }
14703 arg1 = reinterpret_cast< wxFont * >(argp1);
14704 {
14705 PyThreadState* __tstate = wxPyBeginAllowThreads();
14706 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
14707 wxPyEndAllowThreads(__tstate);
14708 if (PyErr_Occurred()) SWIG_fail;
14709 }
14710 resultobj = SWIG_From_int(static_cast< int >(result));
14711 return resultobj;
14712 fail:
14713 return NULL;
14714 }
14715
14716
14717 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxFont *arg1 = (wxFont *) 0 ;
14720 wxNativeFontInfo *result = 0 ;
14721 void *argp1 = 0 ;
14722 int res1 = 0 ;
14723 PyObject *swig_obj[1] ;
14724
14725 if (!args) SWIG_fail;
14726 swig_obj[0] = args;
14727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14728 if (!SWIG_IsOK(res1)) {
14729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont const *""'");
14730 }
14731 arg1 = reinterpret_cast< wxFont * >(argp1);
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNativeFontInfo, 0 | 0 );
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_Font_IsFixedWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746 PyObject *resultobj = 0;
14747 wxFont *arg1 = (wxFont *) 0 ;
14748 bool result;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 PyObject *swig_obj[1] ;
14752
14753 if (!args) SWIG_fail;
14754 swig_obj[0] = args;
14755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14756 if (!SWIG_IsOK(res1)) {
14757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_IsFixedWidth" "', expected argument " "1"" of type '" "wxFont const *""'");
14758 }
14759 arg1 = reinterpret_cast< wxFont * >(argp1);
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
14763 wxPyEndAllowThreads(__tstate);
14764 if (PyErr_Occurred()) SWIG_fail;
14765 }
14766 {
14767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14768 }
14769 return resultobj;
14770 fail:
14771 return NULL;
14772 }
14773
14774
14775 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14776 PyObject *resultobj = 0;
14777 wxFont *arg1 = (wxFont *) 0 ;
14778 wxString result;
14779 void *argp1 = 0 ;
14780 int res1 = 0 ;
14781 PyObject *swig_obj[1] ;
14782
14783 if (!args) SWIG_fail;
14784 swig_obj[0] = args;
14785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14786 if (!SWIG_IsOK(res1)) {
14787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14788 }
14789 arg1 = reinterpret_cast< wxFont * >(argp1);
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 #if wxUSE_UNICODE
14798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14799 #else
14800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14801 #endif
14802 }
14803 return resultobj;
14804 fail:
14805 return NULL;
14806 }
14807
14808
14809 SWIGINTERN PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14810 PyObject *resultobj = 0;
14811 wxFont *arg1 = (wxFont *) 0 ;
14812 wxString result;
14813 void *argp1 = 0 ;
14814 int res1 = 0 ;
14815 PyObject *swig_obj[1] ;
14816
14817 if (!args) SWIG_fail;
14818 swig_obj[0] = args;
14819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont const *""'");
14822 }
14823 arg1 = reinterpret_cast< wxFont * >(argp1);
14824 {
14825 PyThreadState* __tstate = wxPyBeginAllowThreads();
14826 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
14827 wxPyEndAllowThreads(__tstate);
14828 if (PyErr_Occurred()) SWIG_fail;
14829 }
14830 {
14831 #if wxUSE_UNICODE
14832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14833 #else
14834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14835 #endif
14836 }
14837 return resultobj;
14838 fail:
14839 return NULL;
14840 }
14841
14842
14843 SWIGINTERN PyObject *_wrap_Font_SetPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14844 PyObject *resultobj = 0;
14845 wxFont *arg1 = (wxFont *) 0 ;
14846 int arg2 ;
14847 void *argp1 = 0 ;
14848 int res1 = 0 ;
14849 int val2 ;
14850 int ecode2 = 0 ;
14851 PyObject * obj0 = 0 ;
14852 PyObject * obj1 = 0 ;
14853 char * kwnames[] = {
14854 (char *) "self",(char *) "pointSize", NULL
14855 };
14856
14857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) SWIG_fail;
14858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14859 if (!SWIG_IsOK(res1)) {
14860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPointSize" "', expected argument " "1"" of type '" "wxFont *""'");
14861 }
14862 arg1 = reinterpret_cast< wxFont * >(argp1);
14863 ecode2 = SWIG_AsVal_int(obj1, &val2);
14864 if (!SWIG_IsOK(ecode2)) {
14865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetPointSize" "', expected argument " "2"" of type '" "int""'");
14866 }
14867 arg2 = static_cast< int >(val2);
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 (arg1)->SetPointSize(arg2);
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 resultobj = SWIG_Py_Void();
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 SWIGINTERN PyObject *_wrap_Font_SetPixelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14882 PyObject *resultobj = 0;
14883 wxFont *arg1 = (wxFont *) 0 ;
14884 wxSize *arg2 = 0 ;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 wxSize temp2 ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 char * kwnames[] = {
14891 (char *) "self",(char *) "pixelSize", NULL
14892 };
14893
14894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) SWIG_fail;
14895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14896 if (!SWIG_IsOK(res1)) {
14897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetPixelSize" "', expected argument " "1"" of type '" "wxFont *""'");
14898 }
14899 arg1 = reinterpret_cast< wxFont * >(argp1);
14900 {
14901 arg2 = &temp2;
14902 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14903 }
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 (arg1)->SetPixelSize((wxSize const &)*arg2);
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 resultobj = SWIG_Py_Void();
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 SWIGINTERN PyObject *_wrap_Font_SetFamily(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj = 0;
14919 wxFont *arg1 = (wxFont *) 0 ;
14920 int arg2 ;
14921 void *argp1 = 0 ;
14922 int res1 = 0 ;
14923 int val2 ;
14924 int ecode2 = 0 ;
14925 PyObject * obj0 = 0 ;
14926 PyObject * obj1 = 0 ;
14927 char * kwnames[] = {
14928 (char *) "self",(char *) "family", NULL
14929 };
14930
14931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) SWIG_fail;
14932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFamily" "', expected argument " "1"" of type '" "wxFont *""'");
14935 }
14936 arg1 = reinterpret_cast< wxFont * >(argp1);
14937 ecode2 = SWIG_AsVal_int(obj1, &val2);
14938 if (!SWIG_IsOK(ecode2)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetFamily" "', expected argument " "2"" of type '" "int""'");
14940 }
14941 arg2 = static_cast< int >(val2);
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 (arg1)->SetFamily(arg2);
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_Font_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14956 PyObject *resultobj = 0;
14957 wxFont *arg1 = (wxFont *) 0 ;
14958 int arg2 ;
14959 void *argp1 = 0 ;
14960 int res1 = 0 ;
14961 int val2 ;
14962 int ecode2 = 0 ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 char * kwnames[] = {
14966 (char *) "self",(char *) "style", NULL
14967 };
14968
14969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
14970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
14971 if (!SWIG_IsOK(res1)) {
14972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetStyle" "', expected argument " "1"" of type '" "wxFont *""'");
14973 }
14974 arg1 = reinterpret_cast< wxFont * >(argp1);
14975 ecode2 = SWIG_AsVal_int(obj1, &val2);
14976 if (!SWIG_IsOK(ecode2)) {
14977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetStyle" "', expected argument " "2"" of type '" "int""'");
14978 }
14979 arg2 = static_cast< int >(val2);
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 (arg1)->SetStyle(arg2);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_Py_Void();
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Font_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj = 0;
14995 wxFont *arg1 = (wxFont *) 0 ;
14996 int arg2 ;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 int val2 ;
15000 int ecode2 = 0 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "weight", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetWeight" "', expected argument " "1"" of type '" "wxFont *""'");
15011 }
15012 arg1 = reinterpret_cast< wxFont * >(argp1);
15013 ecode2 = SWIG_AsVal_int(obj1, &val2);
15014 if (!SWIG_IsOK(ecode2)) {
15015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetWeight" "', expected argument " "2"" of type '" "int""'");
15016 }
15017 arg2 = static_cast< int >(val2);
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 (arg1)->SetWeight(arg2);
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 resultobj = SWIG_Py_Void();
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_Font_SetFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj = 0;
15033 wxFont *arg1 = (wxFont *) 0 ;
15034 wxString *arg2 = 0 ;
15035 bool result;
15036 void *argp1 = 0 ;
15037 int res1 = 0 ;
15038 bool temp2 = false ;
15039 PyObject * obj0 = 0 ;
15040 PyObject * obj1 = 0 ;
15041 char * kwnames[] = {
15042 (char *) "self",(char *) "faceName", NULL
15043 };
15044
15045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) SWIG_fail;
15046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15047 if (!SWIG_IsOK(res1)) {
15048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetFaceName" "', expected argument " "1"" of type '" "wxFont *""'");
15049 }
15050 arg1 = reinterpret_cast< wxFont * >(argp1);
15051 {
15052 arg2 = wxString_in_helper(obj1);
15053 if (arg2 == NULL) SWIG_fail;
15054 temp2 = true;
15055 }
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = (bool)(arg1)->SetFaceName((wxString const &)*arg2);
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 {
15063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15064 }
15065 {
15066 if (temp2)
15067 delete arg2;
15068 }
15069 return resultobj;
15070 fail:
15071 {
15072 if (temp2)
15073 delete arg2;
15074 }
15075 return NULL;
15076 }
15077
15078
15079 SWIGINTERN PyObject *_wrap_Font_SetUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15080 PyObject *resultobj = 0;
15081 wxFont *arg1 = (wxFont *) 0 ;
15082 bool arg2 ;
15083 void *argp1 = 0 ;
15084 int res1 = 0 ;
15085 bool val2 ;
15086 int ecode2 = 0 ;
15087 PyObject * obj0 = 0 ;
15088 PyObject * obj1 = 0 ;
15089 char * kwnames[] = {
15090 (char *) "self",(char *) "underlined", NULL
15091 };
15092
15093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) SWIG_fail;
15094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15095 if (!SWIG_IsOK(res1)) {
15096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetUnderlined" "', expected argument " "1"" of type '" "wxFont *""'");
15097 }
15098 arg1 = reinterpret_cast< wxFont * >(argp1);
15099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15100 if (!SWIG_IsOK(ecode2)) {
15101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetUnderlined" "', expected argument " "2"" of type '" "bool""'");
15102 }
15103 arg2 = static_cast< bool >(val2);
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 (arg1)->SetUnderlined(arg2);
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 resultobj = SWIG_Py_Void();
15111 return resultobj;
15112 fail:
15113 return NULL;
15114 }
15115
15116
15117 SWIGINTERN PyObject *_wrap_Font_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15118 PyObject *resultobj = 0;
15119 wxFont *arg1 = (wxFont *) 0 ;
15120 wxFontEncoding arg2 ;
15121 void *argp1 = 0 ;
15122 int res1 = 0 ;
15123 int val2 ;
15124 int ecode2 = 0 ;
15125 PyObject * obj0 = 0 ;
15126 PyObject * obj1 = 0 ;
15127 char * kwnames[] = {
15128 (char *) "self",(char *) "encoding", NULL
15129 };
15130
15131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
15132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetEncoding" "', expected argument " "1"" of type '" "wxFont *""'");
15135 }
15136 arg1 = reinterpret_cast< wxFont * >(argp1);
15137 ecode2 = SWIG_AsVal_int(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetEncoding" "', expected argument " "2"" of type '" "wxFontEncoding""'");
15140 }
15141 arg2 = static_cast< wxFontEncoding >(val2);
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 (arg1)->SetEncoding(arg2);
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_Py_Void();
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj = 0;
15157 wxFont *arg1 = (wxFont *) 0 ;
15158 wxNativeFontInfo *arg2 = 0 ;
15159 void *argp1 = 0 ;
15160 int res1 = 0 ;
15161 void *argp2 = 0 ;
15162 int res2 = 0 ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 char * kwnames[] = {
15166 (char *) "self",(char *) "info", NULL
15167 };
15168
15169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) SWIG_fail;
15170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15171 if (!SWIG_IsOK(res1)) {
15172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfo" "', expected argument " "1"" of type '" "wxFont *""'");
15173 }
15174 arg1 = reinterpret_cast< wxFont * >(argp1);
15175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxNativeFontInfo, 0 | 0);
15176 if (!SWIG_IsOK(res2)) {
15177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
15178 }
15179 if (!argp2) {
15180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Font_SetNativeFontInfo" "', expected argument " "2"" of type '" "wxNativeFontInfo const &""'");
15181 }
15182 arg2 = reinterpret_cast< wxNativeFontInfo * >(argp2);
15183 {
15184 PyThreadState* __tstate = wxPyBeginAllowThreads();
15185 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 resultobj = SWIG_Py_Void();
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj = 0;
15198 wxFont *arg1 = (wxFont *) 0 ;
15199 wxString *arg2 = 0 ;
15200 bool result;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 bool temp2 = false ;
15204 PyObject * obj0 = 0 ;
15205 PyObject * obj1 = 0 ;
15206 char * kwnames[] = {
15207 (char *) "self",(char *) "info", NULL
15208 };
15209
15210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) SWIG_fail;
15211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15212 if (!SWIG_IsOK(res1)) {
15213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoFromString" "', expected argument " "1"" of type '" "wxFont *""'");
15214 }
15215 arg1 = reinterpret_cast< wxFont * >(argp1);
15216 {
15217 arg2 = wxString_in_helper(obj1);
15218 if (arg2 == NULL) SWIG_fail;
15219 temp2 = true;
15220 }
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 result = (bool)(arg1)->SetNativeFontInfo((wxString const &)*arg2);
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 {
15228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15229 }
15230 {
15231 if (temp2)
15232 delete arg2;
15233 }
15234 return resultobj;
15235 fail:
15236 {
15237 if (temp2)
15238 delete arg2;
15239 }
15240 return NULL;
15241 }
15242
15243
15244 SWIGINTERN PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15245 PyObject *resultobj = 0;
15246 wxFont *arg1 = (wxFont *) 0 ;
15247 wxString *arg2 = 0 ;
15248 bool result;
15249 void *argp1 = 0 ;
15250 int res1 = 0 ;
15251 bool temp2 = false ;
15252 PyObject * obj0 = 0 ;
15253 PyObject * obj1 = 0 ;
15254 char * kwnames[] = {
15255 (char *) "self",(char *) "info", NULL
15256 };
15257
15258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) SWIG_fail;
15259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15260 if (!SWIG_IsOK(res1)) {
15261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNativeFontInfoUserDesc" "', expected argument " "1"" of type '" "wxFont *""'");
15262 }
15263 arg1 = reinterpret_cast< wxFont * >(argp1);
15264 {
15265 arg2 = wxString_in_helper(obj1);
15266 if (arg2 == NULL) SWIG_fail;
15267 temp2 = true;
15268 }
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (bool)(arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 {
15276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15277 }
15278 {
15279 if (temp2)
15280 delete arg2;
15281 }
15282 return resultobj;
15283 fail:
15284 {
15285 if (temp2)
15286 delete arg2;
15287 }
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Font_GetFamilyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15293 PyObject *resultobj = 0;
15294 wxFont *arg1 = (wxFont *) 0 ;
15295 wxString result;
15296 void *argp1 = 0 ;
15297 int res1 = 0 ;
15298 PyObject *swig_obj[1] ;
15299
15300 if (!args) SWIG_fail;
15301 swig_obj[0] = args;
15302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15303 if (!SWIG_IsOK(res1)) {
15304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetFamilyString" "', expected argument " "1"" of type '" "wxFont const *""'");
15305 }
15306 arg1 = reinterpret_cast< wxFont * >(argp1);
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = ((wxFont const *)arg1)->GetFamilyString();
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 {
15314 #if wxUSE_UNICODE
15315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15316 #else
15317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15318 #endif
15319 }
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 SWIGINTERN PyObject *_wrap_Font_GetStyleString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15327 PyObject *resultobj = 0;
15328 wxFont *arg1 = (wxFont *) 0 ;
15329 wxString result;
15330 void *argp1 = 0 ;
15331 int res1 = 0 ;
15332 PyObject *swig_obj[1] ;
15333
15334 if (!args) SWIG_fail;
15335 swig_obj[0] = args;
15336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15337 if (!SWIG_IsOK(res1)) {
15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetStyleString" "', expected argument " "1"" of type '" "wxFont const *""'");
15339 }
15340 arg1 = reinterpret_cast< wxFont * >(argp1);
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 result = ((wxFont const *)arg1)->GetStyleString();
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 {
15348 #if wxUSE_UNICODE
15349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15350 #else
15351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15352 #endif
15353 }
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Font_GetWeightString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15361 PyObject *resultobj = 0;
15362 wxFont *arg1 = (wxFont *) 0 ;
15363 wxString result;
15364 void *argp1 = 0 ;
15365 int res1 = 0 ;
15366 PyObject *swig_obj[1] ;
15367
15368 if (!args) SWIG_fail;
15369 swig_obj[0] = args;
15370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15371 if (!SWIG_IsOK(res1)) {
15372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetWeightString" "', expected argument " "1"" of type '" "wxFont const *""'");
15373 }
15374 arg1 = reinterpret_cast< wxFont * >(argp1);
15375 {
15376 PyThreadState* __tstate = wxPyBeginAllowThreads();
15377 result = ((wxFont const *)arg1)->GetWeightString();
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 {
15382 #if wxUSE_UNICODE
15383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15384 #else
15385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15386 #endif
15387 }
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj = 0;
15396 wxFont *arg1 = (wxFont *) 0 ;
15397 bool arg2 = (bool) true ;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 bool val2 ;
15401 int ecode2 = 0 ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 char * kwnames[] = {
15405 (char *) "self",(char *) "no", NULL
15406 };
15407
15408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) SWIG_fail;
15409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont *""'");
15412 }
15413 arg1 = reinterpret_cast< wxFont * >(argp1);
15414 if (obj1) {
15415 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15416 if (!SWIG_IsOK(ecode2)) {
15417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Font_SetNoAntiAliasing" "', expected argument " "2"" of type '" "bool""'");
15418 }
15419 arg2 = static_cast< bool >(val2);
15420 }
15421 {
15422 PyThreadState* __tstate = wxPyBeginAllowThreads();
15423 (arg1)->SetNoAntiAliasing(arg2);
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 resultobj = SWIG_Py_Void();
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 SWIGINTERN PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15435 PyObject *resultobj = 0;
15436 wxFont *arg1 = (wxFont *) 0 ;
15437 bool result;
15438 void *argp1 = 0 ;
15439 int res1 = 0 ;
15440 PyObject *swig_obj[1] ;
15441
15442 if (!args) SWIG_fail;
15443 swig_obj[0] = args;
15444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFont, 0 | 0 );
15445 if (!SWIG_IsOK(res1)) {
15446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Font_GetNoAntiAliasing" "', expected argument " "1"" of type '" "wxFont const *""'");
15447 }
15448 arg1 = reinterpret_cast< wxFont * >(argp1);
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 {
15456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15457 }
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_Font_GetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15465 PyObject *resultobj = 0;
15466 wxFontEncoding result;
15467
15468 if (!SWIG_Python_UnpackTuple(args,"Font_GetDefaultEncoding",0,0,0)) SWIG_fail;
15469 {
15470 if (!wxPyCheckForApp()) SWIG_fail;
15471 PyThreadState* __tstate = wxPyBeginAllowThreads();
15472 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 resultobj = SWIG_From_int(static_cast< int >(result));
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 SWIGINTERN PyObject *_wrap_Font_SetDefaultEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15484 PyObject *resultobj = 0;
15485 wxFontEncoding arg1 ;
15486 int val1 ;
15487 int ecode1 = 0 ;
15488 PyObject * obj0 = 0 ;
15489 char * kwnames[] = {
15490 (char *) "encoding", NULL
15491 };
15492
15493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) SWIG_fail;
15494 ecode1 = SWIG_AsVal_int(obj0, &val1);
15495 if (!SWIG_IsOK(ecode1)) {
15496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Font_SetDefaultEncoding" "', expected argument " "1"" of type '" "wxFontEncoding""'");
15497 }
15498 arg1 = static_cast< wxFontEncoding >(val1);
15499 {
15500 if (!wxPyCheckForApp()) SWIG_fail;
15501 PyThreadState* __tstate = wxPyBeginAllowThreads();
15502 wxFont::SetDefaultEncoding(arg1);
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 resultobj = SWIG_Py_Void();
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 SWIGINTERN PyObject *Font_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15514 PyObject *obj;
15515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15516 SWIG_TypeNewClientData(SWIGTYPE_p_wxFont, SWIG_NewClientData(obj));
15517 return SWIG_Py_Void();
15518 }
15519
15520 SWIGINTERN PyObject *Font_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15521 return SWIG_Python_InitShadowInstance(args);
15522 }
15523
15524 SWIGINTERN PyObject *_wrap_new_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15525 PyObject *resultobj = 0;
15526 wxPyFontEnumerator *result = 0 ;
15527
15528 if (!SWIG_Python_UnpackTuple(args,"new_FontEnumerator",0,0,0)) SWIG_fail;
15529 {
15530 if (!wxPyCheckForApp()) SWIG_fail;
15531 PyThreadState* __tstate = wxPyBeginAllowThreads();
15532 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_NEW | 0 );
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_delete_FontEnumerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15544 PyObject *resultobj = 0;
15545 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 PyObject *swig_obj[1] ;
15549
15550 if (!args) SWIG_fail;
15551 swig_obj[0] = args;
15552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_DISOWN | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FontEnumerator" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15555 }
15556 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 delete arg1;
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 resultobj = SWIG_Py_Void();
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 SWIGINTERN PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15572 PyObject *resultobj = 0;
15573 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
15574 PyObject *arg2 = (PyObject *) 0 ;
15575 PyObject *arg3 = (PyObject *) 0 ;
15576 bool arg4 ;
15577 void *argp1 = 0 ;
15578 int res1 = 0 ;
15579 bool val4 ;
15580 int ecode4 = 0 ;
15581 PyObject * obj0 = 0 ;
15582 PyObject * obj1 = 0 ;
15583 PyObject * obj2 = 0 ;
15584 PyObject * obj3 = 0 ;
15585 char * kwnames[] = {
15586 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
15587 };
15588
15589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
15591 if (!SWIG_IsOK(res1)) {
15592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15593 }
15594 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15595 arg2 = obj1;
15596 arg3 = obj2;
15597 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15598 if (!SWIG_IsOK(ecode4)) {
15599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontEnumerator__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
15600 }
15601 arg4 = static_cast< bool >(val4);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = SWIG_Py_Void();
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15616 PyObject *resultobj = 0;
15617 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
15618 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
15619 bool arg3 = (bool) false ;
15620 bool result;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 int val2 ;
15624 int ecode2 = 0 ;
15625 bool val3 ;
15626 int ecode3 = 0 ;
15627 PyObject * obj0 = 0 ;
15628 PyObject * obj1 = 0 ;
15629 PyObject * obj2 = 0 ;
15630 char * kwnames[] = {
15631 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
15632 };
15633
15634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15638 }
15639 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15640 if (obj1) {
15641 ecode2 = SWIG_AsVal_int(obj1, &val2);
15642 if (!SWIG_IsOK(ecode2)) {
15643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "2"" of type '" "wxFontEncoding""'");
15644 }
15645 arg2 = static_cast< wxFontEncoding >(val2);
15646 }
15647 if (obj2) {
15648 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15649 if (!SWIG_IsOK(ecode3)) {
15650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontEnumerator_EnumerateFacenames" "', expected argument " "3"" of type '" "bool""'");
15651 }
15652 arg3 = static_cast< bool >(val3);
15653 }
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 result = (bool)(arg1)->EnumerateFacenames(arg2,arg3);
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 {
15661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15662 }
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 SWIGINTERN PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj = 0;
15671 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
15672 wxString const &arg2_defvalue = wxPyEmptyString ;
15673 wxString *arg2 = (wxString *) &arg2_defvalue ;
15674 bool result;
15675 void *argp1 = 0 ;
15676 int res1 = 0 ;
15677 bool temp2 = false ;
15678 PyObject * obj0 = 0 ;
15679 PyObject * obj1 = 0 ;
15680 char * kwnames[] = {
15681 (char *) "self",(char *) "facename", NULL
15682 };
15683
15684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) SWIG_fail;
15685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFontEnumerator, 0 | 0 );
15686 if (!SWIG_IsOK(res1)) {
15687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontEnumerator_EnumerateEncodings" "', expected argument " "1"" of type '" "wxPyFontEnumerator *""'");
15688 }
15689 arg1 = reinterpret_cast< wxPyFontEnumerator * >(argp1);
15690 if (obj1) {
15691 {
15692 arg2 = wxString_in_helper(obj1);
15693 if (arg2 == NULL) SWIG_fail;
15694 temp2 = true;
15695 }
15696 }
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 {
15704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15705 }
15706 {
15707 if (temp2)
15708 delete arg2;
15709 }
15710 return resultobj;
15711 fail:
15712 {
15713 if (temp2)
15714 delete arg2;
15715 }
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15721 PyObject *resultobj = 0;
15722 PyObject *result = 0 ;
15723
15724 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetEncodings",0,0,0)) SWIG_fail;
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (PyObject *)wxPyFontEnumerator_GetEncodings();
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 resultobj = result;
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15739 PyObject *resultobj = 0;
15740 PyObject *result = 0 ;
15741
15742 if (!SWIG_Python_UnpackTuple(args,"FontEnumerator_GetFacenames",0,0,0)) SWIG_fail;
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 result = (PyObject *)wxPyFontEnumerator_GetFacenames();
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 resultobj = result;
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 SWIGINTERN PyObject *_wrap_FontEnumerator_IsValidFacename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj = 0;
15758 wxString *arg1 = 0 ;
15759 bool result;
15760 bool temp1 = false ;
15761 PyObject * obj0 = 0 ;
15762 char * kwnames[] = {
15763 (char *) "str", NULL
15764 };
15765
15766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_IsValidFacename",kwnames,&obj0)) SWIG_fail;
15767 {
15768 arg1 = wxString_in_helper(obj0);
15769 if (arg1 == NULL) SWIG_fail;
15770 temp1 = true;
15771 }
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = (bool)wxPyFontEnumerator::IsValidFacename((wxString const &)*arg1);
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 {
15779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15780 }
15781 {
15782 if (temp1)
15783 delete arg1;
15784 }
15785 return resultobj;
15786 fail:
15787 {
15788 if (temp1)
15789 delete arg1;
15790 }
15791 return NULL;
15792 }
15793
15794
15795 SWIGINTERN PyObject *FontEnumerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15796 PyObject *obj;
15797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15798 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFontEnumerator, SWIG_NewClientData(obj));
15799 return SWIG_Py_Void();
15800 }
15801
15802 SWIGINTERN PyObject *FontEnumerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15803 return SWIG_Python_InitShadowInstance(args);
15804 }
15805
15806 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15807 PyObject *resultobj = 0;
15808 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15809 int arg2 ;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 int val2 ;
15813 int ecode2 = 0 ;
15814 PyObject *swig_obj[2] ;
15815
15816 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Language_set",2,2,swig_obj)) SWIG_fail;
15817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15818 if (!SWIG_IsOK(res1)) {
15819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15820 }
15821 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15822 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15823 if (!SWIG_IsOK(ecode2)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LanguageInfo_Language_set" "', expected argument " "2"" of type '" "int""'");
15825 }
15826 arg2 = static_cast< int >(val2);
15827 if (arg1) (arg1)->Language = arg2;
15828
15829 resultobj = SWIG_Py_Void();
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_LanguageInfo_Language_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15839 int result;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Language_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15849 }
15850 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15851 result = (int) ((arg1)->Language);
15852 resultobj = SWIG_From_int(static_cast< int >(result));
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15860 PyObject *resultobj = 0;
15861 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15862 wxString *arg2 = (wxString *) 0 ;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 bool temp2 = false ;
15866 PyObject *swig_obj[2] ;
15867
15868 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_CanonicalName_set",2,2,swig_obj)) SWIG_fail;
15869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15870 if (!SWIG_IsOK(res1)) {
15871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15872 }
15873 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15874 {
15875 arg2 = wxString_in_helper(swig_obj[1]);
15876 if (arg2 == NULL) SWIG_fail;
15877 temp2 = true;
15878 }
15879 if (arg1) (arg1)->CanonicalName = *arg2;
15880
15881 resultobj = SWIG_Py_Void();
15882 {
15883 if (temp2)
15884 delete arg2;
15885 }
15886 return resultobj;
15887 fail:
15888 {
15889 if (temp2)
15890 delete arg2;
15891 }
15892 return NULL;
15893 }
15894
15895
15896 SWIGINTERN PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15897 PyObject *resultobj = 0;
15898 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15899 wxString *result = 0 ;
15900 void *argp1 = 0 ;
15901 int res1 = 0 ;
15902 PyObject *swig_obj[1] ;
15903
15904 if (!args) SWIG_fail;
15905 swig_obj[0] = args;
15906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15907 if (!SWIG_IsOK(res1)) {
15908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_CanonicalName_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15909 }
15910 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15911 result = (wxString *)& ((arg1)->CanonicalName);
15912 {
15913 #if wxUSE_UNICODE
15914 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15915 #else
15916 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15917 #endif
15918 }
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15926 PyObject *resultobj = 0;
15927 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15928 wxString *arg2 = (wxString *) 0 ;
15929 void *argp1 = 0 ;
15930 int res1 = 0 ;
15931 bool temp2 = false ;
15932 PyObject *swig_obj[2] ;
15933
15934 if (!SWIG_Python_UnpackTuple(args,"LanguageInfo_Description_set",2,2,swig_obj)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_set" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15938 }
15939 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15940 {
15941 arg2 = wxString_in_helper(swig_obj[1]);
15942 if (arg2 == NULL) SWIG_fail;
15943 temp2 = true;
15944 }
15945 if (arg1) (arg1)->Description = *arg2;
15946
15947 resultobj = SWIG_Py_Void();
15948 {
15949 if (temp2)
15950 delete arg2;
15951 }
15952 return resultobj;
15953 fail:
15954 {
15955 if (temp2)
15956 delete arg2;
15957 }
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_LanguageInfo_Description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 PyObject *resultobj = 0;
15964 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
15965 wxString *result = 0 ;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 PyObject *swig_obj[1] ;
15969
15970 if (!args) SWIG_fail;
15971 swig_obj[0] = args;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LanguageInfo_Description_get" "', expected argument " "1"" of type '" "wxLanguageInfo *""'");
15975 }
15976 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
15977 result = (wxString *)& ((arg1)->Description);
15978 {
15979 #if wxUSE_UNICODE
15980 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15981 #else
15982 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15983 #endif
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 SWIGINTERN PyObject *LanguageInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15992 PyObject *obj;
15993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15994 SWIG_TypeNewClientData(SWIGTYPE_p_wxLanguageInfo, SWIG_NewClientData(obj));
15995 return SWIG_Py_Void();
15996 }
15997
15998 SWIGINTERN PyObject *_wrap_new_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15999 PyObject *resultobj = 0;
16000 int arg1 = (int) -1 ;
16001 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
16002 wxLocale *result = 0 ;
16003 int val1 ;
16004 int ecode1 = 0 ;
16005 int val2 ;
16006 int ecode2 = 0 ;
16007 PyObject * obj0 = 0 ;
16008 PyObject * obj1 = 0 ;
16009 char * kwnames[] = {
16010 (char *) "language",(char *) "flags", NULL
16011 };
16012
16013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) SWIG_fail;
16014 if (obj0) {
16015 ecode1 = SWIG_AsVal_int(obj0, &val1);
16016 if (!SWIG_IsOK(ecode1)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Locale" "', expected argument " "1"" of type '" "int""'");
16018 }
16019 arg1 = static_cast< int >(val1);
16020 }
16021 if (obj1) {
16022 ecode2 = SWIG_AsVal_int(obj1, &val2);
16023 if (!SWIG_IsOK(ecode2)) {
16024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Locale" "', expected argument " "2"" of type '" "int""'");
16025 }
16026 arg2 = static_cast< int >(val2);
16027 }
16028 {
16029 PyThreadState* __tstate = wxPyBeginAllowThreads();
16030 result = (wxLocale *)new_wxLocale(arg1,arg2);
16031 wxPyEndAllowThreads(__tstate);
16032 if (PyErr_Occurred()) SWIG_fail;
16033 }
16034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, SWIG_POINTER_NEW | 0 );
16035 return resultobj;
16036 fail:
16037 return NULL;
16038 }
16039
16040
16041 SWIGINTERN PyObject *_wrap_delete_Locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16042 PyObject *resultobj = 0;
16043 wxLocale *arg1 = (wxLocale *) 0 ;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 PyObject *swig_obj[1] ;
16047
16048 if (!args) SWIG_fail;
16049 swig_obj[0] = args;
16050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, SWIG_POINTER_DISOWN | 0 );
16051 if (!SWIG_IsOK(res1)) {
16052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locale" "', expected argument " "1"" of type '" "wxLocale *""'");
16053 }
16054 arg1 = reinterpret_cast< wxLocale * >(argp1);
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 delete arg1;
16058
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 resultobj = SWIG_Py_Void();
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 SWIGINTERN PyObject *_wrap_Locale_Init1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj = 0;
16071 wxLocale *arg1 = (wxLocale *) 0 ;
16072 wxString *arg2 = 0 ;
16073 wxString const &arg3_defvalue = wxPyEmptyString ;
16074 wxString *arg3 = (wxString *) &arg3_defvalue ;
16075 wxString const &arg4_defvalue = wxPyEmptyString ;
16076 wxString *arg4 = (wxString *) &arg4_defvalue ;
16077 bool arg5 = (bool) true ;
16078 bool arg6 = (bool) false ;
16079 bool result;
16080 void *argp1 = 0 ;
16081 int res1 = 0 ;
16082 bool temp2 = false ;
16083 bool temp3 = false ;
16084 bool temp4 = false ;
16085 bool val5 ;
16086 int ecode5 = 0 ;
16087 bool val6 ;
16088 int ecode6 = 0 ;
16089 PyObject * obj0 = 0 ;
16090 PyObject * obj1 = 0 ;
16091 PyObject * obj2 = 0 ;
16092 PyObject * obj3 = 0 ;
16093 PyObject * obj4 = 0 ;
16094 PyObject * obj5 = 0 ;
16095 char * kwnames[] = {
16096 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
16097 };
16098
16099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init1" "', expected argument " "1"" of type '" "wxLocale *""'");
16103 }
16104 arg1 = reinterpret_cast< wxLocale * >(argp1);
16105 {
16106 arg2 = wxString_in_helper(obj1);
16107 if (arg2 == NULL) SWIG_fail;
16108 temp2 = true;
16109 }
16110 if (obj2) {
16111 {
16112 arg3 = wxString_in_helper(obj2);
16113 if (arg3 == NULL) SWIG_fail;
16114 temp3 = true;
16115 }
16116 }
16117 if (obj3) {
16118 {
16119 arg4 = wxString_in_helper(obj3);
16120 if (arg4 == NULL) SWIG_fail;
16121 temp4 = true;
16122 }
16123 }
16124 if (obj4) {
16125 ecode5 = SWIG_AsVal_bool(obj4, &val5);
16126 if (!SWIG_IsOK(ecode5)) {
16127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Locale_Init1" "', expected argument " "5"" of type '" "bool""'");
16128 }
16129 arg5 = static_cast< bool >(val5);
16130 }
16131 if (obj5) {
16132 ecode6 = SWIG_AsVal_bool(obj5, &val6);
16133 if (!SWIG_IsOK(ecode6)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Locale_Init1" "', expected argument " "6"" of type '" "bool""'");
16135 }
16136 arg6 = static_cast< bool >(val6);
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 {
16145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16146 }
16147 {
16148 if (temp2)
16149 delete arg2;
16150 }
16151 {
16152 if (temp3)
16153 delete arg3;
16154 }
16155 {
16156 if (temp4)
16157 delete arg4;
16158 }
16159 return resultobj;
16160 fail:
16161 {
16162 if (temp2)
16163 delete arg2;
16164 }
16165 {
16166 if (temp3)
16167 delete arg3;
16168 }
16169 {
16170 if (temp4)
16171 delete arg4;
16172 }
16173 return NULL;
16174 }
16175
16176
16177 SWIGINTERN PyObject *_wrap_Locale_Init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj = 0;
16179 wxLocale *arg1 = (wxLocale *) 0 ;
16180 int arg2 = (int) wxLANGUAGE_DEFAULT ;
16181 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
16182 bool result;
16183 void *argp1 = 0 ;
16184 int res1 = 0 ;
16185 int val2 ;
16186 int ecode2 = 0 ;
16187 int val3 ;
16188 int ecode3 = 0 ;
16189 PyObject * obj0 = 0 ;
16190 PyObject * obj1 = 0 ;
16191 PyObject * obj2 = 0 ;
16192 char * kwnames[] = {
16193 (char *) "self",(char *) "language",(char *) "flags", NULL
16194 };
16195
16196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16198 if (!SWIG_IsOK(res1)) {
16199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_Init2" "', expected argument " "1"" of type '" "wxLocale *""'");
16200 }
16201 arg1 = reinterpret_cast< wxLocale * >(argp1);
16202 if (obj1) {
16203 ecode2 = SWIG_AsVal_int(obj1, &val2);
16204 if (!SWIG_IsOK(ecode2)) {
16205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Locale_Init2" "', expected argument " "2"" of type '" "int""'");
16206 }
16207 arg2 = static_cast< int >(val2);
16208 }
16209 if (obj2) {
16210 ecode3 = SWIG_AsVal_int(obj2, &val3);
16211 if (!SWIG_IsOK(ecode3)) {
16212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Locale_Init2" "', expected argument " "3"" of type '" "int""'");
16213 }
16214 arg3 = static_cast< int >(val3);
16215 }
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 {
16223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16224 }
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Locale_GetSystemLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16232 PyObject *resultobj = 0;
16233 int result;
16234
16235 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemLanguage",0,0,0)) SWIG_fail;
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = (int)wxLocale::GetSystemLanguage();
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 resultobj = SWIG_From_int(static_cast< int >(result));
16243 return resultobj;
16244 fail:
16245 return NULL;
16246 }
16247
16248
16249 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16250 PyObject *resultobj = 0;
16251 wxFontEncoding result;
16252
16253 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncoding",0,0,0)) SWIG_fail;
16254 {
16255 PyThreadState* __tstate = wxPyBeginAllowThreads();
16256 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
16257 wxPyEndAllowThreads(__tstate);
16258 if (PyErr_Occurred()) SWIG_fail;
16259 }
16260 resultobj = SWIG_From_int(static_cast< int >(result));
16261 return resultobj;
16262 fail:
16263 return NULL;
16264 }
16265
16266
16267 SWIGINTERN PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16268 PyObject *resultobj = 0;
16269 wxString result;
16270
16271 if (!SWIG_Python_UnpackTuple(args,"Locale_GetSystemEncodingName",0,0,0)) SWIG_fail;
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 result = wxLocale::GetSystemEncodingName();
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 {
16279 #if wxUSE_UNICODE
16280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16281 #else
16282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16283 #endif
16284 }
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 SWIGINTERN PyObject *_wrap_Locale_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16292 PyObject *resultobj = 0;
16293 wxLocale *arg1 = (wxLocale *) 0 ;
16294 bool result;
16295 void *argp1 = 0 ;
16296 int res1 = 0 ;
16297 PyObject *swig_obj[1] ;
16298
16299 if (!args) SWIG_fail;
16300 swig_obj[0] = args;
16301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16302 if (!SWIG_IsOK(res1)) {
16303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsOk" "', expected argument " "1"" of type '" "wxLocale const *""'");
16304 }
16305 arg1 = reinterpret_cast< wxLocale * >(argp1);
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 result = (bool)((wxLocale const *)arg1)->IsOk();
16309 wxPyEndAllowThreads(__tstate);
16310 if (PyErr_Occurred()) SWIG_fail;
16311 }
16312 {
16313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16314 }
16315 return resultobj;
16316 fail:
16317 return NULL;
16318 }
16319
16320
16321 SWIGINTERN PyObject *_wrap_Locale_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16322 PyObject *resultobj = 0;
16323 wxLocale *arg1 = (wxLocale *) 0 ;
16324 wxString result;
16325 void *argp1 = 0 ;
16326 int res1 = 0 ;
16327 PyObject *swig_obj[1] ;
16328
16329 if (!args) SWIG_fail;
16330 swig_obj[0] = args;
16331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16332 if (!SWIG_IsOK(res1)) {
16333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLocale" "', expected argument " "1"" of type '" "wxLocale const *""'");
16334 }
16335 arg1 = reinterpret_cast< wxLocale * >(argp1);
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = ((wxLocale const *)arg1)->GetLocale();
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 #if wxUSE_UNICODE
16344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16345 #else
16346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16347 #endif
16348 }
16349 return resultobj;
16350 fail:
16351 return NULL;
16352 }
16353
16354
16355 SWIGINTERN PyObject *_wrap_Locale_GetLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16356 PyObject *resultobj = 0;
16357 wxLocale *arg1 = (wxLocale *) 0 ;
16358 int result;
16359 void *argp1 = 0 ;
16360 int res1 = 0 ;
16361 PyObject *swig_obj[1] ;
16362
16363 if (!args) SWIG_fail;
16364 swig_obj[0] = args;
16365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16366 if (!SWIG_IsOK(res1)) {
16367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetLanguage" "', expected argument " "1"" of type '" "wxLocale const *""'");
16368 }
16369 arg1 = reinterpret_cast< wxLocale * >(argp1);
16370 {
16371 PyThreadState* __tstate = wxPyBeginAllowThreads();
16372 result = (int)((wxLocale const *)arg1)->GetLanguage();
16373 wxPyEndAllowThreads(__tstate);
16374 if (PyErr_Occurred()) SWIG_fail;
16375 }
16376 resultobj = SWIG_From_int(static_cast< int >(result));
16377 return resultobj;
16378 fail:
16379 return NULL;
16380 }
16381
16382
16383 SWIGINTERN PyObject *_wrap_Locale_GetSysName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16384 PyObject *resultobj = 0;
16385 wxLocale *arg1 = (wxLocale *) 0 ;
16386 wxString result;
16387 void *argp1 = 0 ;
16388 int res1 = 0 ;
16389 PyObject *swig_obj[1] ;
16390
16391 if (!args) SWIG_fail;
16392 swig_obj[0] = args;
16393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16394 if (!SWIG_IsOK(res1)) {
16395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetSysName" "', expected argument " "1"" of type '" "wxLocale const *""'");
16396 }
16397 arg1 = reinterpret_cast< wxLocale * >(argp1);
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = ((wxLocale const *)arg1)->GetSysName();
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 #if wxUSE_UNICODE
16406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16407 #else
16408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16409 #endif
16410 }
16411 return resultobj;
16412 fail:
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_Locale_GetCanonicalName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16418 PyObject *resultobj = 0;
16419 wxLocale *arg1 = (wxLocale *) 0 ;
16420 wxString result;
16421 void *argp1 = 0 ;
16422 int res1 = 0 ;
16423 PyObject *swig_obj[1] ;
16424
16425 if (!args) SWIG_fail;
16426 swig_obj[0] = args;
16427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16428 if (!SWIG_IsOK(res1)) {
16429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetCanonicalName" "', expected argument " "1"" of type '" "wxLocale const *""'");
16430 }
16431 arg1 = reinterpret_cast< wxLocale * >(argp1);
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 result = ((wxLocale const *)arg1)->GetCanonicalName();
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 #if wxUSE_UNICODE
16440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16441 #else
16442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16443 #endif
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxString *arg1 = 0 ;
16454 bool temp1 = false ;
16455 PyObject * obj0 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "prefix", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) SWIG_fail;
16461 {
16462 arg1 = wxString_in_helper(obj0);
16463 if (arg1 == NULL) SWIG_fail;
16464 temp1 = true;
16465 }
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 resultobj = SWIG_Py_Void();
16473 {
16474 if (temp1)
16475 delete arg1;
16476 }
16477 return resultobj;
16478 fail:
16479 {
16480 if (temp1)
16481 delete arg1;
16482 }
16483 return NULL;
16484 }
16485
16486
16487 SWIGINTERN PyObject *_wrap_Locale_AddCatalog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16488 PyObject *resultobj = 0;
16489 wxLocale *arg1 = (wxLocale *) 0 ;
16490 wxString *arg2 = 0 ;
16491 bool result;
16492 void *argp1 = 0 ;
16493 int res1 = 0 ;
16494 bool temp2 = false ;
16495 PyObject * obj0 = 0 ;
16496 PyObject * obj1 = 0 ;
16497 char * kwnames[] = {
16498 (char *) "self",(char *) "szDomain", NULL
16499 };
16500
16501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) SWIG_fail;
16502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16503 if (!SWIG_IsOK(res1)) {
16504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddCatalog" "', expected argument " "1"" of type '" "wxLocale *""'");
16505 }
16506 arg1 = reinterpret_cast< wxLocale * >(argp1);
16507 {
16508 arg2 = wxString_in_helper(obj1);
16509 if (arg2 == NULL) SWIG_fail;
16510 temp2 = true;
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 {
16519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16520 }
16521 {
16522 if (temp2)
16523 delete arg2;
16524 }
16525 return resultobj;
16526 fail:
16527 {
16528 if (temp2)
16529 delete arg2;
16530 }
16531 return NULL;
16532 }
16533
16534
16535 SWIGINTERN PyObject *_wrap_Locale_IsLoaded(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj = 0;
16537 wxLocale *arg1 = (wxLocale *) 0 ;
16538 wxString *arg2 = 0 ;
16539 bool result;
16540 void *argp1 = 0 ;
16541 int res1 = 0 ;
16542 bool temp2 = false ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 char * kwnames[] = {
16546 (char *) "self",(char *) "szDomain", NULL
16547 };
16548
16549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) SWIG_fail;
16550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16551 if (!SWIG_IsOK(res1)) {
16552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_IsLoaded" "', expected argument " "1"" of type '" "wxLocale const *""'");
16553 }
16554 arg1 = reinterpret_cast< wxLocale * >(argp1);
16555 {
16556 arg2 = wxString_in_helper(obj1);
16557 if (arg2 == NULL) SWIG_fail;
16558 temp2 = true;
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 {
16570 if (temp2)
16571 delete arg2;
16572 }
16573 return resultobj;
16574 fail:
16575 {
16576 if (temp2)
16577 delete arg2;
16578 }
16579 return NULL;
16580 }
16581
16582
16583 SWIGINTERN PyObject *_wrap_Locale_GetLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj = 0;
16585 int arg1 ;
16586 wxLanguageInfo *result = 0 ;
16587 int val1 ;
16588 int ecode1 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 char * kwnames[] = {
16591 (char *) "lang", NULL
16592 };
16593
16594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) SWIG_fail;
16595 ecode1 = SWIG_AsVal_int(obj0, &val1);
16596 if (!SWIG_IsOK(ecode1)) {
16597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageInfo" "', expected argument " "1"" of type '" "int""'");
16598 }
16599 arg1 = static_cast< int >(val1);
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
16607 return resultobj;
16608 fail:
16609 return NULL;
16610 }
16611
16612
16613 SWIGINTERN PyObject *_wrap_Locale_GetLanguageName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16614 PyObject *resultobj = 0;
16615 int arg1 ;
16616 wxString result;
16617 int val1 ;
16618 int ecode1 = 0 ;
16619 PyObject * obj0 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "lang", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) SWIG_fail;
16625 ecode1 = SWIG_AsVal_int(obj0, &val1);
16626 if (!SWIG_IsOK(ecode1)) {
16627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Locale_GetLanguageName" "', expected argument " "1"" of type '" "int""'");
16628 }
16629 arg1 = static_cast< int >(val1);
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 result = wxLocale::GetLanguageName(arg1);
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 #if wxUSE_UNICODE
16638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16639 #else
16640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16641 #endif
16642 }
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Locale_FindLanguageInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxString *arg1 = 0 ;
16652 wxLanguageInfo *result = 0 ;
16653 bool temp1 = false ;
16654 PyObject * obj0 = 0 ;
16655 char * kwnames[] = {
16656 (char *) "locale", NULL
16657 };
16658
16659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) SWIG_fail;
16660 {
16661 arg1 = wxString_in_helper(obj0);
16662 if (arg1 == NULL) SWIG_fail;
16663 temp1 = true;
16664 }
16665 {
16666 PyThreadState* __tstate = wxPyBeginAllowThreads();
16667 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLanguageInfo, 0 | 0 );
16672 {
16673 if (temp1)
16674 delete arg1;
16675 }
16676 return resultobj;
16677 fail:
16678 {
16679 if (temp1)
16680 delete arg1;
16681 }
16682 return NULL;
16683 }
16684
16685
16686 SWIGINTERN PyObject *_wrap_Locale_AddLanguage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16687 PyObject *resultobj = 0;
16688 wxLanguageInfo *arg1 = 0 ;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject * obj0 = 0 ;
16692 char * kwnames[] = {
16693 (char *) "info", NULL
16694 };
16695
16696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) SWIG_fail;
16697 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxLanguageInfo, 0 | 0);
16698 if (!SWIG_IsOK(res1)) {
16699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16700 }
16701 if (!argp1) {
16702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Locale_AddLanguage" "', expected argument " "1"" of type '" "wxLanguageInfo const &""'");
16703 }
16704 arg1 = reinterpret_cast< wxLanguageInfo * >(argp1);
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
16708 wxPyEndAllowThreads(__tstate);
16709 if (PyErr_Occurred()) SWIG_fail;
16710 }
16711 resultobj = SWIG_Py_Void();
16712 return resultobj;
16713 fail:
16714 return NULL;
16715 }
16716
16717
16718 SWIGINTERN PyObject *_wrap_Locale_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16719 PyObject *resultobj = 0;
16720 wxLocale *arg1 = (wxLocale *) 0 ;
16721 wxString *arg2 = 0 ;
16722 wxString const &arg3_defvalue = wxPyEmptyString ;
16723 wxString *arg3 = (wxString *) &arg3_defvalue ;
16724 wxString result;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 bool temp2 = false ;
16728 bool temp3 = false ;
16729 PyObject * obj0 = 0 ;
16730 PyObject * obj1 = 0 ;
16731 PyObject * obj2 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16738 if (!SWIG_IsOK(res1)) {
16739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetString" "', expected argument " "1"" of type '" "wxLocale const *""'");
16740 }
16741 arg1 = reinterpret_cast< wxLocale * >(argp1);
16742 {
16743 arg2 = wxString_in_helper(obj1);
16744 if (arg2 == NULL) SWIG_fail;
16745 temp2 = true;
16746 }
16747 if (obj2) {
16748 {
16749 arg3 = wxString_in_helper(obj2);
16750 if (arg3 == NULL) SWIG_fail;
16751 temp3 = true;
16752 }
16753 }
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 {
16761 #if wxUSE_UNICODE
16762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16763 #else
16764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16765 #endif
16766 }
16767 {
16768 if (temp2)
16769 delete arg2;
16770 }
16771 {
16772 if (temp3)
16773 delete arg3;
16774 }
16775 return resultobj;
16776 fail:
16777 {
16778 if (temp2)
16779 delete arg2;
16780 }
16781 {
16782 if (temp3)
16783 delete arg3;
16784 }
16785 return NULL;
16786 }
16787
16788
16789 SWIGINTERN PyObject *_wrap_Locale_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16790 PyObject *resultobj = 0;
16791 wxLocale *arg1 = (wxLocale *) 0 ;
16792 wxString *result = 0 ;
16793 void *argp1 = 0 ;
16794 int res1 = 0 ;
16795 PyObject *swig_obj[1] ;
16796
16797 if (!args) SWIG_fail;
16798 swig_obj[0] = args;
16799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLocale, 0 | 0 );
16800 if (!SWIG_IsOK(res1)) {
16801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locale_GetName" "', expected argument " "1"" of type '" "wxLocale const *""'");
16802 }
16803 arg1 = reinterpret_cast< wxLocale * >(argp1);
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 {
16807 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
16808 result = (wxString *) &_result_ref;
16809 }
16810 wxPyEndAllowThreads(__tstate);
16811 if (PyErr_Occurred()) SWIG_fail;
16812 }
16813 {
16814 #if wxUSE_UNICODE
16815 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16816 #else
16817 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16818 #endif
16819 }
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *Locale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16827 PyObject *obj;
16828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16829 SWIG_TypeNewClientData(SWIGTYPE_p_wxLocale, SWIG_NewClientData(obj));
16830 return SWIG_Py_Void();
16831 }
16832
16833 SWIGINTERN PyObject *Locale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16834 return SWIG_Python_InitShadowInstance(args);
16835 }
16836
16837 SWIGINTERN PyObject *_wrap_new_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj = 0;
16839 int arg1 = (int) -1 ;
16840 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
16841 wxPyLocale *result = 0 ;
16842 int val1 ;
16843 int ecode1 = 0 ;
16844 int val2 ;
16845 int ecode2 = 0 ;
16846 PyObject * obj0 = 0 ;
16847 PyObject * obj1 = 0 ;
16848 char * kwnames[] = {
16849 (char *) "language",(char *) "flags", NULL
16850 };
16851
16852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyLocale",kwnames,&obj0,&obj1)) SWIG_fail;
16853 if (obj0) {
16854 ecode1 = SWIG_AsVal_int(obj0, &val1);
16855 if (!SWIG_IsOK(ecode1)) {
16856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyLocale" "', expected argument " "1"" of type '" "int""'");
16857 }
16858 arg1 = static_cast< int >(val1);
16859 }
16860 if (obj1) {
16861 ecode2 = SWIG_AsVal_int(obj1, &val2);
16862 if (!SWIG_IsOK(ecode2)) {
16863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyLocale" "', expected argument " "2"" of type '" "int""'");
16864 }
16865 arg2 = static_cast< int >(val2);
16866 }
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (wxPyLocale *)new_wxPyLocale(arg1,arg2);
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLocale, SWIG_POINTER_NEW | 0 );
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_delete_PyLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16881 PyObject *resultobj = 0;
16882 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 PyObject *swig_obj[1] ;
16886
16887 if (!args) SWIG_fail;
16888 swig_obj[0] = args;
16889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyLocale, SWIG_POINTER_DISOWN | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyLocale" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16892 }
16893 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 delete arg1;
16897
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 resultobj = SWIG_Py_Void();
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 SWIGINTERN PyObject *_wrap_PyLocale__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj = 0;
16910 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16911 PyObject *arg2 = (PyObject *) 0 ;
16912 PyObject *arg3 = (PyObject *) 0 ;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 PyObject * obj0 = 0 ;
16916 PyObject * obj1 = 0 ;
16917 PyObject * obj2 = 0 ;
16918 char * kwnames[] = {
16919 (char *) "self",(char *) "self",(char *) "_class", NULL
16920 };
16921
16922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLocale__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16924 if (!SWIG_IsOK(res1)) {
16925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLocale *""'");
16926 }
16927 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16928 arg2 = obj1;
16929 arg3 = obj2;
16930 {
16931 PyThreadState* __tstate = wxPyBeginAllowThreads();
16932 (arg1)->_setCallbackInfo(arg2,arg3);
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 resultobj = SWIG_Py_Void();
16937 return resultobj;
16938 fail:
16939 return NULL;
16940 }
16941
16942
16943 SWIGINTERN PyObject *_wrap_PyLocale_GetSingularString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16944 PyObject *resultobj = 0;
16945 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16946 wxChar *arg2 = (wxChar *) 0 ;
16947 wxChar *arg3 = (wxChar *) NULL ;
16948 wxChar *result = 0 ;
16949 void *argp1 = 0 ;
16950 int res1 = 0 ;
16951 void *argp2 = 0 ;
16952 int res2 = 0 ;
16953 void *argp3 = 0 ;
16954 int res3 = 0 ;
16955 PyObject * obj0 = 0 ;
16956 PyObject * obj1 = 0 ;
16957 PyObject * obj2 = 0 ;
16958 char * kwnames[] = {
16959 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
16960 };
16961
16962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyLocale_GetSingularString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
16964 if (!SWIG_IsOK(res1)) {
16965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetSingularString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
16966 }
16967 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
16968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
16969 if (!SWIG_IsOK(res2)) {
16970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetSingularString" "', expected argument " "2"" of type '" "wxChar const *""'");
16971 }
16972 arg2 = reinterpret_cast< wxChar * >(argp2);
16973 if (obj2) {
16974 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
16975 if (!SWIG_IsOK(res3)) {
16976 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetSingularString" "', expected argument " "3"" of type '" "wxChar const *""'");
16977 }
16978 arg3 = reinterpret_cast< wxChar * >(argp3);
16979 }
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 result = (wxChar *)((wxPyLocale const *)arg1)->GetSingularString((wxChar const *)arg2,(wxChar const *)arg3);
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_PyLocale_GetPluralString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 wxPyLocale *arg1 = (wxPyLocale *) 0 ;
16996 wxChar *arg2 = (wxChar *) 0 ;
16997 wxChar *arg3 = (wxChar *) 0 ;
16998 size_t arg4 ;
16999 wxChar *arg5 = (wxChar *) NULL ;
17000 wxChar *result = 0 ;
17001 void *argp1 = 0 ;
17002 int res1 = 0 ;
17003 void *argp2 = 0 ;
17004 int res2 = 0 ;
17005 void *argp3 = 0 ;
17006 int res3 = 0 ;
17007 size_t val4 ;
17008 int ecode4 = 0 ;
17009 void *argp5 = 0 ;
17010 int res5 = 0 ;
17011 PyObject * obj0 = 0 ;
17012 PyObject * obj1 = 0 ;
17013 PyObject * obj2 = 0 ;
17014 PyObject * obj3 = 0 ;
17015 PyObject * obj4 = 0 ;
17016 char * kwnames[] = {
17017 (char *) "self",(char *) "szOrigString",(char *) "szOrigString2",(char *) "n",(char *) "szDomain", NULL
17018 };
17019
17020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PyLocale_GetPluralString",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLocale, 0 | 0 );
17022 if (!SWIG_IsOK(res1)) {
17023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLocale_GetPluralString" "', expected argument " "1"" of type '" "wxPyLocale const *""'");
17024 }
17025 arg1 = reinterpret_cast< wxPyLocale * >(argp1);
17026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
17027 if (!SWIG_IsOK(res2)) {
17028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyLocale_GetPluralString" "', expected argument " "2"" of type '" "wxChar const *""'");
17029 }
17030 arg2 = reinterpret_cast< wxChar * >(argp2);
17031 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxChar, 0 | 0 );
17032 if (!SWIG_IsOK(res3)) {
17033 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyLocale_GetPluralString" "', expected argument " "3"" of type '" "wxChar const *""'");
17034 }
17035 arg3 = reinterpret_cast< wxChar * >(argp3);
17036 ecode4 = SWIG_AsVal_size_t(obj3, &val4);
17037 if (!SWIG_IsOK(ecode4)) {
17038 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyLocale_GetPluralString" "', expected argument " "4"" of type '" "size_t""'");
17039 }
17040 arg4 = static_cast< size_t >(val4);
17041 if (obj4) {
17042 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxChar, 0 | 0 );
17043 if (!SWIG_IsOK(res5)) {
17044 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PyLocale_GetPluralString" "', expected argument " "5"" of type '" "wxChar const *""'");
17045 }
17046 arg5 = reinterpret_cast< wxChar * >(argp5);
17047 }
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 result = (wxChar *)((wxPyLocale const *)arg1)->GetPluralString((wxChar const *)arg2,(wxChar const *)arg3,arg4,(wxChar const *)arg5);
17051 wxPyEndAllowThreads(__tstate);
17052 if (PyErr_Occurred()) SWIG_fail;
17053 }
17054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
17055 return resultobj;
17056 fail:
17057 return NULL;
17058 }
17059
17060
17061 SWIGINTERN PyObject *PyLocale_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17062 PyObject *obj;
17063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17064 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLocale, SWIG_NewClientData(obj));
17065 return SWIG_Py_Void();
17066 }
17067
17068 SWIGINTERN PyObject *PyLocale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17069 return SWIG_Python_InitShadowInstance(args);
17070 }
17071
17072 SWIGINTERN PyObject *_wrap_GetLocale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17073 PyObject *resultobj = 0;
17074 wxLocale *result = 0 ;
17075
17076 if (!SWIG_Python_UnpackTuple(args,"GetLocale",0,0,0)) SWIG_fail;
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (wxLocale *)wxGetLocale();
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLocale, 0 | 0 );
17084 return resultobj;
17085 fail:
17086 return NULL;
17087 }
17088
17089
17090 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
17091 PyObject *resultobj = 0;
17092 wxString *arg1 = 0 ;
17093 wxString result;
17094 bool temp1 = false ;
17095
17096 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
17097 {
17098 arg1 = wxString_in_helper(swig_obj[0]);
17099 if (arg1 == NULL) SWIG_fail;
17100 temp1 = true;
17101 }
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 result = wxGetTranslation((wxString const &)*arg1);
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 {
17109 #if wxUSE_UNICODE
17110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17111 #else
17112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17113 #endif
17114 }
17115 {
17116 if (temp1)
17117 delete arg1;
17118 }
17119 return resultobj;
17120 fail:
17121 {
17122 if (temp1)
17123 delete arg1;
17124 }
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
17130 PyObject *resultobj = 0;
17131 wxString *arg1 = 0 ;
17132 wxString *arg2 = 0 ;
17133 wxString result;
17134 bool temp1 = false ;
17135 bool temp2 = false ;
17136
17137 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
17138 {
17139 arg1 = wxString_in_helper(swig_obj[0]);
17140 if (arg1 == NULL) SWIG_fail;
17141 temp1 = true;
17142 }
17143 {
17144 arg2 = wxString_in_helper(swig_obj[1]);
17145 if (arg2 == NULL) SWIG_fail;
17146 temp2 = true;
17147 }
17148 {
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2);
17151 wxPyEndAllowThreads(__tstate);
17152 if (PyErr_Occurred()) SWIG_fail;
17153 }
17154 {
17155 #if wxUSE_UNICODE
17156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17157 #else
17158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17159 #endif
17160 }
17161 {
17162 if (temp1)
17163 delete arg1;
17164 }
17165 {
17166 if (temp2)
17167 delete arg2;
17168 }
17169 return resultobj;
17170 fail:
17171 {
17172 if (temp1)
17173 delete arg1;
17174 }
17175 {
17176 if (temp2)
17177 delete arg2;
17178 }
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
17184 PyObject *resultobj = 0;
17185 wxString *arg1 = 0 ;
17186 wxString *arg2 = 0 ;
17187 size_t arg3 ;
17188 wxString result;
17189 bool temp1 = false ;
17190 bool temp2 = false ;
17191 size_t val3 ;
17192 int ecode3 = 0 ;
17193
17194 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
17195 {
17196 arg1 = wxString_in_helper(swig_obj[0]);
17197 if (arg1 == NULL) SWIG_fail;
17198 temp1 = true;
17199 }
17200 {
17201 arg2 = wxString_in_helper(swig_obj[1]);
17202 if (arg2 == NULL) SWIG_fail;
17203 temp2 = true;
17204 }
17205 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
17206 if (!SWIG_IsOK(ecode3)) {
17207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
17208 }
17209 arg3 = static_cast< size_t >(val3);
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 #if wxUSE_UNICODE
17218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17219 #else
17220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17221 #endif
17222 }
17223 {
17224 if (temp1)
17225 delete arg1;
17226 }
17227 {
17228 if (temp2)
17229 delete arg2;
17230 }
17231 return resultobj;
17232 fail:
17233 {
17234 if (temp1)
17235 delete arg1;
17236 }
17237 {
17238 if (temp2)
17239 delete arg2;
17240 }
17241 return NULL;
17242 }
17243
17244
17245 SWIGINTERN PyObject *_wrap_GetTranslation__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
17246 PyObject *resultobj = 0;
17247 wxString *arg1 = 0 ;
17248 wxString *arg2 = 0 ;
17249 size_t arg3 ;
17250 wxString *arg4 = 0 ;
17251 wxString result;
17252 bool temp1 = false ;
17253 bool temp2 = false ;
17254 size_t val3 ;
17255 int ecode3 = 0 ;
17256 bool temp4 = false ;
17257
17258 if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
17259 {
17260 arg1 = wxString_in_helper(swig_obj[0]);
17261 if (arg1 == NULL) SWIG_fail;
17262 temp1 = true;
17263 }
17264 {
17265 arg2 = wxString_in_helper(swig_obj[1]);
17266 if (arg2 == NULL) SWIG_fail;
17267 temp2 = true;
17268 }
17269 ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
17270 if (!SWIG_IsOK(ecode3)) {
17271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTranslation" "', expected argument " "3"" of type '" "size_t""'");
17272 }
17273 arg3 = static_cast< size_t >(val3);
17274 {
17275 arg4 = wxString_in_helper(swig_obj[3]);
17276 if (arg4 == NULL) SWIG_fail;
17277 temp4 = true;
17278 }
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxString const &)*arg4);
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 #if wxUSE_UNICODE
17287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17288 #else
17289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17290 #endif
17291 }
17292 {
17293 if (temp1)
17294 delete arg1;
17295 }
17296 {
17297 if (temp2)
17298 delete arg2;
17299 }
17300 {
17301 if (temp4)
17302 delete arg4;
17303 }
17304 return resultobj;
17305 fail:
17306 {
17307 if (temp1)
17308 delete arg1;
17309 }
17310 {
17311 if (temp2)
17312 delete arg2;
17313 }
17314 {
17315 if (temp4)
17316 delete arg4;
17317 }
17318 return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
17323 int argc;
17324 PyObject *argv[5];
17325
17326 if (!(argc = SWIG_Python_UnpackTuple(args,"GetTranslation",0,4,argv))) SWIG_fail;
17327 --argc;
17328 if (argc == 1) {
17329 return _wrap_GetTranslation__SWIG_0(self, argc, argv);
17330 }
17331 if (argc == 2) {
17332 return _wrap_GetTranslation__SWIG_1(self, argc, argv);
17333 }
17334 if (argc == 3) {
17335 return _wrap_GetTranslation__SWIG_2(self, argc, argv);
17336 }
17337 if (argc == 4) {
17338 return _wrap_GetTranslation__SWIG_3(self, argc, argv);
17339 }
17340
17341 fail:
17342 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *_wrap_new_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *resultobj = 0;
17349 wxEncodingConverter *result = 0 ;
17350
17351 if (!SWIG_Python_UnpackTuple(args,"new_EncodingConverter",0,0,0)) SWIG_fail;
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (wxEncodingConverter *)new wxEncodingConverter();
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_NEW | 0 );
17359 return resultobj;
17360 fail:
17361 return NULL;
17362 }
17363
17364
17365 SWIGINTERN PyObject *_wrap_delete_EncodingConverter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 PyObject *resultobj = 0;
17367 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
17368 void *argp1 = 0 ;
17369 int res1 = 0 ;
17370 PyObject *swig_obj[1] ;
17371
17372 if (!args) SWIG_fail;
17373 swig_obj[0] = args;
17374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_DISOWN | 0 );
17375 if (!SWIG_IsOK(res1)) {
17376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodingConverter" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
17377 }
17378 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
17379 {
17380 PyThreadState* __tstate = wxPyBeginAllowThreads();
17381 delete arg1;
17382
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 resultobj = SWIG_Py_Void();
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *_wrap_EncodingConverter_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17394 PyObject *resultobj = 0;
17395 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
17396 wxFontEncoding arg2 ;
17397 wxFontEncoding arg3 ;
17398 int arg4 = (int) wxCONVERT_STRICT ;
17399 bool result;
17400 void *argp1 = 0 ;
17401 int res1 = 0 ;
17402 int val2 ;
17403 int ecode2 = 0 ;
17404 int val3 ;
17405 int ecode3 = 0 ;
17406 int val4 ;
17407 int ecode4 = 0 ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 PyObject * obj3 = 0 ;
17412 char * kwnames[] = {
17413 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
17414 };
17415
17416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
17418 if (!SWIG_IsOK(res1)) {
17419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Init" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
17420 }
17421 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
17422 ecode2 = SWIG_AsVal_int(obj1, &val2);
17423 if (!SWIG_IsOK(ecode2)) {
17424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_Init" "', expected argument " "2"" of type '" "wxFontEncoding""'");
17425 }
17426 arg2 = static_cast< wxFontEncoding >(val2);
17427 ecode3 = SWIG_AsVal_int(obj2, &val3);
17428 if (!SWIG_IsOK(ecode3)) {
17429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EncodingConverter_Init" "', expected argument " "3"" of type '" "wxFontEncoding""'");
17430 }
17431 arg3 = static_cast< wxFontEncoding >(val3);
17432 if (obj3) {
17433 ecode4 = SWIG_AsVal_int(obj3, &val4);
17434 if (!SWIG_IsOK(ecode4)) {
17435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EncodingConverter_Init" "', expected argument " "4"" of type '" "int""'");
17436 }
17437 arg4 = static_cast< int >(val4);
17438 }
17439 {
17440 PyThreadState* __tstate = wxPyBeginAllowThreads();
17441 result = (bool)(arg1)->Init(arg2,arg3,arg4);
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 return resultobj;
17449 fail:
17450 return NULL;
17451 }
17452
17453
17454 SWIGINTERN PyObject *_wrap_EncodingConverter_Convert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj = 0;
17456 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
17457 wxString *arg2 = 0 ;
17458 wxString result;
17459 void *argp1 = 0 ;
17460 int res1 = 0 ;
17461 bool temp2 = false ;
17462 PyObject * obj0 = 0 ;
17463 PyObject * obj1 = 0 ;
17464 char * kwnames[] = {
17465 (char *) "self",(char *) "input", NULL
17466 };
17467
17468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) SWIG_fail;
17469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEncodingConverter, 0 | 0 );
17470 if (!SWIG_IsOK(res1)) {
17471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncodingConverter_Convert" "', expected argument " "1"" of type '" "wxEncodingConverter *""'");
17472 }
17473 arg1 = reinterpret_cast< wxEncodingConverter * >(argp1);
17474 {
17475 arg2 = wxString_in_helper(obj1);
17476 if (arg2 == NULL) SWIG_fail;
17477 temp2 = true;
17478 }
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (arg1)->Convert((wxString const &)*arg2);
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 {
17486 #if wxUSE_UNICODE
17487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17488 #else
17489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17490 #endif
17491 }
17492 {
17493 if (temp2)
17494 delete arg2;
17495 }
17496 return resultobj;
17497 fail:
17498 {
17499 if (temp2)
17500 delete arg2;
17501 }
17502 return NULL;
17503 }
17504
17505
17506 SWIGINTERN PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj = 0;
17508 wxFontEncoding arg1 ;
17509 int arg2 = (int) wxPLATFORM_CURRENT ;
17510 wxFontEncodingArray result;
17511 int val1 ;
17512 int ecode1 = 0 ;
17513 int val2 ;
17514 int ecode2 = 0 ;
17515 PyObject * obj0 = 0 ;
17516 PyObject * obj1 = 0 ;
17517 char * kwnames[] = {
17518 (char *) "enc",(char *) "platform", NULL
17519 };
17520
17521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) SWIG_fail;
17522 ecode1 = SWIG_AsVal_int(obj0, &val1);
17523 if (!SWIG_IsOK(ecode1)) {
17524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
17525 }
17526 arg1 = static_cast< wxFontEncoding >(val1);
17527 if (obj1) {
17528 ecode2 = SWIG_AsVal_int(obj1, &val2);
17529 if (!SWIG_IsOK(ecode2)) {
17530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_GetPlatformEquivalents" "', expected argument " "2"" of type '" "int""'");
17531 }
17532 arg2 = static_cast< int >(val2);
17533 }
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = wxEncodingConverter::GetPlatformEquivalents(arg1,arg2);
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = PyList_New(0);
17542 for (size_t i=0; i < (&result)->GetCount(); i++) {
17543 PyObject* number = PyInt_FromLong((&result)->Item(i));
17544 PyList_Append(resultobj, number);
17545 Py_DECREF(number);
17546 }
17547 }
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 SWIGINTERN PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj = 0;
17556 wxFontEncoding arg1 ;
17557 wxFontEncodingArray result;
17558 int val1 ;
17559 int ecode1 = 0 ;
17560 PyObject * obj0 = 0 ;
17561 char * kwnames[] = {
17562 (char *) "enc", NULL
17563 };
17564
17565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) SWIG_fail;
17566 ecode1 = SWIG_AsVal_int(obj0, &val1);
17567 if (!SWIG_IsOK(ecode1)) {
17568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_GetAllEquivalents" "', expected argument " "1"" of type '" "wxFontEncoding""'");
17569 }
17570 arg1 = static_cast< wxFontEncoding >(val1);
17571 {
17572 PyThreadState* __tstate = wxPyBeginAllowThreads();
17573 result = wxEncodingConverter::GetAllEquivalents(arg1);
17574 wxPyEndAllowThreads(__tstate);
17575 if (PyErr_Occurred()) SWIG_fail;
17576 }
17577 {
17578 resultobj = PyList_New(0);
17579 for (size_t i=0; i < (&result)->GetCount(); i++) {
17580 PyObject* number = PyInt_FromLong((&result)->Item(i));
17581 PyList_Append(resultobj, number);
17582 Py_DECREF(number);
17583 }
17584 }
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *_wrap_EncodingConverter_CanConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17592 PyObject *resultobj = 0;
17593 wxFontEncoding arg1 ;
17594 wxFontEncoding arg2 ;
17595 bool result;
17596 int val1 ;
17597 int ecode1 = 0 ;
17598 int val2 ;
17599 int ecode2 = 0 ;
17600 PyObject * obj0 = 0 ;
17601 PyObject * obj1 = 0 ;
17602 char * kwnames[] = {
17603 (char *) "encIn",(char *) "encOut", NULL
17604 };
17605
17606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) SWIG_fail;
17607 ecode1 = SWIG_AsVal_int(obj0, &val1);
17608 if (!SWIG_IsOK(ecode1)) {
17609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EncodingConverter_CanConvert" "', expected argument " "1"" of type '" "wxFontEncoding""'");
17610 }
17611 arg1 = static_cast< wxFontEncoding >(val1);
17612 ecode2 = SWIG_AsVal_int(obj1, &val2);
17613 if (!SWIG_IsOK(ecode2)) {
17614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EncodingConverter_CanConvert" "', expected argument " "2"" of type '" "wxFontEncoding""'");
17615 }
17616 arg2 = static_cast< wxFontEncoding >(val2);
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (bool)wxEncodingConverter::CanConvert(arg1,arg2);
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 {
17624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17625 }
17626 return resultobj;
17627 fail:
17628 return NULL;
17629 }
17630
17631
17632 SWIGINTERN PyObject *EncodingConverter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17633 PyObject *obj;
17634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17635 SWIG_TypeNewClientData(SWIGTYPE_p_wxEncodingConverter, SWIG_NewClientData(obj));
17636 return SWIG_Py_Void();
17637 }
17638
17639 SWIGINTERN PyObject *EncodingConverter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17640 return SWIG_Python_InitShadowInstance(args);
17641 }
17642
17643 SWIGINTERN PyObject *_wrap_delete_DC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17644 PyObject *resultobj = 0;
17645 wxDC *arg1 = (wxDC *) 0 ;
17646 void *argp1 = 0 ;
17647 int res1 = 0 ;
17648 PyObject *swig_obj[1] ;
17649
17650 if (!args) SWIG_fail;
17651 swig_obj[0] = args;
17652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, SWIG_POINTER_DISOWN | 0 );
17653 if (!SWIG_IsOK(res1)) {
17654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DC" "', expected argument " "1"" of type '" "wxDC *""'");
17655 }
17656 arg1 = reinterpret_cast< wxDC * >(argp1);
17657 {
17658 PyThreadState* __tstate = wxPyBeginAllowThreads();
17659 delete arg1;
17660
17661 wxPyEndAllowThreads(__tstate);
17662 if (PyErr_Occurred()) SWIG_fail;
17663 }
17664 resultobj = SWIG_Py_Void();
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 SWIGINTERN PyObject *_wrap_DC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj = 0;
17673 wxDC *arg1 = (wxDC *) 0 ;
17674 int arg2 ;
17675 int arg3 ;
17676 wxColour *arg4 = 0 ;
17677 int arg5 = (int) wxFLOOD_SURFACE ;
17678 bool result;
17679 void *argp1 = 0 ;
17680 int res1 = 0 ;
17681 int val2 ;
17682 int ecode2 = 0 ;
17683 int val3 ;
17684 int ecode3 = 0 ;
17685 wxColour temp4 ;
17686 int val5 ;
17687 int ecode5 = 0 ;
17688 PyObject * obj0 = 0 ;
17689 PyObject * obj1 = 0 ;
17690 PyObject * obj2 = 0 ;
17691 PyObject * obj3 = 0 ;
17692 PyObject * obj4 = 0 ;
17693 char * kwnames[] = {
17694 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
17695 };
17696
17697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFill" "', expected argument " "1"" of type '" "wxDC *""'");
17701 }
17702 arg1 = reinterpret_cast< wxDC * >(argp1);
17703 ecode2 = SWIG_AsVal_int(obj1, &val2);
17704 if (!SWIG_IsOK(ecode2)) {
17705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_FloodFill" "', expected argument " "2"" of type '" "int""'");
17706 }
17707 arg2 = static_cast< int >(val2);
17708 ecode3 = SWIG_AsVal_int(obj2, &val3);
17709 if (!SWIG_IsOK(ecode3)) {
17710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_FloodFill" "', expected argument " "3"" of type '" "int""'");
17711 }
17712 arg3 = static_cast< int >(val3);
17713 {
17714 arg4 = &temp4;
17715 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17716 }
17717 if (obj4) {
17718 ecode5 = SWIG_AsVal_int(obj4, &val5);
17719 if (!SWIG_IsOK(ecode5)) {
17720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_FloodFill" "', expected argument " "5"" of type '" "int""'");
17721 }
17722 arg5 = static_cast< int >(val5);
17723 }
17724 {
17725 PyThreadState* __tstate = wxPyBeginAllowThreads();
17726 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 SWIGINTERN PyObject *_wrap_DC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj = 0;
17741 wxDC *arg1 = (wxDC *) 0 ;
17742 wxPoint *arg2 = 0 ;
17743 wxColour *arg3 = 0 ;
17744 int arg4 = (int) wxFLOOD_SURFACE ;
17745 bool result;
17746 void *argp1 = 0 ;
17747 int res1 = 0 ;
17748 wxPoint temp2 ;
17749 wxColour temp3 ;
17750 int val4 ;
17751 int ecode4 = 0 ;
17752 PyObject * obj0 = 0 ;
17753 PyObject * obj1 = 0 ;
17754 PyObject * obj2 = 0 ;
17755 PyObject * obj3 = 0 ;
17756 char * kwnames[] = {
17757 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
17758 };
17759
17760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17762 if (!SWIG_IsOK(res1)) {
17763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_FloodFillPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17764 }
17765 arg1 = reinterpret_cast< wxDC * >(argp1);
17766 {
17767 arg2 = &temp2;
17768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17769 }
17770 {
17771 arg3 = &temp3;
17772 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17773 }
17774 if (obj3) {
17775 ecode4 = SWIG_AsVal_int(obj3, &val4);
17776 if (!SWIG_IsOK(ecode4)) {
17777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
17778 }
17779 arg4 = static_cast< int >(val4);
17780 }
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 {
17788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17789 }
17790 return resultobj;
17791 fail:
17792 return NULL;
17793 }
17794
17795
17796 SWIGINTERN PyObject *_wrap_DC_GradientFillConcentric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17797 PyObject *resultobj = 0;
17798 wxDC *arg1 = (wxDC *) 0 ;
17799 wxRect *arg2 = 0 ;
17800 wxColour *arg3 = 0 ;
17801 wxColour *arg4 = 0 ;
17802 wxPoint *arg5 = 0 ;
17803 void *argp1 = 0 ;
17804 int res1 = 0 ;
17805 wxRect temp2 ;
17806 wxColour temp3 ;
17807 wxColour temp4 ;
17808 wxPoint temp5 ;
17809 PyObject * obj0 = 0 ;
17810 PyObject * obj1 = 0 ;
17811 PyObject * obj2 = 0 ;
17812 PyObject * obj3 = 0 ;
17813 PyObject * obj4 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "circleCenter", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_GradientFillConcentric",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillConcentric" "', expected argument " "1"" of type '" "wxDC *""'");
17822 }
17823 arg1 = reinterpret_cast< wxDC * >(argp1);
17824 {
17825 arg2 = &temp2;
17826 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17827 }
17828 {
17829 arg3 = &temp3;
17830 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17831 }
17832 {
17833 arg4 = &temp4;
17834 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17835 }
17836 {
17837 arg5 = &temp5;
17838 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
17839 }
17840 {
17841 PyThreadState* __tstate = wxPyBeginAllowThreads();
17842 (arg1)->GradientFillConcentric((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxPoint const &)*arg5);
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 resultobj = SWIG_Py_Void();
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 SWIGINTERN PyObject *_wrap_DC_GradientFillLinear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj = 0;
17855 wxDC *arg1 = (wxDC *) 0 ;
17856 wxRect *arg2 = 0 ;
17857 wxColour *arg3 = 0 ;
17858 wxColour *arg4 = 0 ;
17859 wxDirection arg5 = (wxDirection) wxEAST ;
17860 void *argp1 = 0 ;
17861 int res1 = 0 ;
17862 wxRect temp2 ;
17863 wxColour temp3 ;
17864 wxColour temp4 ;
17865 int val5 ;
17866 int ecode5 = 0 ;
17867 PyObject * obj0 = 0 ;
17868 PyObject * obj1 = 0 ;
17869 PyObject * obj2 = 0 ;
17870 PyObject * obj3 = 0 ;
17871 PyObject * obj4 = 0 ;
17872 char * kwnames[] = {
17873 (char *) "self",(char *) "rect",(char *) "initialColour",(char *) "destColour",(char *) "nDirection", NULL
17874 };
17875
17876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_GradientFillLinear",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17878 if (!SWIG_IsOK(res1)) {
17879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GradientFillLinear" "', expected argument " "1"" of type '" "wxDC *""'");
17880 }
17881 arg1 = reinterpret_cast< wxDC * >(argp1);
17882 {
17883 arg2 = &temp2;
17884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17885 }
17886 {
17887 arg3 = &temp3;
17888 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
17889 }
17890 {
17891 arg4 = &temp4;
17892 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
17893 }
17894 if (obj4) {
17895 ecode5 = SWIG_AsVal_int(obj4, &val5);
17896 if (!SWIG_IsOK(ecode5)) {
17897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_GradientFillLinear" "', expected argument " "5"" of type '" "wxDirection""'");
17898 }
17899 arg5 = static_cast< wxDirection >(val5);
17900 }
17901 {
17902 PyThreadState* __tstate = wxPyBeginAllowThreads();
17903 (arg1)->GradientFillLinear((wxRect const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,arg5);
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 resultobj = SWIG_Py_Void();
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 SWIGINTERN PyObject *_wrap_DC_GetPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj = 0;
17916 wxDC *arg1 = (wxDC *) 0 ;
17917 int arg2 ;
17918 int arg3 ;
17919 wxColour result;
17920 void *argp1 = 0 ;
17921 int res1 = 0 ;
17922 int val2 ;
17923 int ecode2 = 0 ;
17924 int val3 ;
17925 int ecode3 = 0 ;
17926 PyObject * obj0 = 0 ;
17927 PyObject * obj1 = 0 ;
17928 PyObject * obj2 = 0 ;
17929 char * kwnames[] = {
17930 (char *) "self",(char *) "x",(char *) "y", NULL
17931 };
17932
17933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17935 if (!SWIG_IsOK(res1)) {
17936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixel" "', expected argument " "1"" of type '" "wxDC *""'");
17937 }
17938 arg1 = reinterpret_cast< wxDC * >(argp1);
17939 ecode2 = SWIG_AsVal_int(obj1, &val2);
17940 if (!SWIG_IsOK(ecode2)) {
17941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_GetPixel" "', expected argument " "2"" of type '" "int""'");
17942 }
17943 arg2 = static_cast< int >(val2);
17944 ecode3 = SWIG_AsVal_int(obj2, &val3);
17945 if (!SWIG_IsOK(ecode3)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_GetPixel" "', expected argument " "3"" of type '" "int""'");
17947 }
17948 arg3 = static_cast< int >(val3);
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = wxDC_GetPixel(arg1,arg2,arg3);
17952 wxPyEndAllowThreads(__tstate);
17953 if (PyErr_Occurred()) SWIG_fail;
17954 }
17955 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17956 return resultobj;
17957 fail:
17958 return NULL;
17959 }
17960
17961
17962 SWIGINTERN PyObject *_wrap_DC_GetPixelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17963 PyObject *resultobj = 0;
17964 wxDC *arg1 = (wxDC *) 0 ;
17965 wxPoint *arg2 = 0 ;
17966 wxColour result;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 wxPoint temp2 ;
17970 PyObject * obj0 = 0 ;
17971 PyObject * obj1 = 0 ;
17972 char * kwnames[] = {
17973 (char *) "self",(char *) "pt", NULL
17974 };
17975
17976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) SWIG_fail;
17977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
17978 if (!SWIG_IsOK(res1)) {
17979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPixelPoint" "', expected argument " "1"" of type '" "wxDC *""'");
17980 }
17981 arg1 = reinterpret_cast< wxDC * >(argp1);
17982 {
17983 arg2 = &temp2;
17984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17985 }
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17993 return resultobj;
17994 fail:
17995 return NULL;
17996 }
17997
17998
17999 SWIGINTERN PyObject *_wrap_DC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18000 PyObject *resultobj = 0;
18001 wxDC *arg1 = (wxDC *) 0 ;
18002 int arg2 ;
18003 int arg3 ;
18004 int arg4 ;
18005 int arg5 ;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 int val2 ;
18009 int ecode2 = 0 ;
18010 int val3 ;
18011 int ecode3 = 0 ;
18012 int val4 ;
18013 int ecode4 = 0 ;
18014 int val5 ;
18015 int ecode5 = 0 ;
18016 PyObject * obj0 = 0 ;
18017 PyObject * obj1 = 0 ;
18018 PyObject * obj2 = 0 ;
18019 PyObject * obj3 = 0 ;
18020 PyObject * obj4 = 0 ;
18021 char * kwnames[] = {
18022 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
18023 };
18024
18025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18027 if (!SWIG_IsOK(res1)) {
18028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLine" "', expected argument " "1"" of type '" "wxDC *""'");
18029 }
18030 arg1 = reinterpret_cast< wxDC * >(argp1);
18031 ecode2 = SWIG_AsVal_int(obj1, &val2);
18032 if (!SWIG_IsOK(ecode2)) {
18033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawLine" "', expected argument " "2"" of type '" "int""'");
18034 }
18035 arg2 = static_cast< int >(val2);
18036 ecode3 = SWIG_AsVal_int(obj2, &val3);
18037 if (!SWIG_IsOK(ecode3)) {
18038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawLine" "', expected argument " "3"" of type '" "int""'");
18039 }
18040 arg3 = static_cast< int >(val3);
18041 ecode4 = SWIG_AsVal_int(obj3, &val4);
18042 if (!SWIG_IsOK(ecode4)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLine" "', expected argument " "4"" of type '" "int""'");
18044 }
18045 arg4 = static_cast< int >(val4);
18046 ecode5 = SWIG_AsVal_int(obj4, &val5);
18047 if (!SWIG_IsOK(ecode5)) {
18048 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLine" "', expected argument " "5"" of type '" "int""'");
18049 }
18050 arg5 = static_cast< int >(val5);
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
18054 wxPyEndAllowThreads(__tstate);
18055 if (PyErr_Occurred()) SWIG_fail;
18056 }
18057 resultobj = SWIG_Py_Void();
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 SWIGINTERN PyObject *_wrap_DC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18065 PyObject *resultobj = 0;
18066 wxDC *arg1 = (wxDC *) 0 ;
18067 wxPoint *arg2 = 0 ;
18068 wxPoint *arg3 = 0 ;
18069 void *argp1 = 0 ;
18070 int res1 = 0 ;
18071 wxPoint temp2 ;
18072 wxPoint temp3 ;
18073 PyObject * obj0 = 0 ;
18074 PyObject * obj1 = 0 ;
18075 PyObject * obj2 = 0 ;
18076 char * kwnames[] = {
18077 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
18078 };
18079
18080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18082 if (!SWIG_IsOK(res1)) {
18083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLinePoint" "', expected argument " "1"" of type '" "wxDC *""'");
18084 }
18085 arg1 = reinterpret_cast< wxDC * >(argp1);
18086 {
18087 arg2 = &temp2;
18088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18089 }
18090 {
18091 arg3 = &temp3;
18092 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18093 }
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = SWIG_Py_Void();
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_DC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj = 0;
18109 wxDC *arg1 = (wxDC *) 0 ;
18110 int arg2 ;
18111 int arg3 ;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 int val2 ;
18115 int ecode2 = 0 ;
18116 int val3 ;
18117 int ecode3 = 0 ;
18118 PyObject * obj0 = 0 ;
18119 PyObject * obj1 = 0 ;
18120 PyObject * obj2 = 0 ;
18121 char * kwnames[] = {
18122 (char *) "self",(char *) "x",(char *) "y", NULL
18123 };
18124
18125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHair" "', expected argument " "1"" of type '" "wxDC *""'");
18129 }
18130 arg1 = reinterpret_cast< wxDC * >(argp1);
18131 ecode2 = SWIG_AsVal_int(obj1, &val2);
18132 if (!SWIG_IsOK(ecode2)) {
18133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CrossHair" "', expected argument " "2"" of type '" "int""'");
18134 }
18135 arg2 = static_cast< int >(val2);
18136 ecode3 = SWIG_AsVal_int(obj2, &val3);
18137 if (!SWIG_IsOK(ecode3)) {
18138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CrossHair" "', expected argument " "3"" of type '" "int""'");
18139 }
18140 arg3 = static_cast< int >(val3);
18141 {
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 (arg1)->CrossHair(arg2,arg3);
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 resultobj = SWIG_Py_Void();
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 SWIGINTERN PyObject *_wrap_DC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18155 PyObject *resultobj = 0;
18156 wxDC *arg1 = (wxDC *) 0 ;
18157 wxPoint *arg2 = 0 ;
18158 void *argp1 = 0 ;
18159 int res1 = 0 ;
18160 wxPoint temp2 ;
18161 PyObject * obj0 = 0 ;
18162 PyObject * obj1 = 0 ;
18163 char * kwnames[] = {
18164 (char *) "self",(char *) "pt", NULL
18165 };
18166
18167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
18168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18169 if (!SWIG_IsOK(res1)) {
18170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CrossHairPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18171 }
18172 arg1 = reinterpret_cast< wxDC * >(argp1);
18173 {
18174 arg2 = &temp2;
18175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18176 }
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 (arg1)->CrossHair((wxPoint const &)*arg2);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = SWIG_Py_Void();
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_DC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj = 0;
18192 wxDC *arg1 = (wxDC *) 0 ;
18193 int arg2 ;
18194 int arg3 ;
18195 int arg4 ;
18196 int arg5 ;
18197 int arg6 ;
18198 int arg7 ;
18199 void *argp1 = 0 ;
18200 int res1 = 0 ;
18201 int val2 ;
18202 int ecode2 = 0 ;
18203 int val3 ;
18204 int ecode3 = 0 ;
18205 int val4 ;
18206 int ecode4 = 0 ;
18207 int val5 ;
18208 int ecode5 = 0 ;
18209 int val6 ;
18210 int ecode6 = 0 ;
18211 int val7 ;
18212 int ecode7 = 0 ;
18213 PyObject * obj0 = 0 ;
18214 PyObject * obj1 = 0 ;
18215 PyObject * obj2 = 0 ;
18216 PyObject * obj3 = 0 ;
18217 PyObject * obj4 = 0 ;
18218 PyObject * obj5 = 0 ;
18219 PyObject * obj6 = 0 ;
18220 char * kwnames[] = {
18221 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
18222 };
18223
18224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArc" "', expected argument " "1"" of type '" "wxDC *""'");
18228 }
18229 arg1 = reinterpret_cast< wxDC * >(argp1);
18230 ecode2 = SWIG_AsVal_int(obj1, &val2);
18231 if (!SWIG_IsOK(ecode2)) {
18232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawArc" "', expected argument " "2"" of type '" "int""'");
18233 }
18234 arg2 = static_cast< int >(val2);
18235 ecode3 = SWIG_AsVal_int(obj2, &val3);
18236 if (!SWIG_IsOK(ecode3)) {
18237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawArc" "', expected argument " "3"" of type '" "int""'");
18238 }
18239 arg3 = static_cast< int >(val3);
18240 ecode4 = SWIG_AsVal_int(obj3, &val4);
18241 if (!SWIG_IsOK(ecode4)) {
18242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawArc" "', expected argument " "4"" of type '" "int""'");
18243 }
18244 arg4 = static_cast< int >(val4);
18245 ecode5 = SWIG_AsVal_int(obj4, &val5);
18246 if (!SWIG_IsOK(ecode5)) {
18247 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawArc" "', expected argument " "5"" of type '" "int""'");
18248 }
18249 arg5 = static_cast< int >(val5);
18250 ecode6 = SWIG_AsVal_int(obj5, &val6);
18251 if (!SWIG_IsOK(ecode6)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawArc" "', expected argument " "6"" of type '" "int""'");
18253 }
18254 arg6 = static_cast< int >(val6);
18255 ecode7 = SWIG_AsVal_int(obj6, &val7);
18256 if (!SWIG_IsOK(ecode7)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawArc" "', expected argument " "7"" of type '" "int""'");
18258 }
18259 arg7 = static_cast< int >(val7);
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 resultobj = SWIG_Py_Void();
18267 return resultobj;
18268 fail:
18269 return NULL;
18270 }
18271
18272
18273 SWIGINTERN PyObject *_wrap_DC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj = 0;
18275 wxDC *arg1 = (wxDC *) 0 ;
18276 wxPoint *arg2 = 0 ;
18277 wxPoint *arg3 = 0 ;
18278 wxPoint *arg4 = 0 ;
18279 void *argp1 = 0 ;
18280 int res1 = 0 ;
18281 wxPoint temp2 ;
18282 wxPoint temp3 ;
18283 wxPoint temp4 ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 PyObject * obj2 = 0 ;
18287 PyObject * obj3 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawArcPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18296 }
18297 arg1 = reinterpret_cast< wxDC * >(argp1);
18298 {
18299 arg2 = &temp2;
18300 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18301 }
18302 {
18303 arg3 = &temp3;
18304 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18305 }
18306 {
18307 arg4 = &temp4;
18308 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
18309 }
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 resultobj = SWIG_Py_Void();
18317 return resultobj;
18318 fail:
18319 return NULL;
18320 }
18321
18322
18323 SWIGINTERN PyObject *_wrap_DC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18324 PyObject *resultobj = 0;
18325 wxDC *arg1 = (wxDC *) 0 ;
18326 int arg2 ;
18327 int arg3 ;
18328 int arg4 ;
18329 int arg5 ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 int val2 ;
18333 int ecode2 = 0 ;
18334 int val3 ;
18335 int ecode3 = 0 ;
18336 int val4 ;
18337 int ecode4 = 0 ;
18338 int val5 ;
18339 int ecode5 = 0 ;
18340 PyObject * obj0 = 0 ;
18341 PyObject * obj1 = 0 ;
18342 PyObject * obj2 = 0 ;
18343 PyObject * obj3 = 0 ;
18344 PyObject * obj4 = 0 ;
18345 char * kwnames[] = {
18346 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18347 };
18348
18349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18351 if (!SWIG_IsOK(res1)) {
18352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMark" "', expected argument " "1"" of type '" "wxDC *""'");
18353 }
18354 arg1 = reinterpret_cast< wxDC * >(argp1);
18355 ecode2 = SWIG_AsVal_int(obj1, &val2);
18356 if (!SWIG_IsOK(ecode2)) {
18357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
18358 }
18359 arg2 = static_cast< int >(val2);
18360 ecode3 = SWIG_AsVal_int(obj2, &val3);
18361 if (!SWIG_IsOK(ecode3)) {
18362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
18363 }
18364 arg3 = static_cast< int >(val3);
18365 ecode4 = SWIG_AsVal_int(obj3, &val4);
18366 if (!SWIG_IsOK(ecode4)) {
18367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
18368 }
18369 arg4 = static_cast< int >(val4);
18370 ecode5 = SWIG_AsVal_int(obj4, &val5);
18371 if (!SWIG_IsOK(ecode5)) {
18372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
18373 }
18374 arg5 = static_cast< int >(val5);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 resultobj = SWIG_Py_Void();
18382 return resultobj;
18383 fail:
18384 return NULL;
18385 }
18386
18387
18388 SWIGINTERN PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18389 PyObject *resultobj = 0;
18390 wxDC *arg1 = (wxDC *) 0 ;
18391 wxRect *arg2 = 0 ;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 wxRect temp2 ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char * kwnames[] = {
18398 (char *) "self",(char *) "rect", NULL
18399 };
18400
18401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
18402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18403 if (!SWIG_IsOK(res1)) {
18404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxDC *""'");
18405 }
18406 arg1 = reinterpret_cast< wxDC * >(argp1);
18407 {
18408 arg2 = &temp2;
18409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18410 }
18411 {
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 (arg1)->DrawCheckMark((wxRect const &)*arg2);
18414 wxPyEndAllowThreads(__tstate);
18415 if (PyErr_Occurred()) SWIG_fail;
18416 }
18417 resultobj = SWIG_Py_Void();
18418 return resultobj;
18419 fail:
18420 return NULL;
18421 }
18422
18423
18424 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18425 PyObject *resultobj = 0;
18426 wxDC *arg1 = (wxDC *) 0 ;
18427 int arg2 ;
18428 int arg3 ;
18429 int arg4 ;
18430 int arg5 ;
18431 double arg6 ;
18432 double arg7 ;
18433 void *argp1 = 0 ;
18434 int res1 = 0 ;
18435 int val2 ;
18436 int ecode2 = 0 ;
18437 int val3 ;
18438 int ecode3 = 0 ;
18439 int val4 ;
18440 int ecode4 = 0 ;
18441 int val5 ;
18442 int ecode5 = 0 ;
18443 double val6 ;
18444 int ecode6 = 0 ;
18445 double val7 ;
18446 int ecode7 = 0 ;
18447 PyObject * obj0 = 0 ;
18448 PyObject * obj1 = 0 ;
18449 PyObject * obj2 = 0 ;
18450 PyObject * obj3 = 0 ;
18451 PyObject * obj4 = 0 ;
18452 PyObject * obj5 = 0 ;
18453 PyObject * obj6 = 0 ;
18454 char * kwnames[] = {
18455 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
18456 };
18457
18458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18460 if (!SWIG_IsOK(res1)) {
18461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxDC *""'");
18462 }
18463 arg1 = reinterpret_cast< wxDC * >(argp1);
18464 ecode2 = SWIG_AsVal_int(obj1, &val2);
18465 if (!SWIG_IsOK(ecode2)) {
18466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
18467 }
18468 arg2 = static_cast< int >(val2);
18469 ecode3 = SWIG_AsVal_int(obj2, &val3);
18470 if (!SWIG_IsOK(ecode3)) {
18471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
18472 }
18473 arg3 = static_cast< int >(val3);
18474 ecode4 = SWIG_AsVal_int(obj3, &val4);
18475 if (!SWIG_IsOK(ecode4)) {
18476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
18477 }
18478 arg4 = static_cast< int >(val4);
18479 ecode5 = SWIG_AsVal_int(obj4, &val5);
18480 if (!SWIG_IsOK(ecode5)) {
18481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
18482 }
18483 arg5 = static_cast< int >(val5);
18484 ecode6 = SWIG_AsVal_double(obj5, &val6);
18485 if (!SWIG_IsOK(ecode6)) {
18486 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
18487 }
18488 arg6 = static_cast< double >(val6);
18489 ecode7 = SWIG_AsVal_double(obj6, &val7);
18490 if (!SWIG_IsOK(ecode7)) {
18491 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
18492 }
18493 arg7 = static_cast< double >(val7);
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
18497 wxPyEndAllowThreads(__tstate);
18498 if (PyErr_Occurred()) SWIG_fail;
18499 }
18500 resultobj = SWIG_Py_Void();
18501 return resultobj;
18502 fail:
18503 return NULL;
18504 }
18505
18506
18507 SWIGINTERN PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18508 PyObject *resultobj = 0;
18509 wxDC *arg1 = (wxDC *) 0 ;
18510 wxPoint *arg2 = 0 ;
18511 wxSize *arg3 = 0 ;
18512 double arg4 ;
18513 double arg5 ;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 wxPoint temp2 ;
18517 wxSize temp3 ;
18518 double val4 ;
18519 int ecode4 = 0 ;
18520 double val5 ;
18521 int ecode5 = 0 ;
18522 PyObject * obj0 = 0 ;
18523 PyObject * obj1 = 0 ;
18524 PyObject * obj2 = 0 ;
18525 PyObject * obj3 = 0 ;
18526 PyObject * obj4 = 0 ;
18527 char * kwnames[] = {
18528 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
18529 };
18530
18531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18533 if (!SWIG_IsOK(res1)) {
18534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18535 }
18536 arg1 = reinterpret_cast< wxDC * >(argp1);
18537 {
18538 arg2 = &temp2;
18539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18540 }
18541 {
18542 arg3 = &temp3;
18543 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18544 }
18545 ecode4 = SWIG_AsVal_double(obj3, &val4);
18546 if (!SWIG_IsOK(ecode4)) {
18547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
18548 }
18549 arg4 = static_cast< double >(val4);
18550 ecode5 = SWIG_AsVal_double(obj4, &val5);
18551 if (!SWIG_IsOK(ecode5)) {
18552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
18553 }
18554 arg5 = static_cast< double >(val5);
18555 {
18556 PyThreadState* __tstate = wxPyBeginAllowThreads();
18557 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_Py_Void();
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 SWIGINTERN PyObject *_wrap_DC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj = 0;
18570 wxDC *arg1 = (wxDC *) 0 ;
18571 int arg2 ;
18572 int arg3 ;
18573 void *argp1 = 0 ;
18574 int res1 = 0 ;
18575 int val2 ;
18576 int ecode2 = 0 ;
18577 int val3 ;
18578 int ecode3 = 0 ;
18579 PyObject * obj0 = 0 ;
18580 PyObject * obj1 = 0 ;
18581 PyObject * obj2 = 0 ;
18582 char * kwnames[] = {
18583 (char *) "self",(char *) "x",(char *) "y", NULL
18584 };
18585
18586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18588 if (!SWIG_IsOK(res1)) {
18589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18590 }
18591 arg1 = reinterpret_cast< wxDC * >(argp1);
18592 ecode2 = SWIG_AsVal_int(obj1, &val2);
18593 if (!SWIG_IsOK(ecode2)) {
18594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
18595 }
18596 arg2 = static_cast< int >(val2);
18597 ecode3 = SWIG_AsVal_int(obj2, &val3);
18598 if (!SWIG_IsOK(ecode3)) {
18599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
18600 }
18601 arg3 = static_cast< int >(val3);
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 (arg1)->DrawPoint(arg2,arg3);
18605 wxPyEndAllowThreads(__tstate);
18606 if (PyErr_Occurred()) SWIG_fail;
18607 }
18608 resultobj = SWIG_Py_Void();
18609 return resultobj;
18610 fail:
18611 return NULL;
18612 }
18613
18614
18615 SWIGINTERN PyObject *_wrap_DC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18616 PyObject *resultobj = 0;
18617 wxDC *arg1 = (wxDC *) 0 ;
18618 wxPoint *arg2 = 0 ;
18619 void *argp1 = 0 ;
18620 int res1 = 0 ;
18621 wxPoint temp2 ;
18622 PyObject * obj0 = 0 ;
18623 PyObject * obj1 = 0 ;
18624 char * kwnames[] = {
18625 (char *) "self",(char *) "pt", NULL
18626 };
18627
18628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
18629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18630 if (!SWIG_IsOK(res1)) {
18631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPointPoint" "', expected argument " "1"" of type '" "wxDC *""'");
18632 }
18633 arg1 = reinterpret_cast< wxDC * >(argp1);
18634 {
18635 arg2 = &temp2;
18636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18637 }
18638 {
18639 PyThreadState* __tstate = wxPyBeginAllowThreads();
18640 (arg1)->DrawPoint((wxPoint const &)*arg2);
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 resultobj = SWIG_Py_Void();
18645 return resultobj;
18646 fail:
18647 return NULL;
18648 }
18649
18650
18651 SWIGINTERN PyObject *_wrap_DC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18652 PyObject *resultobj = 0;
18653 wxDC *arg1 = (wxDC *) 0 ;
18654 int arg2 ;
18655 int arg3 ;
18656 int arg4 ;
18657 int arg5 ;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 int val2 ;
18661 int ecode2 = 0 ;
18662 int val3 ;
18663 int ecode3 = 0 ;
18664 int val4 ;
18665 int ecode4 = 0 ;
18666 int val5 ;
18667 int ecode5 = 0 ;
18668 PyObject * obj0 = 0 ;
18669 PyObject * obj1 = 0 ;
18670 PyObject * obj2 = 0 ;
18671 PyObject * obj3 = 0 ;
18672 PyObject * obj4 = 0 ;
18673 char * kwnames[] = {
18674 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
18675 };
18676
18677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18679 if (!SWIG_IsOK(res1)) {
18680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18681 }
18682 arg1 = reinterpret_cast< wxDC * >(argp1);
18683 ecode2 = SWIG_AsVal_int(obj1, &val2);
18684 if (!SWIG_IsOK(ecode2)) {
18685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
18686 }
18687 arg2 = static_cast< int >(val2);
18688 ecode3 = SWIG_AsVal_int(obj2, &val3);
18689 if (!SWIG_IsOK(ecode3)) {
18690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
18691 }
18692 arg3 = static_cast< int >(val3);
18693 ecode4 = SWIG_AsVal_int(obj3, &val4);
18694 if (!SWIG_IsOK(ecode4)) {
18695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
18696 }
18697 arg4 = static_cast< int >(val4);
18698 ecode5 = SWIG_AsVal_int(obj4, &val5);
18699 if (!SWIG_IsOK(ecode5)) {
18700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
18701 }
18702 arg5 = static_cast< int >(val5);
18703 {
18704 PyThreadState* __tstate = wxPyBeginAllowThreads();
18705 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
18706 wxPyEndAllowThreads(__tstate);
18707 if (PyErr_Occurred()) SWIG_fail;
18708 }
18709 resultobj = SWIG_Py_Void();
18710 return resultobj;
18711 fail:
18712 return NULL;
18713 }
18714
18715
18716 SWIGINTERN PyObject *_wrap_DC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18717 PyObject *resultobj = 0;
18718 wxDC *arg1 = (wxDC *) 0 ;
18719 wxRect *arg2 = 0 ;
18720 void *argp1 = 0 ;
18721 int res1 = 0 ;
18722 wxRect temp2 ;
18723 PyObject * obj0 = 0 ;
18724 PyObject * obj1 = 0 ;
18725 char * kwnames[] = {
18726 (char *) "self",(char *) "rect", NULL
18727 };
18728
18729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
18730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18731 if (!SWIG_IsOK(res1)) {
18732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18733 }
18734 arg1 = reinterpret_cast< wxDC * >(argp1);
18735 {
18736 arg2 = &temp2;
18737 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18738 }
18739 {
18740 PyThreadState* __tstate = wxPyBeginAllowThreads();
18741 (arg1)->DrawRectangle((wxRect const &)*arg2);
18742 wxPyEndAllowThreads(__tstate);
18743 if (PyErr_Occurred()) SWIG_fail;
18744 }
18745 resultobj = SWIG_Py_Void();
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 SWIGINTERN PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18753 PyObject *resultobj = 0;
18754 wxDC *arg1 = (wxDC *) 0 ;
18755 wxPoint *arg2 = 0 ;
18756 wxSize *arg3 = 0 ;
18757 void *argp1 = 0 ;
18758 int res1 = 0 ;
18759 wxPoint temp2 ;
18760 wxSize temp3 ;
18761 PyObject * obj0 = 0 ;
18762 PyObject * obj1 = 0 ;
18763 PyObject * obj2 = 0 ;
18764 char * kwnames[] = {
18765 (char *) "self",(char *) "pt",(char *) "sz", NULL
18766 };
18767
18768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18770 if (!SWIG_IsOK(res1)) {
18771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18772 }
18773 arg1 = reinterpret_cast< wxDC * >(argp1);
18774 {
18775 arg2 = &temp2;
18776 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18777 }
18778 {
18779 arg3 = &temp3;
18780 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18781 }
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
18785 wxPyEndAllowThreads(__tstate);
18786 if (PyErr_Occurred()) SWIG_fail;
18787 }
18788 resultobj = SWIG_Py_Void();
18789 return resultobj;
18790 fail:
18791 return NULL;
18792 }
18793
18794
18795 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj = 0;
18797 wxDC *arg1 = (wxDC *) 0 ;
18798 int arg2 ;
18799 int arg3 ;
18800 int arg4 ;
18801 int arg5 ;
18802 double arg6 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 int val2 ;
18806 int ecode2 = 0 ;
18807 int val3 ;
18808 int ecode3 = 0 ;
18809 int val4 ;
18810 int ecode4 = 0 ;
18811 int val5 ;
18812 int ecode5 = 0 ;
18813 double val6 ;
18814 int ecode6 = 0 ;
18815 PyObject * obj0 = 0 ;
18816 PyObject * obj1 = 0 ;
18817 PyObject * obj2 = 0 ;
18818 PyObject * obj3 = 0 ;
18819 PyObject * obj4 = 0 ;
18820 PyObject * obj5 = 0 ;
18821 char * kwnames[] = {
18822 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
18823 };
18824
18825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18827 if (!SWIG_IsOK(res1)) {
18828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxDC *""'");
18829 }
18830 arg1 = reinterpret_cast< wxDC * >(argp1);
18831 ecode2 = SWIG_AsVal_int(obj1, &val2);
18832 if (!SWIG_IsOK(ecode2)) {
18833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
18834 }
18835 arg2 = static_cast< int >(val2);
18836 ecode3 = SWIG_AsVal_int(obj2, &val3);
18837 if (!SWIG_IsOK(ecode3)) {
18838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
18839 }
18840 arg3 = static_cast< int >(val3);
18841 ecode4 = SWIG_AsVal_int(obj3, &val4);
18842 if (!SWIG_IsOK(ecode4)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
18844 }
18845 arg4 = static_cast< int >(val4);
18846 ecode5 = SWIG_AsVal_int(obj4, &val5);
18847 if (!SWIG_IsOK(ecode5)) {
18848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
18849 }
18850 arg5 = static_cast< int >(val5);
18851 ecode6 = SWIG_AsVal_double(obj5, &val6);
18852 if (!SWIG_IsOK(ecode6)) {
18853 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
18854 }
18855 arg6 = static_cast< double >(val6);
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 resultobj = SWIG_Py_Void();
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj = 0;
18871 wxDC *arg1 = (wxDC *) 0 ;
18872 wxRect *arg2 = 0 ;
18873 double arg3 ;
18874 void *argp1 = 0 ;
18875 int res1 = 0 ;
18876 wxRect temp2 ;
18877 double val3 ;
18878 int ecode3 = 0 ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 PyObject * obj2 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "self",(char *) "r",(char *) "radius", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxDC *""'");
18890 }
18891 arg1 = reinterpret_cast< wxDC * >(argp1);
18892 {
18893 arg2 = &temp2;
18894 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18895 }
18896 ecode3 = SWIG_AsVal_double(obj2, &val3);
18897 if (!SWIG_IsOK(ecode3)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
18899 }
18900 arg3 = static_cast< double >(val3);
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 resultobj = SWIG_Py_Void();
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 SWIGINTERN PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj = 0;
18916 wxDC *arg1 = (wxDC *) 0 ;
18917 wxPoint *arg2 = 0 ;
18918 wxSize *arg3 = 0 ;
18919 double arg4 ;
18920 void *argp1 = 0 ;
18921 int res1 = 0 ;
18922 wxPoint temp2 ;
18923 wxSize temp3 ;
18924 double val4 ;
18925 int ecode4 = 0 ;
18926 PyObject * obj0 = 0 ;
18927 PyObject * obj1 = 0 ;
18928 PyObject * obj2 = 0 ;
18929 PyObject * obj3 = 0 ;
18930 char * kwnames[] = {
18931 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
18932 };
18933
18934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18936 if (!SWIG_IsOK(res1)) {
18937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
18938 }
18939 arg1 = reinterpret_cast< wxDC * >(argp1);
18940 {
18941 arg2 = &temp2;
18942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18943 }
18944 {
18945 arg3 = &temp3;
18946 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
18947 }
18948 ecode4 = SWIG_AsVal_double(obj3, &val4);
18949 if (!SWIG_IsOK(ecode4)) {
18950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
18951 }
18952 arg4 = static_cast< double >(val4);
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_Py_Void();
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *_wrap_DC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj = 0;
18968 wxDC *arg1 = (wxDC *) 0 ;
18969 int arg2 ;
18970 int arg3 ;
18971 int arg4 ;
18972 void *argp1 = 0 ;
18973 int res1 = 0 ;
18974 int val2 ;
18975 int ecode2 = 0 ;
18976 int val3 ;
18977 int ecode3 = 0 ;
18978 int val4 ;
18979 int ecode4 = 0 ;
18980 PyObject * obj0 = 0 ;
18981 PyObject * obj1 = 0 ;
18982 PyObject * obj2 = 0 ;
18983 PyObject * obj3 = 0 ;
18984 char * kwnames[] = {
18985 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
18986 };
18987
18988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCircle" "', expected argument " "1"" of type '" "wxDC *""'");
18992 }
18993 arg1 = reinterpret_cast< wxDC * >(argp1);
18994 ecode2 = SWIG_AsVal_int(obj1, &val2);
18995 if (!SWIG_IsOK(ecode2)) {
18996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
18997 }
18998 arg2 = static_cast< int >(val2);
18999 ecode3 = SWIG_AsVal_int(obj2, &val3);
19000 if (!SWIG_IsOK(ecode3)) {
19001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
19002 }
19003 arg3 = static_cast< int >(val3);
19004 ecode4 = SWIG_AsVal_int(obj3, &val4);
19005 if (!SWIG_IsOK(ecode4)) {
19006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
19007 }
19008 arg4 = static_cast< int >(val4);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 (arg1)->DrawCircle(arg2,arg3,arg4);
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_Py_Void();
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_DC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19023 PyObject *resultobj = 0;
19024 wxDC *arg1 = (wxDC *) 0 ;
19025 wxPoint *arg2 = 0 ;
19026 int arg3 ;
19027 void *argp1 = 0 ;
19028 int res1 = 0 ;
19029 wxPoint temp2 ;
19030 int val3 ;
19031 int ecode3 = 0 ;
19032 PyObject * obj0 = 0 ;
19033 PyObject * obj1 = 0 ;
19034 PyObject * obj2 = 0 ;
19035 char * kwnames[] = {
19036 (char *) "self",(char *) "pt",(char *) "radius", NULL
19037 };
19038
19039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19041 if (!SWIG_IsOK(res1)) {
19042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxDC *""'");
19043 }
19044 arg1 = reinterpret_cast< wxDC * >(argp1);
19045 {
19046 arg2 = &temp2;
19047 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19048 }
19049 ecode3 = SWIG_AsVal_int(obj2, &val3);
19050 if (!SWIG_IsOK(ecode3)) {
19051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
19052 }
19053 arg3 = static_cast< int >(val3);
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 resultobj = SWIG_Py_Void();
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_DC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19068 PyObject *resultobj = 0;
19069 wxDC *arg1 = (wxDC *) 0 ;
19070 int arg2 ;
19071 int arg3 ;
19072 int arg4 ;
19073 int arg5 ;
19074 void *argp1 = 0 ;
19075 int res1 = 0 ;
19076 int val2 ;
19077 int ecode2 = 0 ;
19078 int val3 ;
19079 int ecode3 = 0 ;
19080 int val4 ;
19081 int ecode4 = 0 ;
19082 int val5 ;
19083 int ecode5 = 0 ;
19084 PyObject * obj0 = 0 ;
19085 PyObject * obj1 = 0 ;
19086 PyObject * obj2 = 0 ;
19087 PyObject * obj3 = 0 ;
19088 PyObject * obj4 = 0 ;
19089 char * kwnames[] = {
19090 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19091 };
19092
19093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipse" "', expected argument " "1"" of type '" "wxDC *""'");
19097 }
19098 arg1 = reinterpret_cast< wxDC * >(argp1);
19099 ecode2 = SWIG_AsVal_int(obj1, &val2);
19100 if (!SWIG_IsOK(ecode2)) {
19101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
19102 }
19103 arg2 = static_cast< int >(val2);
19104 ecode3 = SWIG_AsVal_int(obj2, &val3);
19105 if (!SWIG_IsOK(ecode3)) {
19106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
19107 }
19108 arg3 = static_cast< int >(val3);
19109 ecode4 = SWIG_AsVal_int(obj3, &val4);
19110 if (!SWIG_IsOK(ecode4)) {
19111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
19112 }
19113 arg4 = static_cast< int >(val4);
19114 ecode5 = SWIG_AsVal_int(obj4, &val5);
19115 if (!SWIG_IsOK(ecode5)) {
19116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
19117 }
19118 arg5 = static_cast< int >(val5);
19119 {
19120 PyThreadState* __tstate = wxPyBeginAllowThreads();
19121 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 resultobj = SWIG_Py_Void();
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 SWIGINTERN PyObject *_wrap_DC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj = 0;
19134 wxDC *arg1 = (wxDC *) 0 ;
19135 wxRect *arg2 = 0 ;
19136 void *argp1 = 0 ;
19137 int res1 = 0 ;
19138 wxRect temp2 ;
19139 PyObject * obj0 = 0 ;
19140 PyObject * obj1 = 0 ;
19141 char * kwnames[] = {
19142 (char *) "self",(char *) "rect", NULL
19143 };
19144
19145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
19146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19147 if (!SWIG_IsOK(res1)) {
19148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxDC *""'");
19149 }
19150 arg1 = reinterpret_cast< wxDC * >(argp1);
19151 {
19152 arg2 = &temp2;
19153 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19154 }
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 (arg1)->DrawEllipse((wxRect const &)*arg2);
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_Py_Void();
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 SWIGINTERN PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj = 0;
19170 wxDC *arg1 = (wxDC *) 0 ;
19171 wxPoint *arg2 = 0 ;
19172 wxSize *arg3 = 0 ;
19173 void *argp1 = 0 ;
19174 int res1 = 0 ;
19175 wxPoint temp2 ;
19176 wxSize temp3 ;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 PyObject * obj2 = 0 ;
19180 char * kwnames[] = {
19181 (char *) "self",(char *) "pt",(char *) "sz", NULL
19182 };
19183
19184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19188 }
19189 arg1 = reinterpret_cast< wxDC * >(argp1);
19190 {
19191 arg2 = &temp2;
19192 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19193 }
19194 {
19195 arg3 = &temp3;
19196 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19197 }
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 resultobj = SWIG_Py_Void();
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 SWIGINTERN PyObject *_wrap_DC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 wxDC *arg1 = (wxDC *) 0 ;
19214 wxIcon *arg2 = 0 ;
19215 int arg3 ;
19216 int arg4 ;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 void *argp2 = 0 ;
19220 int res2 = 0 ;
19221 int val3 ;
19222 int ecode3 = 0 ;
19223 int val4 ;
19224 int ecode4 = 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 PyObject * obj2 = 0 ;
19228 PyObject * obj3 = 0 ;
19229 char * kwnames[] = {
19230 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
19231 };
19232
19233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19235 if (!SWIG_IsOK(res1)) {
19236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIcon" "', expected argument " "1"" of type '" "wxDC *""'");
19237 }
19238 arg1 = reinterpret_cast< wxDC * >(argp1);
19239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
19240 if (!SWIG_IsOK(res2)) {
19241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
19242 }
19243 if (!argp2) {
19244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
19245 }
19246 arg2 = reinterpret_cast< wxIcon * >(argp2);
19247 ecode3 = SWIG_AsVal_int(obj2, &val3);
19248 if (!SWIG_IsOK(ecode3)) {
19249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
19250 }
19251 arg3 = static_cast< int >(val3);
19252 ecode4 = SWIG_AsVal_int(obj3, &val4);
19253 if (!SWIG_IsOK(ecode4)) {
19254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
19255 }
19256 arg4 = static_cast< int >(val4);
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 resultobj = SWIG_Py_Void();
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *_wrap_DC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19271 PyObject *resultobj = 0;
19272 wxDC *arg1 = (wxDC *) 0 ;
19273 wxIcon *arg2 = 0 ;
19274 wxPoint *arg3 = 0 ;
19275 void *argp1 = 0 ;
19276 int res1 = 0 ;
19277 void *argp2 = 0 ;
19278 int res2 = 0 ;
19279 wxPoint temp3 ;
19280 PyObject * obj0 = 0 ;
19281 PyObject * obj1 = 0 ;
19282 PyObject * obj2 = 0 ;
19283 char * kwnames[] = {
19284 (char *) "self",(char *) "icon",(char *) "pt", NULL
19285 };
19286
19287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19289 if (!SWIG_IsOK(res1)) {
19290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawIconPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19291 }
19292 arg1 = reinterpret_cast< wxDC * >(argp1);
19293 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
19294 if (!SWIG_IsOK(res2)) {
19295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
19296 }
19297 if (!argp2) {
19298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
19299 }
19300 arg2 = reinterpret_cast< wxIcon * >(argp2);
19301 {
19302 arg3 = &temp3;
19303 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19304 }
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_Py_Void();
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *_wrap_DC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19319 PyObject *resultobj = 0;
19320 wxDC *arg1 = (wxDC *) 0 ;
19321 wxBitmap *arg2 = 0 ;
19322 int arg3 ;
19323 int arg4 ;
19324 bool arg5 = (bool) false ;
19325 void *argp1 = 0 ;
19326 int res1 = 0 ;
19327 void *argp2 = 0 ;
19328 int res2 = 0 ;
19329 int val3 ;
19330 int ecode3 = 0 ;
19331 int val4 ;
19332 int ecode4 = 0 ;
19333 bool val5 ;
19334 int ecode5 = 0 ;
19335 PyObject * obj0 = 0 ;
19336 PyObject * obj1 = 0 ;
19337 PyObject * obj2 = 0 ;
19338 PyObject * obj3 = 0 ;
19339 PyObject * obj4 = 0 ;
19340 char * kwnames[] = {
19341 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
19342 };
19343
19344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmap" "', expected argument " "1"" of type '" "wxDC *""'");
19348 }
19349 arg1 = reinterpret_cast< wxDC * >(argp1);
19350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
19351 if (!SWIG_IsOK(res2)) {
19352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
19353 }
19354 if (!argp2) {
19355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
19356 }
19357 arg2 = reinterpret_cast< wxBitmap * >(argp2);
19358 ecode3 = SWIG_AsVal_int(obj2, &val3);
19359 if (!SWIG_IsOK(ecode3)) {
19360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
19361 }
19362 arg3 = static_cast< int >(val3);
19363 ecode4 = SWIG_AsVal_int(obj3, &val4);
19364 if (!SWIG_IsOK(ecode4)) {
19365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
19366 }
19367 arg4 = static_cast< int >(val4);
19368 if (obj4) {
19369 ecode5 = SWIG_AsVal_bool(obj4, &val5);
19370 if (!SWIG_IsOK(ecode5)) {
19371 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
19372 }
19373 arg5 = static_cast< bool >(val5);
19374 }
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 resultobj = SWIG_Py_Void();
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *_wrap_DC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj = 0;
19390 wxDC *arg1 = (wxDC *) 0 ;
19391 wxBitmap *arg2 = 0 ;
19392 wxPoint *arg3 = 0 ;
19393 bool arg4 = (bool) false ;
19394 void *argp1 = 0 ;
19395 int res1 = 0 ;
19396 void *argp2 = 0 ;
19397 int res2 = 0 ;
19398 wxPoint temp3 ;
19399 bool val4 ;
19400 int ecode4 = 0 ;
19401 PyObject * obj0 = 0 ;
19402 PyObject * obj1 = 0 ;
19403 PyObject * obj2 = 0 ;
19404 PyObject * obj3 = 0 ;
19405 char * kwnames[] = {
19406 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
19407 };
19408
19409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19411 if (!SWIG_IsOK(res1)) {
19412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19413 }
19414 arg1 = reinterpret_cast< wxDC * >(argp1);
19415 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
19416 if (!SWIG_IsOK(res2)) {
19417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
19418 }
19419 if (!argp2) {
19420 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
19421 }
19422 arg2 = reinterpret_cast< wxBitmap * >(argp2);
19423 {
19424 arg3 = &temp3;
19425 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19426 }
19427 if (obj3) {
19428 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19429 if (!SWIG_IsOK(ecode4)) {
19430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
19431 }
19432 arg4 = static_cast< bool >(val4);
19433 }
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_Py_Void();
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_DC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj = 0;
19449 wxDC *arg1 = (wxDC *) 0 ;
19450 wxString *arg2 = 0 ;
19451 int arg3 ;
19452 int arg4 ;
19453 void *argp1 = 0 ;
19454 int res1 = 0 ;
19455 bool temp2 = false ;
19456 int val3 ;
19457 int ecode3 = 0 ;
19458 int val4 ;
19459 int ecode4 = 0 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 PyObject * obj2 = 0 ;
19463 PyObject * obj3 = 0 ;
19464 char * kwnames[] = {
19465 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
19466 };
19467
19468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawText" "', expected argument " "1"" of type '" "wxDC *""'");
19472 }
19473 arg1 = reinterpret_cast< wxDC * >(argp1);
19474 {
19475 arg2 = wxString_in_helper(obj1);
19476 if (arg2 == NULL) SWIG_fail;
19477 temp2 = true;
19478 }
19479 ecode3 = SWIG_AsVal_int(obj2, &val3);
19480 if (!SWIG_IsOK(ecode3)) {
19481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawText" "', expected argument " "3"" of type '" "int""'");
19482 }
19483 arg3 = static_cast< int >(val3);
19484 ecode4 = SWIG_AsVal_int(obj3, &val4);
19485 if (!SWIG_IsOK(ecode4)) {
19486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawText" "', expected argument " "4"" of type '" "int""'");
19487 }
19488 arg4 = static_cast< int >(val4);
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = SWIG_Py_Void();
19496 {
19497 if (temp2)
19498 delete arg2;
19499 }
19500 return resultobj;
19501 fail:
19502 {
19503 if (temp2)
19504 delete arg2;
19505 }
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *_wrap_DC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj = 0;
19512 wxDC *arg1 = (wxDC *) 0 ;
19513 wxString *arg2 = 0 ;
19514 wxPoint *arg3 = 0 ;
19515 void *argp1 = 0 ;
19516 int res1 = 0 ;
19517 bool temp2 = false ;
19518 wxPoint temp3 ;
19519 PyObject * obj0 = 0 ;
19520 PyObject * obj1 = 0 ;
19521 PyObject * obj2 = 0 ;
19522 char * kwnames[] = {
19523 (char *) "self",(char *) "text",(char *) "pt", NULL
19524 };
19525
19526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19530 }
19531 arg1 = reinterpret_cast< wxDC * >(argp1);
19532 {
19533 arg2 = wxString_in_helper(obj1);
19534 if (arg2 == NULL) SWIG_fail;
19535 temp2 = true;
19536 }
19537 {
19538 arg3 = &temp3;
19539 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19540 }
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 resultobj = SWIG_Py_Void();
19548 {
19549 if (temp2)
19550 delete arg2;
19551 }
19552 return resultobj;
19553 fail:
19554 {
19555 if (temp2)
19556 delete arg2;
19557 }
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_DC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxDC *arg1 = (wxDC *) 0 ;
19565 wxString *arg2 = 0 ;
19566 int arg3 ;
19567 int arg4 ;
19568 double arg5 ;
19569 void *argp1 = 0 ;
19570 int res1 = 0 ;
19571 bool temp2 = false ;
19572 int val3 ;
19573 int ecode3 = 0 ;
19574 int val4 ;
19575 int ecode4 = 0 ;
19576 double val5 ;
19577 int ecode5 = 0 ;
19578 PyObject * obj0 = 0 ;
19579 PyObject * obj1 = 0 ;
19580 PyObject * obj2 = 0 ;
19581 PyObject * obj3 = 0 ;
19582 PyObject * obj4 = 0 ;
19583 char * kwnames[] = {
19584 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
19585 };
19586
19587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19589 if (!SWIG_IsOK(res1)) {
19590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedText" "', expected argument " "1"" of type '" "wxDC *""'");
19591 }
19592 arg1 = reinterpret_cast< wxDC * >(argp1);
19593 {
19594 arg2 = wxString_in_helper(obj1);
19595 if (arg2 == NULL) SWIG_fail;
19596 temp2 = true;
19597 }
19598 ecode3 = SWIG_AsVal_int(obj2, &val3);
19599 if (!SWIG_IsOK(ecode3)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
19601 }
19602 arg3 = static_cast< int >(val3);
19603 ecode4 = SWIG_AsVal_int(obj3, &val4);
19604 if (!SWIG_IsOK(ecode4)) {
19605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
19606 }
19607 arg4 = static_cast< int >(val4);
19608 ecode5 = SWIG_AsVal_double(obj4, &val5);
19609 if (!SWIG_IsOK(ecode5)) {
19610 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
19611 }
19612 arg5 = static_cast< double >(val5);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_Py_Void();
19620 {
19621 if (temp2)
19622 delete arg2;
19623 }
19624 return resultobj;
19625 fail:
19626 {
19627 if (temp2)
19628 delete arg2;
19629 }
19630 return NULL;
19631 }
19632
19633
19634 SWIGINTERN PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19635 PyObject *resultobj = 0;
19636 wxDC *arg1 = (wxDC *) 0 ;
19637 wxString *arg2 = 0 ;
19638 wxPoint *arg3 = 0 ;
19639 double arg4 ;
19640 void *argp1 = 0 ;
19641 int res1 = 0 ;
19642 bool temp2 = false ;
19643 wxPoint temp3 ;
19644 double val4 ;
19645 int ecode4 = 0 ;
19646 PyObject * obj0 = 0 ;
19647 PyObject * obj1 = 0 ;
19648 PyObject * obj2 = 0 ;
19649 PyObject * obj3 = 0 ;
19650 char * kwnames[] = {
19651 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
19652 };
19653
19654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxDC *""'");
19658 }
19659 arg1 = reinterpret_cast< wxDC * >(argp1);
19660 {
19661 arg2 = wxString_in_helper(obj1);
19662 if (arg2 == NULL) SWIG_fail;
19663 temp2 = true;
19664 }
19665 {
19666 arg3 = &temp3;
19667 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19668 }
19669 ecode4 = SWIG_AsVal_double(obj3, &val4);
19670 if (!SWIG_IsOK(ecode4)) {
19671 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
19672 }
19673 arg4 = static_cast< double >(val4);
19674 {
19675 PyThreadState* __tstate = wxPyBeginAllowThreads();
19676 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
19677 wxPyEndAllowThreads(__tstate);
19678 if (PyErr_Occurred()) SWIG_fail;
19679 }
19680 resultobj = SWIG_Py_Void();
19681 {
19682 if (temp2)
19683 delete arg2;
19684 }
19685 return resultobj;
19686 fail:
19687 {
19688 if (temp2)
19689 delete arg2;
19690 }
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *_wrap_DC_Blit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19696 PyObject *resultobj = 0;
19697 wxDC *arg1 = (wxDC *) 0 ;
19698 int arg2 ;
19699 int arg3 ;
19700 int arg4 ;
19701 int arg5 ;
19702 wxDC *arg6 = (wxDC *) 0 ;
19703 int arg7 ;
19704 int arg8 ;
19705 int arg9 = (int) wxCOPY ;
19706 bool arg10 = (bool) false ;
19707 int arg11 = (int) -1 ;
19708 int arg12 = (int) -1 ;
19709 bool result;
19710 void *argp1 = 0 ;
19711 int res1 = 0 ;
19712 int val2 ;
19713 int ecode2 = 0 ;
19714 int val3 ;
19715 int ecode3 = 0 ;
19716 int val4 ;
19717 int ecode4 = 0 ;
19718 int val5 ;
19719 int ecode5 = 0 ;
19720 void *argp6 = 0 ;
19721 int res6 = 0 ;
19722 int val7 ;
19723 int ecode7 = 0 ;
19724 int val8 ;
19725 int ecode8 = 0 ;
19726 int val9 ;
19727 int ecode9 = 0 ;
19728 bool val10 ;
19729 int ecode10 = 0 ;
19730 int val11 ;
19731 int ecode11 = 0 ;
19732 int val12 ;
19733 int ecode12 = 0 ;
19734 PyObject * obj0 = 0 ;
19735 PyObject * obj1 = 0 ;
19736 PyObject * obj2 = 0 ;
19737 PyObject * obj3 = 0 ;
19738 PyObject * obj4 = 0 ;
19739 PyObject * obj5 = 0 ;
19740 PyObject * obj6 = 0 ;
19741 PyObject * obj7 = 0 ;
19742 PyObject * obj8 = 0 ;
19743 PyObject * obj9 = 0 ;
19744 PyObject * obj10 = 0 ;
19745 PyObject * obj11 = 0 ;
19746 char * kwnames[] = {
19747 (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
19748 };
19749
19750 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;
19751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Blit" "', expected argument " "1"" of type '" "wxDC *""'");
19754 }
19755 arg1 = reinterpret_cast< wxDC * >(argp1);
19756 ecode2 = SWIG_AsVal_int(obj1, &val2);
19757 if (!SWIG_IsOK(ecode2)) {
19758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_Blit" "', expected argument " "2"" of type '" "int""'");
19759 }
19760 arg2 = static_cast< int >(val2);
19761 ecode3 = SWIG_AsVal_int(obj2, &val3);
19762 if (!SWIG_IsOK(ecode3)) {
19763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_Blit" "', expected argument " "3"" of type '" "int""'");
19764 }
19765 arg3 = static_cast< int >(val3);
19766 ecode4 = SWIG_AsVal_int(obj3, &val4);
19767 if (!SWIG_IsOK(ecode4)) {
19768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_Blit" "', expected argument " "4"" of type '" "int""'");
19769 }
19770 arg4 = static_cast< int >(val4);
19771 ecode5 = SWIG_AsVal_int(obj4, &val5);
19772 if (!SWIG_IsOK(ecode5)) {
19773 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_Blit" "', expected argument " "5"" of type '" "int""'");
19774 }
19775 arg5 = static_cast< int >(val5);
19776 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxDC, 0 | 0 );
19777 if (!SWIG_IsOK(res6)) {
19778 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_Blit" "', expected argument " "6"" of type '" "wxDC *""'");
19779 }
19780 arg6 = reinterpret_cast< wxDC * >(argp6);
19781 ecode7 = SWIG_AsVal_int(obj6, &val7);
19782 if (!SWIG_IsOK(ecode7)) {
19783 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_Blit" "', expected argument " "7"" of type '" "int""'");
19784 }
19785 arg7 = static_cast< int >(val7);
19786 ecode8 = SWIG_AsVal_int(obj7, &val8);
19787 if (!SWIG_IsOK(ecode8)) {
19788 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DC_Blit" "', expected argument " "8"" of type '" "int""'");
19789 }
19790 arg8 = static_cast< int >(val8);
19791 if (obj8) {
19792 ecode9 = SWIG_AsVal_int(obj8, &val9);
19793 if (!SWIG_IsOK(ecode9)) {
19794 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "DC_Blit" "', expected argument " "9"" of type '" "int""'");
19795 }
19796 arg9 = static_cast< int >(val9);
19797 }
19798 if (obj9) {
19799 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19800 if (!SWIG_IsOK(ecode10)) {
19801 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "DC_Blit" "', expected argument " "10"" of type '" "bool""'");
19802 }
19803 arg10 = static_cast< bool >(val10);
19804 }
19805 if (obj10) {
19806 ecode11 = SWIG_AsVal_int(obj10, &val11);
19807 if (!SWIG_IsOK(ecode11)) {
19808 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "DC_Blit" "', expected argument " "11"" of type '" "int""'");
19809 }
19810 arg11 = static_cast< int >(val11);
19811 }
19812 if (obj11) {
19813 ecode12 = SWIG_AsVal_int(obj11, &val12);
19814 if (!SWIG_IsOK(ecode12)) {
19815 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "DC_Blit" "', expected argument " "12"" of type '" "int""'");
19816 }
19817 arg12 = static_cast< int >(val12);
19818 }
19819 {
19820 PyThreadState* __tstate = wxPyBeginAllowThreads();
19821 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19822 wxPyEndAllowThreads(__tstate);
19823 if (PyErr_Occurred()) SWIG_fail;
19824 }
19825 {
19826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19827 }
19828 return resultobj;
19829 fail:
19830 return NULL;
19831 }
19832
19833
19834 SWIGINTERN PyObject *_wrap_DC_BlitPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19835 PyObject *resultobj = 0;
19836 wxDC *arg1 = (wxDC *) 0 ;
19837 wxPoint *arg2 = 0 ;
19838 wxSize *arg3 = 0 ;
19839 wxDC *arg4 = (wxDC *) 0 ;
19840 wxPoint *arg5 = 0 ;
19841 int arg6 = (int) wxCOPY ;
19842 bool arg7 = (bool) false ;
19843 wxPoint const &arg8_defvalue = wxDefaultPosition ;
19844 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
19845 bool result;
19846 void *argp1 = 0 ;
19847 int res1 = 0 ;
19848 wxPoint temp2 ;
19849 wxSize temp3 ;
19850 void *argp4 = 0 ;
19851 int res4 = 0 ;
19852 wxPoint temp5 ;
19853 int val6 ;
19854 int ecode6 = 0 ;
19855 bool val7 ;
19856 int ecode7 = 0 ;
19857 wxPoint temp8 ;
19858 PyObject * obj0 = 0 ;
19859 PyObject * obj1 = 0 ;
19860 PyObject * obj2 = 0 ;
19861 PyObject * obj3 = 0 ;
19862 PyObject * obj4 = 0 ;
19863 PyObject * obj5 = 0 ;
19864 PyObject * obj6 = 0 ;
19865 PyObject * obj7 = 0 ;
19866 char * kwnames[] = {
19867 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
19868 };
19869
19870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
19871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19872 if (!SWIG_IsOK(res1)) {
19873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_BlitPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
19874 }
19875 arg1 = reinterpret_cast< wxDC * >(argp1);
19876 {
19877 arg2 = &temp2;
19878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19879 }
19880 {
19881 arg3 = &temp3;
19882 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19883 }
19884 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxDC, 0 | 0 );
19885 if (!SWIG_IsOK(res4)) {
19886 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DC_BlitPointSize" "', expected argument " "4"" of type '" "wxDC *""'");
19887 }
19888 arg4 = reinterpret_cast< wxDC * >(argp4);
19889 {
19890 arg5 = &temp5;
19891 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
19892 }
19893 if (obj5) {
19894 ecode6 = SWIG_AsVal_int(obj5, &val6);
19895 if (!SWIG_IsOK(ecode6)) {
19896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_BlitPointSize" "', expected argument " "6"" of type '" "int""'");
19897 }
19898 arg6 = static_cast< int >(val6);
19899 }
19900 if (obj6) {
19901 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19902 if (!SWIG_IsOK(ecode7)) {
19903 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DC_BlitPointSize" "', expected argument " "7"" of type '" "bool""'");
19904 }
19905 arg7 = static_cast< bool >(val7);
19906 }
19907 if (obj7) {
19908 {
19909 arg8 = &temp8;
19910 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
19911 }
19912 }
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 {
19920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19921 }
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 SWIGINTERN PyObject *_wrap_DC_SetClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19929 PyObject *resultobj = 0;
19930 wxDC *arg1 = (wxDC *) 0 ;
19931 int arg2 ;
19932 int arg3 ;
19933 int arg4 ;
19934 int arg5 ;
19935 void *argp1 = 0 ;
19936 int res1 = 0 ;
19937 int val2 ;
19938 int ecode2 = 0 ;
19939 int val3 ;
19940 int ecode3 = 0 ;
19941 int val4 ;
19942 int ecode4 = 0 ;
19943 int val5 ;
19944 int ecode5 = 0 ;
19945 PyObject * obj0 = 0 ;
19946 PyObject * obj1 = 0 ;
19947 PyObject * obj2 = 0 ;
19948 PyObject * obj3 = 0 ;
19949 PyObject * obj4 = 0 ;
19950 char * kwnames[] = {
19951 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
19952 };
19953
19954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
19956 if (!SWIG_IsOK(res1)) {
19957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
19958 }
19959 arg1 = reinterpret_cast< wxDC * >(argp1);
19960 ecode2 = SWIG_AsVal_int(obj1, &val2);
19961 if (!SWIG_IsOK(ecode2)) {
19962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetClippingRegion" "', expected argument " "2"" of type '" "int""'");
19963 }
19964 arg2 = static_cast< int >(val2);
19965 ecode3 = SWIG_AsVal_int(obj2, &val3);
19966 if (!SWIG_IsOK(ecode3)) {
19967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetClippingRegion" "', expected argument " "3"" of type '" "int""'");
19968 }
19969 arg3 = static_cast< int >(val3);
19970 ecode4 = SWIG_AsVal_int(obj3, &val4);
19971 if (!SWIG_IsOK(ecode4)) {
19972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_SetClippingRegion" "', expected argument " "4"" of type '" "int""'");
19973 }
19974 arg4 = static_cast< int >(val4);
19975 ecode5 = SWIG_AsVal_int(obj4, &val5);
19976 if (!SWIG_IsOK(ecode5)) {
19977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_SetClippingRegion" "', expected argument " "5"" of type '" "int""'");
19978 }
19979 arg5 = static_cast< int >(val5);
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
19983 wxPyEndAllowThreads(__tstate);
19984 if (PyErr_Occurred()) SWIG_fail;
19985 }
19986 resultobj = SWIG_Py_Void();
19987 return resultobj;
19988 fail:
19989 return NULL;
19990 }
19991
19992
19993 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj = 0;
19995 wxDC *arg1 = (wxDC *) 0 ;
19996 wxPoint *arg2 = 0 ;
19997 wxSize *arg3 = 0 ;
19998 void *argp1 = 0 ;
19999 int res1 = 0 ;
20000 wxPoint temp2 ;
20001 wxSize temp3 ;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 PyObject * obj2 = 0 ;
20005 char * kwnames[] = {
20006 (char *) "self",(char *) "pt",(char *) "sz", NULL
20007 };
20008
20009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20011 if (!SWIG_IsOK(res1)) {
20012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionPointSize" "', expected argument " "1"" of type '" "wxDC *""'");
20013 }
20014 arg1 = reinterpret_cast< wxDC * >(argp1);
20015 {
20016 arg2 = &temp2;
20017 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20018 }
20019 {
20020 arg3 = &temp3;
20021 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20022 }
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_Py_Void();
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 SWIGINTERN PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj = 0;
20038 wxDC *arg1 = (wxDC *) 0 ;
20039 wxRegion *arg2 = 0 ;
20040 void *argp1 = 0 ;
20041 int res1 = 0 ;
20042 void *argp2 = 0 ;
20043 int res2 = 0 ;
20044 PyObject * obj0 = 0 ;
20045 PyObject * obj1 = 0 ;
20046 char * kwnames[] = {
20047 (char *) "self",(char *) "region", NULL
20048 };
20049
20050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) SWIG_fail;
20051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20052 if (!SWIG_IsOK(res1)) {
20053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "1"" of type '" "wxDC *""'");
20054 }
20055 arg1 = reinterpret_cast< wxDC * >(argp1);
20056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRegion, 0 | 0);
20057 if (!SWIG_IsOK(res2)) {
20058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
20059 }
20060 if (!argp2) {
20061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetClippingRegionAsRegion" "', expected argument " "2"" of type '" "wxRegion const &""'");
20062 }
20063 arg2 = reinterpret_cast< wxRegion * >(argp2);
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 resultobj = SWIG_Py_Void();
20071 return resultobj;
20072 fail:
20073 return NULL;
20074 }
20075
20076
20077 SWIGINTERN PyObject *_wrap_DC_SetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20078 PyObject *resultobj = 0;
20079 wxDC *arg1 = (wxDC *) 0 ;
20080 wxRect *arg2 = 0 ;
20081 void *argp1 = 0 ;
20082 int res1 = 0 ;
20083 wxRect temp2 ;
20084 PyObject * obj0 = 0 ;
20085 PyObject * obj1 = 0 ;
20086 char * kwnames[] = {
20087 (char *) "self",(char *) "rect", NULL
20088 };
20089
20090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) SWIG_fail;
20091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20092 if (!SWIG_IsOK(res1)) {
20093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
20094 }
20095 arg1 = reinterpret_cast< wxDC * >(argp1);
20096 {
20097 arg2 = &temp2;
20098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20099 }
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 (arg1)->SetClippingRegion((wxRect const &)*arg2);
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = SWIG_Py_Void();
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_DC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj = 0;
20115 wxDC *arg1 = (wxDC *) 0 ;
20116 int arg2 ;
20117 wxPoint *arg3 = (wxPoint *) 0 ;
20118 int arg4 = (int) 0 ;
20119 int arg5 = (int) 0 ;
20120 void *argp1 = 0 ;
20121 int res1 = 0 ;
20122 int val4 ;
20123 int ecode4 = 0 ;
20124 int val5 ;
20125 int ecode5 = 0 ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 PyObject * obj2 = 0 ;
20129 PyObject * obj3 = 0 ;
20130 char * kwnames[] = {
20131 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
20132 };
20133
20134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20136 if (!SWIG_IsOK(res1)) {
20137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLines" "', expected argument " "1"" of type '" "wxDC *""'");
20138 }
20139 arg1 = reinterpret_cast< wxDC * >(argp1);
20140 {
20141 arg3 = wxPoint_LIST_helper(obj1, &arg2);
20142 if (arg3 == NULL) SWIG_fail;
20143 }
20144 if (obj2) {
20145 ecode4 = SWIG_AsVal_int(obj2, &val4);
20146 if (!SWIG_IsOK(ecode4)) {
20147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLines" "', expected argument " "4"" of type '" "int""'");
20148 }
20149 arg4 = static_cast< int >(val4);
20150 }
20151 if (obj3) {
20152 ecode5 = SWIG_AsVal_int(obj3, &val5);
20153 if (!SWIG_IsOK(ecode5)) {
20154 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLines" "', expected argument " "5"" of type '" "int""'");
20155 }
20156 arg5 = static_cast< int >(val5);
20157 }
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
20161 wxPyEndAllowThreads(__tstate);
20162 if (PyErr_Occurred()) SWIG_fail;
20163 }
20164 resultobj = SWIG_Py_Void();
20165 {
20166 if (arg3) delete [] arg3;
20167 }
20168 return resultobj;
20169 fail:
20170 {
20171 if (arg3) delete [] arg3;
20172 }
20173 return NULL;
20174 }
20175
20176
20177 SWIGINTERN PyObject *_wrap_DC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj = 0;
20179 wxDC *arg1 = (wxDC *) 0 ;
20180 int arg2 ;
20181 wxPoint *arg3 = (wxPoint *) 0 ;
20182 int arg4 = (int) 0 ;
20183 int arg5 = (int) 0 ;
20184 int arg6 = (int) wxODDEVEN_RULE ;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 int val4 ;
20188 int ecode4 = 0 ;
20189 int val5 ;
20190 int ecode5 = 0 ;
20191 int val6 ;
20192 int ecode6 = 0 ;
20193 PyObject * obj0 = 0 ;
20194 PyObject * obj1 = 0 ;
20195 PyObject * obj2 = 0 ;
20196 PyObject * obj3 = 0 ;
20197 PyObject * obj4 = 0 ;
20198 char * kwnames[] = {
20199 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
20200 };
20201
20202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawPolygon" "', expected argument " "1"" of type '" "wxDC *""'");
20206 }
20207 arg1 = reinterpret_cast< wxDC * >(argp1);
20208 {
20209 arg3 = wxPoint_LIST_helper(obj1, &arg2);
20210 if (arg3 == NULL) SWIG_fail;
20211 }
20212 if (obj2) {
20213 ecode4 = SWIG_AsVal_int(obj2, &val4);
20214 if (!SWIG_IsOK(ecode4)) {
20215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
20216 }
20217 arg4 = static_cast< int >(val4);
20218 }
20219 if (obj3) {
20220 ecode5 = SWIG_AsVal_int(obj3, &val5);
20221 if (!SWIG_IsOK(ecode5)) {
20222 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
20223 }
20224 arg5 = static_cast< int >(val5);
20225 }
20226 if (obj4) {
20227 ecode6 = SWIG_AsVal_int(obj4, &val6);
20228 if (!SWIG_IsOK(ecode6)) {
20229 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
20230 }
20231 arg6 = static_cast< int >(val6);
20232 }
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 resultobj = SWIG_Py_Void();
20240 {
20241 if (arg3) delete [] arg3;
20242 }
20243 return resultobj;
20244 fail:
20245 {
20246 if (arg3) delete [] arg3;
20247 }
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_DC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj = 0;
20254 wxDC *arg1 = (wxDC *) 0 ;
20255 wxString *arg2 = 0 ;
20256 wxRect *arg3 = 0 ;
20257 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
20258 int arg5 = (int) -1 ;
20259 void *argp1 = 0 ;
20260 int res1 = 0 ;
20261 bool temp2 = false ;
20262 wxRect temp3 ;
20263 int val4 ;
20264 int ecode4 = 0 ;
20265 int val5 ;
20266 int ecode5 = 0 ;
20267 PyObject * obj0 = 0 ;
20268 PyObject * obj1 = 0 ;
20269 PyObject * obj2 = 0 ;
20270 PyObject * obj3 = 0 ;
20271 PyObject * obj4 = 0 ;
20272 char * kwnames[] = {
20273 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
20274 };
20275
20276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawLabel" "', expected argument " "1"" of type '" "wxDC *""'");
20280 }
20281 arg1 = reinterpret_cast< wxDC * >(argp1);
20282 {
20283 arg2 = wxString_in_helper(obj1);
20284 if (arg2 == NULL) SWIG_fail;
20285 temp2 = true;
20286 }
20287 {
20288 arg3 = &temp3;
20289 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20290 }
20291 if (obj3) {
20292 ecode4 = SWIG_AsVal_int(obj3, &val4);
20293 if (!SWIG_IsOK(ecode4)) {
20294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
20295 }
20296 arg4 = static_cast< int >(val4);
20297 }
20298 if (obj4) {
20299 ecode5 = SWIG_AsVal_int(obj4, &val5);
20300 if (!SWIG_IsOK(ecode5)) {
20301 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
20302 }
20303 arg5 = static_cast< int >(val5);
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_Py_Void();
20312 {
20313 if (temp2)
20314 delete arg2;
20315 }
20316 return resultobj;
20317 fail:
20318 {
20319 if (temp2)
20320 delete arg2;
20321 }
20322 return NULL;
20323 }
20324
20325
20326 SWIGINTERN PyObject *_wrap_DC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj = 0;
20328 wxDC *arg1 = (wxDC *) 0 ;
20329 wxString *arg2 = 0 ;
20330 wxBitmap *arg3 = 0 ;
20331 wxRect *arg4 = 0 ;
20332 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
20333 int arg6 = (int) -1 ;
20334 wxRect result;
20335 void *argp1 = 0 ;
20336 int res1 = 0 ;
20337 bool temp2 = false ;
20338 void *argp3 = 0 ;
20339 int res3 = 0 ;
20340 wxRect temp4 ;
20341 int val5 ;
20342 int ecode5 = 0 ;
20343 int val6 ;
20344 int ecode6 = 0 ;
20345 PyObject * obj0 = 0 ;
20346 PyObject * obj1 = 0 ;
20347 PyObject * obj2 = 0 ;
20348 PyObject * obj3 = 0 ;
20349 PyObject * obj4 = 0 ;
20350 PyObject * obj5 = 0 ;
20351 char * kwnames[] = {
20352 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
20353 };
20354
20355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20357 if (!SWIG_IsOK(res1)) {
20358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawImageLabel" "', expected argument " "1"" of type '" "wxDC *""'");
20359 }
20360 arg1 = reinterpret_cast< wxDC * >(argp1);
20361 {
20362 arg2 = wxString_in_helper(obj1);
20363 if (arg2 == NULL) SWIG_fail;
20364 temp2 = true;
20365 }
20366 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
20367 if (!SWIG_IsOK(res3)) {
20368 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
20369 }
20370 if (!argp3) {
20371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
20372 }
20373 arg3 = reinterpret_cast< wxBitmap * >(argp3);
20374 {
20375 arg4 = &temp4;
20376 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20377 }
20378 if (obj4) {
20379 ecode5 = SWIG_AsVal_int(obj4, &val5);
20380 if (!SWIG_IsOK(ecode5)) {
20381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
20382 }
20383 arg5 = static_cast< int >(val5);
20384 }
20385 if (obj5) {
20386 ecode6 = SWIG_AsVal_int(obj5, &val6);
20387 if (!SWIG_IsOK(ecode6)) {
20388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
20389 }
20390 arg6 = static_cast< int >(val6);
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
20399 {
20400 if (temp2)
20401 delete arg2;
20402 }
20403 return resultobj;
20404 fail:
20405 {
20406 if (temp2)
20407 delete arg2;
20408 }
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_DC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20414 PyObject *resultobj = 0;
20415 wxDC *arg1 = (wxDC *) 0 ;
20416 int arg2 ;
20417 wxPoint *arg3 = (wxPoint *) 0 ;
20418 void *argp1 = 0 ;
20419 int res1 = 0 ;
20420 PyObject * obj0 = 0 ;
20421 PyObject * obj1 = 0 ;
20422 char * kwnames[] = {
20423 (char *) "self",(char *) "points", NULL
20424 };
20425
20426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
20427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20428 if (!SWIG_IsOK(res1)) {
20429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DrawSpline" "', expected argument " "1"" of type '" "wxDC *""'");
20430 }
20431 arg1 = reinterpret_cast< wxDC * >(argp1);
20432 {
20433 arg3 = wxPoint_LIST_helper(obj1, &arg2);
20434 if (arg3 == NULL) SWIG_fail;
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 (arg1)->DrawSpline(arg2,arg3);
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 resultobj = SWIG_Py_Void();
20443 {
20444 if (arg3) delete [] arg3;
20445 }
20446 return resultobj;
20447 fail:
20448 {
20449 if (arg3) delete [] arg3;
20450 }
20451 return NULL;
20452 }
20453
20454
20455 SWIGINTERN PyObject *_wrap_DC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20456 PyObject *resultobj = 0;
20457 wxDC *arg1 = (wxDC *) 0 ;
20458 void *argp1 = 0 ;
20459 int res1 = 0 ;
20460 PyObject *swig_obj[1] ;
20461
20462 if (!args) SWIG_fail;
20463 swig_obj[0] = args;
20464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20465 if (!SWIG_IsOK(res1)) {
20466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Clear" "', expected argument " "1"" of type '" "wxDC *""'");
20467 }
20468 arg1 = reinterpret_cast< wxDC * >(argp1);
20469 {
20470 PyThreadState* __tstate = wxPyBeginAllowThreads();
20471 (arg1)->Clear();
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 resultobj = SWIG_Py_Void();
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 SWIGINTERN PyObject *_wrap_DC_StartDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20483 PyObject *resultobj = 0;
20484 wxDC *arg1 = (wxDC *) 0 ;
20485 wxString *arg2 = 0 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 bool temp2 = false ;
20490 PyObject * obj0 = 0 ;
20491 PyObject * obj1 = 0 ;
20492 char * kwnames[] = {
20493 (char *) "self",(char *) "message", NULL
20494 };
20495
20496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) SWIG_fail;
20497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20498 if (!SWIG_IsOK(res1)) {
20499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartDoc" "', expected argument " "1"" of type '" "wxDC *""'");
20500 }
20501 arg1 = reinterpret_cast< wxDC * >(argp1);
20502 {
20503 arg2 = wxString_in_helper(obj1);
20504 if (arg2 == NULL) SWIG_fail;
20505 temp2 = true;
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 {
20517 if (temp2)
20518 delete arg2;
20519 }
20520 return resultobj;
20521 fail:
20522 {
20523 if (temp2)
20524 delete arg2;
20525 }
20526 return NULL;
20527 }
20528
20529
20530 SWIGINTERN PyObject *_wrap_DC_EndDoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531 PyObject *resultobj = 0;
20532 wxDC *arg1 = (wxDC *) 0 ;
20533 void *argp1 = 0 ;
20534 int res1 = 0 ;
20535 PyObject *swig_obj[1] ;
20536
20537 if (!args) SWIG_fail;
20538 swig_obj[0] = args;
20539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20540 if (!SWIG_IsOK(res1)) {
20541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndDoc" "', expected argument " "1"" of type '" "wxDC *""'");
20542 }
20543 arg1 = reinterpret_cast< wxDC * >(argp1);
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 (arg1)->EndDoc();
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 resultobj = SWIG_Py_Void();
20551 return resultobj;
20552 fail:
20553 return NULL;
20554 }
20555
20556
20557 SWIGINTERN PyObject *_wrap_DC_StartPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20558 PyObject *resultobj = 0;
20559 wxDC *arg1 = (wxDC *) 0 ;
20560 void *argp1 = 0 ;
20561 int res1 = 0 ;
20562 PyObject *swig_obj[1] ;
20563
20564 if (!args) SWIG_fail;
20565 swig_obj[0] = args;
20566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20567 if (!SWIG_IsOK(res1)) {
20568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_StartPage" "', expected argument " "1"" of type '" "wxDC *""'");
20569 }
20570 arg1 = reinterpret_cast< wxDC * >(argp1);
20571 {
20572 PyThreadState* __tstate = wxPyBeginAllowThreads();
20573 (arg1)->StartPage();
20574 wxPyEndAllowThreads(__tstate);
20575 if (PyErr_Occurred()) SWIG_fail;
20576 }
20577 resultobj = SWIG_Py_Void();
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 SWIGINTERN PyObject *_wrap_DC_EndPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20585 PyObject *resultobj = 0;
20586 wxDC *arg1 = (wxDC *) 0 ;
20587 void *argp1 = 0 ;
20588 int res1 = 0 ;
20589 PyObject *swig_obj[1] ;
20590
20591 if (!args) SWIG_fail;
20592 swig_obj[0] = args;
20593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20594 if (!SWIG_IsOK(res1)) {
20595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_EndPage" "', expected argument " "1"" of type '" "wxDC *""'");
20596 }
20597 arg1 = reinterpret_cast< wxDC * >(argp1);
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 (arg1)->EndPage();
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_Py_Void();
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 SWIGINTERN PyObject *_wrap_DC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj = 0;
20613 wxDC *arg1 = (wxDC *) 0 ;
20614 wxFont *arg2 = 0 ;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 void *argp2 = 0 ;
20618 int res2 = 0 ;
20619 PyObject * obj0 = 0 ;
20620 PyObject * obj1 = 0 ;
20621 char * kwnames[] = {
20622 (char *) "self",(char *) "font", NULL
20623 };
20624
20625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
20626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20627 if (!SWIG_IsOK(res1)) {
20628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetFont" "', expected argument " "1"" of type '" "wxDC *""'");
20629 }
20630 arg1 = reinterpret_cast< wxDC * >(argp1);
20631 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
20632 if (!SWIG_IsOK(res2)) {
20633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
20634 }
20635 if (!argp2) {
20636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
20637 }
20638 arg2 = reinterpret_cast< wxFont * >(argp2);
20639 {
20640 PyThreadState* __tstate = wxPyBeginAllowThreads();
20641 (arg1)->SetFont((wxFont const &)*arg2);
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 resultobj = SWIG_Py_Void();
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 SWIGINTERN PyObject *_wrap_DC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj = 0;
20654 wxDC *arg1 = (wxDC *) 0 ;
20655 wxPen *arg2 = 0 ;
20656 void *argp1 = 0 ;
20657 int res1 = 0 ;
20658 void *argp2 = 0 ;
20659 int res2 = 0 ;
20660 PyObject * obj0 = 0 ;
20661 PyObject * obj1 = 0 ;
20662 char * kwnames[] = {
20663 (char *) "self",(char *) "pen", NULL
20664 };
20665
20666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
20667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20668 if (!SWIG_IsOK(res1)) {
20669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPen" "', expected argument " "1"" of type '" "wxDC *""'");
20670 }
20671 arg1 = reinterpret_cast< wxDC * >(argp1);
20672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
20673 if (!SWIG_IsOK(res2)) {
20674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20675 }
20676 if (!argp2) {
20677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
20678 }
20679 arg2 = reinterpret_cast< wxPen * >(argp2);
20680 {
20681 PyThreadState* __tstate = wxPyBeginAllowThreads();
20682 (arg1)->SetPen((wxPen const &)*arg2);
20683 wxPyEndAllowThreads(__tstate);
20684 if (PyErr_Occurred()) SWIG_fail;
20685 }
20686 resultobj = SWIG_Py_Void();
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_DC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20694 PyObject *resultobj = 0;
20695 wxDC *arg1 = (wxDC *) 0 ;
20696 wxBrush *arg2 = 0 ;
20697 void *argp1 = 0 ;
20698 int res1 = 0 ;
20699 void *argp2 = 0 ;
20700 int res2 = 0 ;
20701 PyObject * obj0 = 0 ;
20702 PyObject * obj1 = 0 ;
20703 char * kwnames[] = {
20704 (char *) "self",(char *) "brush", NULL
20705 };
20706
20707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
20708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20709 if (!SWIG_IsOK(res1)) {
20710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBrush" "', expected argument " "1"" of type '" "wxDC *""'");
20711 }
20712 arg1 = reinterpret_cast< wxDC * >(argp1);
20713 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20714 if (!SWIG_IsOK(res2)) {
20715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20716 }
20717 if (!argp2) {
20718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
20719 }
20720 arg2 = reinterpret_cast< wxBrush * >(argp2);
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 (arg1)->SetBrush((wxBrush const &)*arg2);
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 resultobj = SWIG_Py_Void();
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_DC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = 0;
20736 wxDC *arg1 = (wxDC *) 0 ;
20737 wxBrush *arg2 = 0 ;
20738 void *argp1 = 0 ;
20739 int res1 = 0 ;
20740 void *argp2 = 0 ;
20741 int res2 = 0 ;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 char * kwnames[] = {
20745 (char *) "self",(char *) "brush", NULL
20746 };
20747
20748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
20749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20750 if (!SWIG_IsOK(res1)) {
20751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackground" "', expected argument " "1"" of type '" "wxDC *""'");
20752 }
20753 arg1 = reinterpret_cast< wxDC * >(argp1);
20754 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
20755 if (!SWIG_IsOK(res2)) {
20756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20757 }
20758 if (!argp2) {
20759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
20760 }
20761 arg2 = reinterpret_cast< wxBrush * >(argp2);
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 (arg1)->SetBackground((wxBrush const &)*arg2);
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 resultobj = SWIG_Py_Void();
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_DC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj = 0;
20777 wxDC *arg1 = (wxDC *) 0 ;
20778 int arg2 ;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 int val2 ;
20782 int ecode2 = 0 ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 char * kwnames[] = {
20786 (char *) "self",(char *) "mode", NULL
20787 };
20788
20789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
20790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20791 if (!SWIG_IsOK(res1)) {
20792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxDC *""'");
20793 }
20794 arg1 = reinterpret_cast< wxDC * >(argp1);
20795 ecode2 = SWIG_AsVal_int(obj1, &val2);
20796 if (!SWIG_IsOK(ecode2)) {
20797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
20798 }
20799 arg2 = static_cast< int >(val2);
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 (arg1)->SetBackgroundMode(arg2);
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_Py_Void();
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *_wrap_DC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj = 0;
20815 wxDC *arg1 = (wxDC *) 0 ;
20816 wxPalette *arg2 = 0 ;
20817 void *argp1 = 0 ;
20818 int res1 = 0 ;
20819 void *argp2 = 0 ;
20820 int res2 = 0 ;
20821 PyObject * obj0 = 0 ;
20822 PyObject * obj1 = 0 ;
20823 char * kwnames[] = {
20824 (char *) "self",(char *) "palette", NULL
20825 };
20826
20827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
20828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20829 if (!SWIG_IsOK(res1)) {
20830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetPalette" "', expected argument " "1"" of type '" "wxDC *""'");
20831 }
20832 arg1 = reinterpret_cast< wxDC * >(argp1);
20833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
20834 if (!SWIG_IsOK(res2)) {
20835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20836 }
20837 if (!argp2) {
20838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
20839 }
20840 arg2 = reinterpret_cast< wxPalette * >(argp2);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 (arg1)->SetPalette((wxPalette const &)*arg2);
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_Py_Void();
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_DC_DestroyClippingRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxDC *arg1 = (wxDC *) 0 ;
20857 void *argp1 = 0 ;
20858 int res1 = 0 ;
20859 PyObject *swig_obj[1] ;
20860
20861 if (!args) SWIG_fail;
20862 swig_obj[0] = args;
20863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20864 if (!SWIG_IsOK(res1)) {
20865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DestroyClippingRegion" "', expected argument " "1"" of type '" "wxDC *""'");
20866 }
20867 arg1 = reinterpret_cast< wxDC * >(argp1);
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 (arg1)->DestroyClippingRegion();
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 resultobj = SWIG_Py_Void();
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_DC_GetClippingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxDC *arg1 = (wxDC *) 0 ;
20884 int *arg2 = (int *) 0 ;
20885 int *arg3 = (int *) 0 ;
20886 int *arg4 = (int *) 0 ;
20887 int *arg5 = (int *) 0 ;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 int temp2 ;
20891 int res2 = SWIG_TMPOBJ ;
20892 int temp3 ;
20893 int res3 = SWIG_TMPOBJ ;
20894 int temp4 ;
20895 int res4 = SWIG_TMPOBJ ;
20896 int temp5 ;
20897 int res5 = SWIG_TMPOBJ ;
20898 PyObject *swig_obj[1] ;
20899
20900 arg2 = &temp2;
20901 arg3 = &temp3;
20902 arg4 = &temp4;
20903 arg5 = &temp5;
20904 if (!args) SWIG_fail;
20905 swig_obj[0] = args;
20906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingBox" "', expected argument " "1"" of type '" "wxDC const *""'");
20909 }
20910 arg1 = reinterpret_cast< wxDC * >(argp1);
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 resultobj = SWIG_Py_Void();
20918 if (SWIG_IsTmpObj(res2)) {
20919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
20920 } else {
20921 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20923 }
20924 if (SWIG_IsTmpObj(res3)) {
20925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
20926 } else {
20927 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
20929 }
20930 if (SWIG_IsTmpObj(res4)) {
20931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
20932 } else {
20933 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
20935 }
20936 if (SWIG_IsTmpObj(res5)) {
20937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
20938 } else {
20939 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_DC_GetClippingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxDC *arg1 = (wxDC *) 0 ;
20951 wxRect result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetClippingRect" "', expected argument " "1"" of type '" "wxDC *""'");
20961 }
20962 arg1 = reinterpret_cast< wxDC * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = wxDC_GetClippingRect(arg1);
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_DC_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20977 PyObject *resultobj = 0;
20978 wxDC *arg1 = (wxDC *) 0 ;
20979 int result;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 PyObject *swig_obj[1] ;
20983
20984 if (!args) SWIG_fail;
20985 swig_obj[0] = args;
20986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
20987 if (!SWIG_IsOK(res1)) {
20988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharHeight" "', expected argument " "1"" of type '" "wxDC const *""'");
20989 }
20990 arg1 = reinterpret_cast< wxDC * >(argp1);
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (int)((wxDC const *)arg1)->GetCharHeight();
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 resultobj = SWIG_From_int(static_cast< int >(result));
20998 return resultobj;
20999 fail:
21000 return NULL;
21001 }
21002
21003
21004 SWIGINTERN PyObject *_wrap_DC_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21005 PyObject *resultobj = 0;
21006 wxDC *arg1 = (wxDC *) 0 ;
21007 int result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 PyObject *swig_obj[1] ;
21011
21012 if (!args) SWIG_fail;
21013 swig_obj[0] = args;
21014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21015 if (!SWIG_IsOK(res1)) {
21016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetCharWidth" "', expected argument " "1"" of type '" "wxDC const *""'");
21017 }
21018 arg1 = reinterpret_cast< wxDC * >(argp1);
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 result = (int)((wxDC const *)arg1)->GetCharWidth();
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 resultobj = SWIG_From_int(static_cast< int >(result));
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_DC_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21033 PyObject *resultobj = 0;
21034 wxDC *arg1 = (wxDC *) 0 ;
21035 wxString *arg2 = 0 ;
21036 int *arg3 = (int *) 0 ;
21037 int *arg4 = (int *) 0 ;
21038 void *argp1 = 0 ;
21039 int res1 = 0 ;
21040 bool temp2 = false ;
21041 int temp3 ;
21042 int res3 = SWIG_TMPOBJ ;
21043 int temp4 ;
21044 int res4 = SWIG_TMPOBJ ;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 char * kwnames[] = {
21048 (char *) "self",(char *) "string", NULL
21049 };
21050
21051 arg3 = &temp3;
21052 arg4 = &temp4;
21053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
21054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
21057 }
21058 arg1 = reinterpret_cast< wxDC * >(argp1);
21059 {
21060 arg2 = wxString_in_helper(obj1);
21061 if (arg2 == NULL) SWIG_fail;
21062 temp2 = true;
21063 }
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
21067 wxPyEndAllowThreads(__tstate);
21068 if (PyErr_Occurred()) SWIG_fail;
21069 }
21070 resultobj = SWIG_Py_Void();
21071 if (SWIG_IsTmpObj(res3)) {
21072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21073 } else {
21074 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21076 }
21077 if (SWIG_IsTmpObj(res4)) {
21078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
21079 } else {
21080 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
21082 }
21083 {
21084 if (temp2)
21085 delete arg2;
21086 }
21087 return resultobj;
21088 fail:
21089 {
21090 if (temp2)
21091 delete arg2;
21092 }
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_DC_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj = 0;
21099 wxDC *arg1 = (wxDC *) 0 ;
21100 wxString *arg2 = 0 ;
21101 int *arg3 = (int *) 0 ;
21102 int *arg4 = (int *) 0 ;
21103 int *arg5 = (int *) 0 ;
21104 int *arg6 = (int *) 0 ;
21105 wxFont *arg7 = (wxFont *) NULL ;
21106 void *argp1 = 0 ;
21107 int res1 = 0 ;
21108 bool temp2 = false ;
21109 int temp3 ;
21110 int res3 = SWIG_TMPOBJ ;
21111 int temp4 ;
21112 int res4 = SWIG_TMPOBJ ;
21113 int temp5 ;
21114 int res5 = SWIG_TMPOBJ ;
21115 int temp6 ;
21116 int res6 = SWIG_TMPOBJ ;
21117 void *argp7 = 0 ;
21118 int res7 = 0 ;
21119 PyObject * obj0 = 0 ;
21120 PyObject * obj1 = 0 ;
21121 PyObject * obj2 = 0 ;
21122 char * kwnames[] = {
21123 (char *) "self",(char *) "string",(char *) "font", NULL
21124 };
21125
21126 arg3 = &temp3;
21127 arg4 = &temp4;
21128 arg5 = &temp5;
21129 arg6 = &temp6;
21130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFullTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
21134 }
21135 arg1 = reinterpret_cast< wxDC * >(argp1);
21136 {
21137 arg2 = wxString_in_helper(obj1);
21138 if (arg2 == NULL) SWIG_fail;
21139 temp2 = true;
21140 }
21141 if (obj2) {
21142 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
21143 if (!SWIG_IsOK(res7)) {
21144 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DC_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont *""'");
21145 }
21146 arg7 = reinterpret_cast< wxFont * >(argp7);
21147 }
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 resultobj = SWIG_Py_Void();
21155 if (SWIG_IsTmpObj(res3)) {
21156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21157 } else {
21158 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21160 }
21161 if (SWIG_IsTmpObj(res4)) {
21162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
21163 } else {
21164 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
21166 }
21167 if (SWIG_IsTmpObj(res5)) {
21168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
21169 } else {
21170 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
21172 }
21173 if (SWIG_IsTmpObj(res6)) {
21174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
21175 } else {
21176 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
21178 }
21179 {
21180 if (temp2)
21181 delete arg2;
21182 }
21183 return resultobj;
21184 fail:
21185 {
21186 if (temp2)
21187 delete arg2;
21188 }
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21194 PyObject *resultobj = 0;
21195 wxDC *arg1 = (wxDC *) 0 ;
21196 wxString *arg2 = 0 ;
21197 int *arg3 = (int *) 0 ;
21198 int *arg4 = (int *) 0 ;
21199 int *arg5 = (int *) 0 ;
21200 wxFont *arg6 = (wxFont *) NULL ;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 bool temp2 = false ;
21204 int temp3 ;
21205 int res3 = SWIG_TMPOBJ ;
21206 int temp4 ;
21207 int res4 = SWIG_TMPOBJ ;
21208 int temp5 ;
21209 int res5 = SWIG_TMPOBJ ;
21210 void *argp6 = 0 ;
21211 int res6 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 PyObject * obj2 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "text",(char *) "font", NULL
21217 };
21218
21219 arg3 = &temp3;
21220 arg4 = &temp4;
21221 arg5 = &temp5;
21222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "1"" of type '" "wxDC *""'");
21226 }
21227 arg1 = reinterpret_cast< wxDC * >(argp1);
21228 {
21229 arg2 = wxString_in_helper(obj1);
21230 if (arg2 == NULL) SWIG_fail;
21231 temp2 = true;
21232 }
21233 if (obj2) {
21234 res6 = SWIG_ConvertPtr(obj2, &argp6,SWIGTYPE_p_wxFont, 0 | 0 );
21235 if (!SWIG_IsOK(res6)) {
21236 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DC_GetMultiLineTextExtent" "', expected argument " "6"" of type '" "wxFont *""'");
21237 }
21238 arg6 = reinterpret_cast< wxFont * >(argp6);
21239 }
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 resultobj = SWIG_Py_Void();
21247 if (SWIG_IsTmpObj(res3)) {
21248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21249 } else {
21250 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21252 }
21253 if (SWIG_IsTmpObj(res4)) {
21254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
21255 } else {
21256 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
21258 }
21259 if (SWIG_IsTmpObj(res5)) {
21260 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
21261 } else {
21262 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
21264 }
21265 {
21266 if (temp2)
21267 delete arg2;
21268 }
21269 return resultobj;
21270 fail:
21271 {
21272 if (temp2)
21273 delete arg2;
21274 }
21275 return NULL;
21276 }
21277
21278
21279 SWIGINTERN PyObject *_wrap_DC_GetPartialTextExtents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj = 0;
21281 wxDC *arg1 = (wxDC *) 0 ;
21282 wxString *arg2 = 0 ;
21283 wxArrayInt result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 bool temp2 = false ;
21287 PyObject * obj0 = 0 ;
21288 PyObject * obj1 = 0 ;
21289 char * kwnames[] = {
21290 (char *) "self",(char *) "text", NULL
21291 };
21292
21293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) SWIG_fail;
21294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPartialTextExtents" "', expected argument " "1"" of type '" "wxDC *""'");
21297 }
21298 arg1 = reinterpret_cast< wxDC * >(argp1);
21299 {
21300 arg2 = wxString_in_helper(obj1);
21301 if (arg2 == NULL) SWIG_fail;
21302 temp2 = true;
21303 }
21304 {
21305 PyThreadState* __tstate = wxPyBeginAllowThreads();
21306 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
21307 wxPyEndAllowThreads(__tstate);
21308 if (PyErr_Occurred()) SWIG_fail;
21309 }
21310 {
21311 resultobj = PyList_New(0);
21312 size_t idx;
21313 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
21314 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
21315 PyList_Append(resultobj, val);
21316 Py_DECREF(val);
21317 }
21318 }
21319 {
21320 if (temp2)
21321 delete arg2;
21322 }
21323 return resultobj;
21324 fail:
21325 {
21326 if (temp2)
21327 delete arg2;
21328 }
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_DC_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21334 PyObject *resultobj = 0;
21335 wxDC *arg1 = (wxDC *) 0 ;
21336 wxSize result;
21337 void *argp1 = 0 ;
21338 int res1 = 0 ;
21339 PyObject *swig_obj[1] ;
21340
21341 if (!args) SWIG_fail;
21342 swig_obj[0] = args;
21343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21344 if (!SWIG_IsOK(res1)) {
21345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSize" "', expected argument " "1"" of type '" "wxDC *""'");
21346 }
21347 arg1 = reinterpret_cast< wxDC * >(argp1);
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 result = (arg1)->GetSize();
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_DC_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxDC *arg1 = (wxDC *) 0 ;
21364 int *arg2 = (int *) 0 ;
21365 int *arg3 = (int *) 0 ;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 int temp2 ;
21369 int res2 = SWIG_TMPOBJ ;
21370 int temp3 ;
21371 int res3 = SWIG_TMPOBJ ;
21372 PyObject *swig_obj[1] ;
21373
21374 arg2 = &temp2;
21375 arg3 = &temp3;
21376 if (!args) SWIG_fail;
21377 swig_obj[0] = args;
21378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21379 if (!SWIG_IsOK(res1)) {
21380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeTuple" "', expected argument " "1"" of type '" "wxDC *""'");
21381 }
21382 arg1 = reinterpret_cast< wxDC * >(argp1);
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 (arg1)->GetSize(arg2,arg3);
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 resultobj = SWIG_Py_Void();
21390 if (SWIG_IsTmpObj(res2)) {
21391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
21392 } else {
21393 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
21395 }
21396 if (SWIG_IsTmpObj(res3)) {
21397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21398 } else {
21399 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21401 }
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 SWIGINTERN PyObject *_wrap_DC_GetSizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21409 PyObject *resultobj = 0;
21410 wxDC *arg1 = (wxDC *) 0 ;
21411 wxSize result;
21412 void *argp1 = 0 ;
21413 int res1 = 0 ;
21414 PyObject *swig_obj[1] ;
21415
21416 if (!args) SWIG_fail;
21417 swig_obj[0] = args;
21418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21419 if (!SWIG_IsOK(res1)) {
21420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMM" "', expected argument " "1"" of type '" "wxDC const *""'");
21421 }
21422 arg1 = reinterpret_cast< wxDC * >(argp1);
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = ((wxDC const *)arg1)->GetSizeMM();
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21430 return resultobj;
21431 fail:
21432 return NULL;
21433 }
21434
21435
21436 SWIGINTERN PyObject *_wrap_DC_GetSizeMMTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21437 PyObject *resultobj = 0;
21438 wxDC *arg1 = (wxDC *) 0 ;
21439 int *arg2 = (int *) 0 ;
21440 int *arg3 = (int *) 0 ;
21441 void *argp1 = 0 ;
21442 int res1 = 0 ;
21443 int temp2 ;
21444 int res2 = SWIG_TMPOBJ ;
21445 int temp3 ;
21446 int res3 = SWIG_TMPOBJ ;
21447 PyObject *swig_obj[1] ;
21448
21449 arg2 = &temp2;
21450 arg3 = &temp3;
21451 if (!args) SWIG_fail;
21452 swig_obj[0] = args;
21453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetSizeMMTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
21456 }
21457 arg1 = reinterpret_cast< wxDC * >(argp1);
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
21461 wxPyEndAllowThreads(__tstate);
21462 if (PyErr_Occurred()) SWIG_fail;
21463 }
21464 resultobj = SWIG_Py_Void();
21465 if (SWIG_IsTmpObj(res2)) {
21466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
21467 } else {
21468 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
21470 }
21471 if (SWIG_IsTmpObj(res3)) {
21472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
21473 } else {
21474 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
21476 }
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj = 0;
21485 wxDC *arg1 = (wxDC *) 0 ;
21486 int arg2 ;
21487 int result;
21488 void *argp1 = 0 ;
21489 int res1 = 0 ;
21490 int val2 ;
21491 int ecode2 = 0 ;
21492 PyObject * obj0 = 0 ;
21493 PyObject * obj1 = 0 ;
21494 char * kwnames[] = {
21495 (char *) "self",(char *) "x", NULL
21496 };
21497
21498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) SWIG_fail;
21499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21500 if (!SWIG_IsOK(res1)) {
21501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalX" "', expected argument " "1"" of type '" "wxDC const *""'");
21502 }
21503 arg1 = reinterpret_cast< wxDC * >(argp1);
21504 ecode2 = SWIG_AsVal_int(obj1, &val2);
21505 if (!SWIG_IsOK(ecode2)) {
21506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalX" "', expected argument " "2"" of type '" "int""'");
21507 }
21508 arg2 = static_cast< int >(val2);
21509 {
21510 PyThreadState* __tstate = wxPyBeginAllowThreads();
21511 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 resultobj = SWIG_From_int(static_cast< int >(result));
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj = 0;
21524 wxDC *arg1 = (wxDC *) 0 ;
21525 int arg2 ;
21526 int result;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 int val2 ;
21530 int ecode2 = 0 ;
21531 PyObject * obj0 = 0 ;
21532 PyObject * obj1 = 0 ;
21533 char * kwnames[] = {
21534 (char *) "self",(char *) "y", NULL
21535 };
21536
21537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) SWIG_fail;
21538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalY" "', expected argument " "1"" of type '" "wxDC const *""'");
21541 }
21542 arg1 = reinterpret_cast< wxDC * >(argp1);
21543 ecode2 = SWIG_AsVal_int(obj1, &val2);
21544 if (!SWIG_IsOK(ecode2)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalY" "', expected argument " "2"" of type '" "int""'");
21546 }
21547 arg2 = static_cast< int >(val2);
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
21551 wxPyEndAllowThreads(__tstate);
21552 if (PyErr_Occurred()) SWIG_fail;
21553 }
21554 resultobj = SWIG_From_int(static_cast< int >(result));
21555 return resultobj;
21556 fail:
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21562 PyObject *resultobj = 0;
21563 wxDC *arg1 = (wxDC *) 0 ;
21564 int arg2 ;
21565 int result;
21566 void *argp1 = 0 ;
21567 int res1 = 0 ;
21568 int val2 ;
21569 int ecode2 = 0 ;
21570 PyObject * obj0 = 0 ;
21571 PyObject * obj1 = 0 ;
21572 char * kwnames[] = {
21573 (char *) "self",(char *) "x", NULL
21574 };
21575
21576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) SWIG_fail;
21577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21578 if (!SWIG_IsOK(res1)) {
21579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21580 }
21581 arg1 = reinterpret_cast< wxDC * >(argp1);
21582 ecode2 = SWIG_AsVal_int(obj1, &val2);
21583 if (!SWIG_IsOK(ecode2)) {
21584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalXRel" "', expected argument " "2"" of type '" "int""'");
21585 }
21586 arg2 = static_cast< int >(val2);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_From_int(static_cast< int >(result));
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21601 PyObject *resultobj = 0;
21602 wxDC *arg1 = (wxDC *) 0 ;
21603 int arg2 ;
21604 int result;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 int val2 ;
21608 int ecode2 = 0 ;
21609 PyObject * obj0 = 0 ;
21610 PyObject * obj1 = 0 ;
21611 char * kwnames[] = {
21612 (char *) "self",(char *) "y", NULL
21613 };
21614
21615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) SWIG_fail;
21616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21619 }
21620 arg1 = reinterpret_cast< wxDC * >(argp1);
21621 ecode2 = SWIG_AsVal_int(obj1, &val2);
21622 if (!SWIG_IsOK(ecode2)) {
21623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_DeviceToLogicalYRel" "', expected argument " "2"" of type '" "int""'");
21624 }
21625 arg2 = static_cast< int >(val2);
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
21629 wxPyEndAllowThreads(__tstate);
21630 if (PyErr_Occurred()) SWIG_fail;
21631 }
21632 resultobj = SWIG_From_int(static_cast< int >(result));
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj = 0;
21641 wxDC *arg1 = (wxDC *) 0 ;
21642 int arg2 ;
21643 int result;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 int val2 ;
21647 int ecode2 = 0 ;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char * kwnames[] = {
21651 (char *) "self",(char *) "x", NULL
21652 };
21653
21654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) SWIG_fail;
21655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21656 if (!SWIG_IsOK(res1)) {
21657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceX" "', expected argument " "1"" of type '" "wxDC const *""'");
21658 }
21659 arg1 = reinterpret_cast< wxDC * >(argp1);
21660 ecode2 = SWIG_AsVal_int(obj1, &val2);
21661 if (!SWIG_IsOK(ecode2)) {
21662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceX" "', expected argument " "2"" of type '" "int""'");
21663 }
21664 arg2 = static_cast< int >(val2);
21665 {
21666 PyThreadState* __tstate = wxPyBeginAllowThreads();
21667 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
21668 wxPyEndAllowThreads(__tstate);
21669 if (PyErr_Occurred()) SWIG_fail;
21670 }
21671 resultobj = SWIG_From_int(static_cast< int >(result));
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = 0;
21680 wxDC *arg1 = (wxDC *) 0 ;
21681 int arg2 ;
21682 int result;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 int val2 ;
21686 int ecode2 = 0 ;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 char * kwnames[] = {
21690 (char *) "self",(char *) "y", NULL
21691 };
21692
21693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) SWIG_fail;
21694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21695 if (!SWIG_IsOK(res1)) {
21696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceY" "', expected argument " "1"" of type '" "wxDC const *""'");
21697 }
21698 arg1 = reinterpret_cast< wxDC * >(argp1);
21699 ecode2 = SWIG_AsVal_int(obj1, &val2);
21700 if (!SWIG_IsOK(ecode2)) {
21701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceY" "', expected argument " "2"" of type '" "int""'");
21702 }
21703 arg2 = static_cast< int >(val2);
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_From_int(static_cast< int >(result));
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21718 PyObject *resultobj = 0;
21719 wxDC *arg1 = (wxDC *) 0 ;
21720 int arg2 ;
21721 int result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 int val2 ;
21725 int ecode2 = 0 ;
21726 PyObject * obj0 = 0 ;
21727 PyObject * obj1 = 0 ;
21728 char * kwnames[] = {
21729 (char *) "self",(char *) "x", NULL
21730 };
21731
21732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) SWIG_fail;
21733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21734 if (!SWIG_IsOK(res1)) {
21735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21736 }
21737 arg1 = reinterpret_cast< wxDC * >(argp1);
21738 ecode2 = SWIG_AsVal_int(obj1, &val2);
21739 if (!SWIG_IsOK(ecode2)) {
21740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceXRel" "', expected argument " "2"" of type '" "int""'");
21741 }
21742 arg2 = static_cast< int >(val2);
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 resultobj = SWIG_From_int(static_cast< int >(result));
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21757 PyObject *resultobj = 0;
21758 wxDC *arg1 = (wxDC *) 0 ;
21759 int arg2 ;
21760 int result;
21761 void *argp1 = 0 ;
21762 int res1 = 0 ;
21763 int val2 ;
21764 int ecode2 = 0 ;
21765 PyObject * obj0 = 0 ;
21766 PyObject * obj1 = 0 ;
21767 char * kwnames[] = {
21768 (char *) "self",(char *) "y", NULL
21769 };
21770
21771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) SWIG_fail;
21772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21773 if (!SWIG_IsOK(res1)) {
21774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "1"" of type '" "wxDC const *""'");
21775 }
21776 arg1 = reinterpret_cast< wxDC * >(argp1);
21777 ecode2 = SWIG_AsVal_int(obj1, &val2);
21778 if (!SWIG_IsOK(ecode2)) {
21779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_LogicalToDeviceYRel" "', expected argument " "2"" of type '" "int""'");
21780 }
21781 arg2 = static_cast< int >(val2);
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_From_int(static_cast< int >(result));
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_DC_CanDrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxDC *arg1 = (wxDC *) 0 ;
21798 bool result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanDrawBitmap" "', expected argument " "1"" of type '" "wxDC const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxDC * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 {
21817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21818 }
21819 return resultobj;
21820 fail:
21821 return NULL;
21822 }
21823
21824
21825 SWIGINTERN PyObject *_wrap_DC_CanGetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21826 PyObject *resultobj = 0;
21827 wxDC *arg1 = (wxDC *) 0 ;
21828 bool result;
21829 void *argp1 = 0 ;
21830 int res1 = 0 ;
21831 PyObject *swig_obj[1] ;
21832
21833 if (!args) SWIG_fail;
21834 swig_obj[0] = args;
21835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CanGetTextExtent" "', expected argument " "1"" of type '" "wxDC const *""'");
21838 }
21839 arg1 = reinterpret_cast< wxDC * >(argp1);
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 {
21847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21848 }
21849 return resultobj;
21850 fail:
21851 return NULL;
21852 }
21853
21854
21855 SWIGINTERN PyObject *_wrap_DC_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21856 PyObject *resultobj = 0;
21857 wxDC *arg1 = (wxDC *) 0 ;
21858 int result;
21859 void *argp1 = 0 ;
21860 int res1 = 0 ;
21861 PyObject *swig_obj[1] ;
21862
21863 if (!args) SWIG_fail;
21864 swig_obj[0] = args;
21865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21866 if (!SWIG_IsOK(res1)) {
21867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDepth" "', expected argument " "1"" of type '" "wxDC const *""'");
21868 }
21869 arg1 = reinterpret_cast< wxDC * >(argp1);
21870 {
21871 PyThreadState* __tstate = wxPyBeginAllowThreads();
21872 result = (int)((wxDC const *)arg1)->GetDepth();
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 resultobj = SWIG_From_int(static_cast< int >(result));
21877 return resultobj;
21878 fail:
21879 return NULL;
21880 }
21881
21882
21883 SWIGINTERN PyObject *_wrap_DC_GetPPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21884 PyObject *resultobj = 0;
21885 wxDC *arg1 = (wxDC *) 0 ;
21886 wxSize result;
21887 void *argp1 = 0 ;
21888 int res1 = 0 ;
21889 PyObject *swig_obj[1] ;
21890
21891 if (!args) SWIG_fail;
21892 swig_obj[0] = args;
21893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21894 if (!SWIG_IsOK(res1)) {
21895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPPI" "', expected argument " "1"" of type '" "wxDC const *""'");
21896 }
21897 arg1 = reinterpret_cast< wxDC * >(argp1);
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 result = ((wxDC const *)arg1)->GetPPI();
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 SWIGINTERN PyObject *_wrap_DC_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21912 PyObject *resultobj = 0;
21913 wxDC *arg1 = (wxDC *) 0 ;
21914 bool result;
21915 void *argp1 = 0 ;
21916 int res1 = 0 ;
21917 PyObject *swig_obj[1] ;
21918
21919 if (!args) SWIG_fail;
21920 swig_obj[0] = args;
21921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21922 if (!SWIG_IsOK(res1)) {
21923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_Ok" "', expected argument " "1"" of type '" "wxDC const *""'");
21924 }
21925 arg1 = reinterpret_cast< wxDC * >(argp1);
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (bool)((wxDC const *)arg1)->Ok();
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 {
21933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21934 }
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 SWIGINTERN PyObject *_wrap_DC_GetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21942 PyObject *resultobj = 0;
21943 wxDC *arg1 = (wxDC *) 0 ;
21944 int result;
21945 void *argp1 = 0 ;
21946 int res1 = 0 ;
21947 PyObject *swig_obj[1] ;
21948
21949 if (!args) SWIG_fail;
21950 swig_obj[0] = args;
21951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21952 if (!SWIG_IsOK(res1)) {
21953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackgroundMode" "', expected argument " "1"" of type '" "wxDC const *""'");
21954 }
21955 arg1 = reinterpret_cast< wxDC * >(argp1);
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 resultobj = SWIG_From_int(static_cast< int >(result));
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_DC_GetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21970 PyObject *resultobj = 0;
21971 wxDC *arg1 = (wxDC *) 0 ;
21972 wxBrush *result = 0 ;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 PyObject *swig_obj[1] ;
21976
21977 if (!args) SWIG_fail;
21978 swig_obj[0] = args;
21979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
21982 }
21983 arg1 = reinterpret_cast< wxDC * >(argp1);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 {
21987 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
21988 result = (wxBrush *) &_result_ref;
21989 }
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 wxBrush* resultptr = new wxBrush(*result);
21995 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
21996 }
21997 return resultobj;
21998 fail:
21999 return NULL;
22000 }
22001
22002
22003 SWIGINTERN PyObject *_wrap_DC_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22004 PyObject *resultobj = 0;
22005 wxDC *arg1 = (wxDC *) 0 ;
22006 wxBrush *result = 0 ;
22007 void *argp1 = 0 ;
22008 int res1 = 0 ;
22009 PyObject *swig_obj[1] ;
22010
22011 if (!args) SWIG_fail;
22012 swig_obj[0] = args;
22013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22014 if (!SWIG_IsOK(res1)) {
22015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBrush" "', expected argument " "1"" of type '" "wxDC const *""'");
22016 }
22017 arg1 = reinterpret_cast< wxDC * >(argp1);
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 {
22021 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
22022 result = (wxBrush *) &_result_ref;
22023 }
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 wxBrush* resultptr = new wxBrush(*result);
22029 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
22030 }
22031 return resultobj;
22032 fail:
22033 return NULL;
22034 }
22035
22036
22037 SWIGINTERN PyObject *_wrap_DC_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22038 PyObject *resultobj = 0;
22039 wxDC *arg1 = (wxDC *) 0 ;
22040 wxFont *result = 0 ;
22041 void *argp1 = 0 ;
22042 int res1 = 0 ;
22043 PyObject *swig_obj[1] ;
22044
22045 if (!args) SWIG_fail;
22046 swig_obj[0] = args;
22047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetFont" "', expected argument " "1"" of type '" "wxDC const *""'");
22050 }
22051 arg1 = reinterpret_cast< wxDC * >(argp1);
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 {
22055 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
22056 result = (wxFont *) &_result_ref;
22057 }
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 {
22062 wxFont* resultptr = new wxFont(*result);
22063 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
22064 }
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_DC_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxDC *arg1 = (wxDC *) 0 ;
22074 wxPen *result = 0 ;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 PyObject *swig_obj[1] ;
22078
22079 if (!args) SWIG_fail;
22080 swig_obj[0] = args;
22081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22082 if (!SWIG_IsOK(res1)) {
22083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetPen" "', expected argument " "1"" of type '" "wxDC const *""'");
22084 }
22085 arg1 = reinterpret_cast< wxDC * >(argp1);
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 {
22089 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
22090 result = (wxPen *) &_result_ref;
22091 }
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 {
22096 wxPen* resultptr = new wxPen(*result);
22097 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
22098 }
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_DC_GetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxDC *arg1 = (wxDC *) 0 ;
22108 wxColour *result = 0 ;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextBackground" "', expected argument " "1"" of type '" "wxDC const *""'");
22118 }
22119 arg1 = reinterpret_cast< wxDC * >(argp1);
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 {
22123 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
22124 result = (wxColour *) &_result_ref;
22125 }
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_DC_GetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxDC *arg1 = (wxDC *) 0 ;
22139 wxColour *result = 0 ;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetTextForeground" "', expected argument " "1"" of type '" "wxDC const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxDC * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 {
22154 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
22155 result = (wxColour *) &_result_ref;
22156 }
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 SWIGINTERN PyObject *_wrap_DC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj = 0;
22169 wxDC *arg1 = (wxDC *) 0 ;
22170 wxColour *arg2 = 0 ;
22171 void *argp1 = 0 ;
22172 int res1 = 0 ;
22173 wxColour temp2 ;
22174 PyObject * obj0 = 0 ;
22175 PyObject * obj1 = 0 ;
22176 char * kwnames[] = {
22177 (char *) "self",(char *) "colour", NULL
22178 };
22179
22180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
22181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22182 if (!SWIG_IsOK(res1)) {
22183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextForeground" "', expected argument " "1"" of type '" "wxDC *""'");
22184 }
22185 arg1 = reinterpret_cast< wxDC * >(argp1);
22186 {
22187 arg2 = &temp2;
22188 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 (arg1)->SetTextForeground((wxColour const &)*arg2);
22193 wxPyEndAllowThreads(__tstate);
22194 if (PyErr_Occurred()) SWIG_fail;
22195 }
22196 resultobj = SWIG_Py_Void();
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 SWIGINTERN PyObject *_wrap_DC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj = 0;
22205 wxDC *arg1 = (wxDC *) 0 ;
22206 wxColour *arg2 = 0 ;
22207 void *argp1 = 0 ;
22208 int res1 = 0 ;
22209 wxColour temp2 ;
22210 PyObject * obj0 = 0 ;
22211 PyObject * obj1 = 0 ;
22212 char * kwnames[] = {
22213 (char *) "self",(char *) "colour", NULL
22214 };
22215
22216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
22217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetTextBackground" "', expected argument " "1"" of type '" "wxDC *""'");
22220 }
22221 arg1 = reinterpret_cast< wxDC * >(argp1);
22222 {
22223 arg2 = &temp2;
22224 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
22225 }
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 (arg1)->SetTextBackground((wxColour const &)*arg2);
22229 wxPyEndAllowThreads(__tstate);
22230 if (PyErr_Occurred()) SWIG_fail;
22231 }
22232 resultobj = SWIG_Py_Void();
22233 return resultobj;
22234 fail:
22235 return NULL;
22236 }
22237
22238
22239 SWIGINTERN PyObject *_wrap_DC_GetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22240 PyObject *resultobj = 0;
22241 wxDC *arg1 = (wxDC *) 0 ;
22242 int result;
22243 void *argp1 = 0 ;
22244 int res1 = 0 ;
22245 PyObject *swig_obj[1] ;
22246
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetMapMode" "', expected argument " "1"" of type '" "wxDC const *""'");
22252 }
22253 arg1 = reinterpret_cast< wxDC * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 result = (int)((wxDC const *)arg1)->GetMapMode();
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 resultobj = SWIG_From_int(static_cast< int >(result));
22261 return resultobj;
22262 fail:
22263 return NULL;
22264 }
22265
22266
22267 SWIGINTERN PyObject *_wrap_DC_SetMapMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22268 PyObject *resultobj = 0;
22269 wxDC *arg1 = (wxDC *) 0 ;
22270 int arg2 ;
22271 void *argp1 = 0 ;
22272 int res1 = 0 ;
22273 int val2 ;
22274 int ecode2 = 0 ;
22275 PyObject * obj0 = 0 ;
22276 PyObject * obj1 = 0 ;
22277 char * kwnames[] = {
22278 (char *) "self",(char *) "mode", NULL
22279 };
22280
22281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) SWIG_fail;
22282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22283 if (!SWIG_IsOK(res1)) {
22284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetMapMode" "', expected argument " "1"" of type '" "wxDC *""'");
22285 }
22286 arg1 = reinterpret_cast< wxDC * >(argp1);
22287 ecode2 = SWIG_AsVal_int(obj1, &val2);
22288 if (!SWIG_IsOK(ecode2)) {
22289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetMapMode" "', expected argument " "2"" of type '" "int""'");
22290 }
22291 arg2 = static_cast< int >(val2);
22292 {
22293 PyThreadState* __tstate = wxPyBeginAllowThreads();
22294 (arg1)->SetMapMode(arg2);
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_Py_Void();
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 SWIGINTERN PyObject *_wrap_DC_GetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22306 PyObject *resultobj = 0;
22307 wxDC *arg1 = (wxDC *) 0 ;
22308 double *arg2 = (double *) 0 ;
22309 double *arg3 = (double *) 0 ;
22310 void *argp1 = 0 ;
22311 int res1 = 0 ;
22312 double temp2 ;
22313 int res2 = SWIG_TMPOBJ ;
22314 double temp3 ;
22315 int res3 = SWIG_TMPOBJ ;
22316 PyObject *swig_obj[1] ;
22317
22318 arg2 = &temp2;
22319 arg3 = &temp3;
22320 if (!args) SWIG_fail;
22321 swig_obj[0] = args;
22322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22323 if (!SWIG_IsOK(res1)) {
22324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetUserScale" "', expected argument " "1"" of type '" "wxDC const *""'");
22325 }
22326 arg1 = reinterpret_cast< wxDC * >(argp1);
22327 {
22328 PyThreadState* __tstate = wxPyBeginAllowThreads();
22329 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
22330 wxPyEndAllowThreads(__tstate);
22331 if (PyErr_Occurred()) SWIG_fail;
22332 }
22333 resultobj = SWIG_Py_Void();
22334 if (SWIG_IsTmpObj(res2)) {
22335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
22336 } else {
22337 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
22339 }
22340 if (SWIG_IsTmpObj(res3)) {
22341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
22342 } else {
22343 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
22345 }
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_DC_SetUserScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj = 0;
22354 wxDC *arg1 = (wxDC *) 0 ;
22355 double arg2 ;
22356 double arg3 ;
22357 void *argp1 = 0 ;
22358 int res1 = 0 ;
22359 double val2 ;
22360 int ecode2 = 0 ;
22361 double val3 ;
22362 int ecode3 = 0 ;
22363 PyObject * obj0 = 0 ;
22364 PyObject * obj1 = 0 ;
22365 PyObject * obj2 = 0 ;
22366 char * kwnames[] = {
22367 (char *) "self",(char *) "x",(char *) "y", NULL
22368 };
22369
22370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetUserScale" "', expected argument " "1"" of type '" "wxDC *""'");
22374 }
22375 arg1 = reinterpret_cast< wxDC * >(argp1);
22376 ecode2 = SWIG_AsVal_double(obj1, &val2);
22377 if (!SWIG_IsOK(ecode2)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetUserScale" "', expected argument " "2"" of type '" "double""'");
22379 }
22380 arg2 = static_cast< double >(val2);
22381 ecode3 = SWIG_AsVal_double(obj2, &val3);
22382 if (!SWIG_IsOK(ecode3)) {
22383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetUserScale" "', expected argument " "3"" of type '" "double""'");
22384 }
22385 arg3 = static_cast< double >(val3);
22386 {
22387 PyThreadState* __tstate = wxPyBeginAllowThreads();
22388 (arg1)->SetUserScale(arg2,arg3);
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_GetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22400 PyObject *resultobj = 0;
22401 wxDC *arg1 = (wxDC *) 0 ;
22402 double *arg2 = (double *) 0 ;
22403 double *arg3 = (double *) 0 ;
22404 void *argp1 = 0 ;
22405 int res1 = 0 ;
22406 double temp2 ;
22407 int res2 = SWIG_TMPOBJ ;
22408 double temp3 ;
22409 int res3 = SWIG_TMPOBJ ;
22410 PyObject *swig_obj[1] ;
22411
22412 arg2 = &temp2;
22413 arg3 = &temp3;
22414 if (!args) SWIG_fail;
22415 swig_obj[0] = args;
22416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22417 if (!SWIG_IsOK(res1)) {
22418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
22419 }
22420 arg1 = reinterpret_cast< wxDC * >(argp1);
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 (arg1)->GetLogicalScale(arg2,arg3);
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 resultobj = SWIG_Py_Void();
22428 if (SWIG_IsTmpObj(res2)) {
22429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
22430 } else {
22431 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
22433 }
22434 if (SWIG_IsTmpObj(res3)) {
22435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
22436 } else {
22437 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
22439 }
22440 return resultobj;
22441 fail:
22442 return NULL;
22443 }
22444
22445
22446 SWIGINTERN PyObject *_wrap_DC_SetLogicalScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22447 PyObject *resultobj = 0;
22448 wxDC *arg1 = (wxDC *) 0 ;
22449 double arg2 ;
22450 double arg3 ;
22451 void *argp1 = 0 ;
22452 int res1 = 0 ;
22453 double val2 ;
22454 int ecode2 = 0 ;
22455 double val3 ;
22456 int ecode3 = 0 ;
22457 PyObject * obj0 = 0 ;
22458 PyObject * obj1 = 0 ;
22459 PyObject * obj2 = 0 ;
22460 char * kwnames[] = {
22461 (char *) "self",(char *) "x",(char *) "y", NULL
22462 };
22463
22464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22466 if (!SWIG_IsOK(res1)) {
22467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalScale" "', expected argument " "1"" of type '" "wxDC *""'");
22468 }
22469 arg1 = reinterpret_cast< wxDC * >(argp1);
22470 ecode2 = SWIG_AsVal_double(obj1, &val2);
22471 if (!SWIG_IsOK(ecode2)) {
22472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalScale" "', expected argument " "2"" of type '" "double""'");
22473 }
22474 arg2 = static_cast< double >(val2);
22475 ecode3 = SWIG_AsVal_double(obj2, &val3);
22476 if (!SWIG_IsOK(ecode3)) {
22477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalScale" "', expected argument " "3"" of type '" "double""'");
22478 }
22479 arg3 = static_cast< double >(val3);
22480 {
22481 PyThreadState* __tstate = wxPyBeginAllowThreads();
22482 (arg1)->SetLogicalScale(arg2,arg3);
22483 wxPyEndAllowThreads(__tstate);
22484 if (PyErr_Occurred()) SWIG_fail;
22485 }
22486 resultobj = SWIG_Py_Void();
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 SWIGINTERN PyObject *_wrap_DC_GetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22494 PyObject *resultobj = 0;
22495 wxDC *arg1 = (wxDC *) 0 ;
22496 wxPoint result;
22497 void *argp1 = 0 ;
22498 int res1 = 0 ;
22499 PyObject *swig_obj[1] ;
22500
22501 if (!args) SWIG_fail;
22502 swig_obj[0] = args;
22503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22504 if (!SWIG_IsOK(res1)) {
22505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
22506 }
22507 arg1 = reinterpret_cast< wxDC * >(argp1);
22508 {
22509 PyThreadState* __tstate = wxPyBeginAllowThreads();
22510 result = ((wxDC const *)arg1)->GetLogicalOrigin();
22511 wxPyEndAllowThreads(__tstate);
22512 if (PyErr_Occurred()) SWIG_fail;
22513 }
22514 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22515 return resultobj;
22516 fail:
22517 return NULL;
22518 }
22519
22520
22521 SWIGINTERN PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22522 PyObject *resultobj = 0;
22523 wxDC *arg1 = (wxDC *) 0 ;
22524 int *arg2 = (int *) 0 ;
22525 int *arg3 = (int *) 0 ;
22526 void *argp1 = 0 ;
22527 int res1 = 0 ;
22528 int temp2 ;
22529 int res2 = SWIG_TMPOBJ ;
22530 int temp3 ;
22531 int res3 = SWIG_TMPOBJ ;
22532 PyObject *swig_obj[1] ;
22533
22534 arg2 = &temp2;
22535 arg3 = &temp3;
22536 if (!args) SWIG_fail;
22537 swig_obj[0] = args;
22538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
22541 }
22542 arg1 = reinterpret_cast< wxDC * >(argp1);
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_Py_Void();
22550 if (SWIG_IsTmpObj(res2)) {
22551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22552 } else {
22553 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22555 }
22556 if (SWIG_IsTmpObj(res3)) {
22557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22558 } else {
22559 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22561 }
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 SWIGINTERN PyObject *_wrap_DC_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22569 PyObject *resultobj = 0;
22570 wxDC *arg1 = (wxDC *) 0 ;
22571 int arg2 ;
22572 int arg3 ;
22573 void *argp1 = 0 ;
22574 int res1 = 0 ;
22575 int val2 ;
22576 int ecode2 = 0 ;
22577 int val3 ;
22578 int ecode3 = 0 ;
22579 PyObject * obj0 = 0 ;
22580 PyObject * obj1 = 0 ;
22581 PyObject * obj2 = 0 ;
22582 char * kwnames[] = {
22583 (char *) "self",(char *) "x",(char *) "y", NULL
22584 };
22585
22586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22590 }
22591 arg1 = reinterpret_cast< wxDC * >(argp1);
22592 ecode2 = SWIG_AsVal_int(obj1, &val2);
22593 if (!SWIG_IsOK(ecode2)) {
22594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
22595 }
22596 arg2 = static_cast< int >(val2);
22597 ecode3 = SWIG_AsVal_int(obj2, &val3);
22598 if (!SWIG_IsOK(ecode3)) {
22599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
22600 }
22601 arg3 = static_cast< int >(val3);
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 (arg1)->SetLogicalOrigin(arg2,arg3);
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 resultobj = SWIG_Py_Void();
22609 return resultobj;
22610 fail:
22611 return NULL;
22612 }
22613
22614
22615 SWIGINTERN PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22616 PyObject *resultobj = 0;
22617 wxDC *arg1 = (wxDC *) 0 ;
22618 wxPoint *arg2 = 0 ;
22619 void *argp1 = 0 ;
22620 int res1 = 0 ;
22621 wxPoint temp2 ;
22622 PyObject * obj0 = 0 ;
22623 PyObject * obj1 = 0 ;
22624 char * kwnames[] = {
22625 (char *) "self",(char *) "point", NULL
22626 };
22627
22628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22630 if (!SWIG_IsOK(res1)) {
22631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22632 }
22633 arg1 = reinterpret_cast< wxDC * >(argp1);
22634 {
22635 arg2 = &temp2;
22636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22637 }
22638 {
22639 PyThreadState* __tstate = wxPyBeginAllowThreads();
22640 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 resultobj = SWIG_Py_Void();
22645 return resultobj;
22646 fail:
22647 return NULL;
22648 }
22649
22650
22651 SWIGINTERN PyObject *_wrap_DC_GetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22652 PyObject *resultobj = 0;
22653 wxDC *arg1 = (wxDC *) 0 ;
22654 wxPoint result;
22655 void *argp1 = 0 ;
22656 int res1 = 0 ;
22657 PyObject *swig_obj[1] ;
22658
22659 if (!args) SWIG_fail;
22660 swig_obj[0] = args;
22661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC const *""'");
22664 }
22665 arg1 = reinterpret_cast< wxDC * >(argp1);
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 result = ((wxDC const *)arg1)->GetDeviceOrigin();
22669 wxPyEndAllowThreads(__tstate);
22670 if (PyErr_Occurred()) SWIG_fail;
22671 }
22672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 SWIGINTERN PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680 PyObject *resultobj = 0;
22681 wxDC *arg1 = (wxDC *) 0 ;
22682 int *arg2 = (int *) 0 ;
22683 int *arg3 = (int *) 0 ;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 int temp2 ;
22687 int res2 = SWIG_TMPOBJ ;
22688 int temp3 ;
22689 int res3 = SWIG_TMPOBJ ;
22690 PyObject *swig_obj[1] ;
22691
22692 arg2 = &temp2;
22693 arg3 = &temp3;
22694 if (!args) SWIG_fail;
22695 swig_obj[0] = args;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetDeviceOriginTuple" "', expected argument " "1"" of type '" "wxDC const *""'");
22699 }
22700 arg1 = reinterpret_cast< wxDC * >(argp1);
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = SWIG_Py_Void();
22708 if (SWIG_IsTmpObj(res2)) {
22709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
22710 } else {
22711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22713 }
22714 if (SWIG_IsTmpObj(res3)) {
22715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
22716 } else {
22717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
22719 }
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 SWIGINTERN PyObject *_wrap_DC_SetDeviceOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22727 PyObject *resultobj = 0;
22728 wxDC *arg1 = (wxDC *) 0 ;
22729 int arg2 ;
22730 int arg3 ;
22731 void *argp1 = 0 ;
22732 int res1 = 0 ;
22733 int val2 ;
22734 int ecode2 = 0 ;
22735 int val3 ;
22736 int ecode3 = 0 ;
22737 PyObject * obj0 = 0 ;
22738 PyObject * obj1 = 0 ;
22739 PyObject * obj2 = 0 ;
22740 char * kwnames[] = {
22741 (char *) "self",(char *) "x",(char *) "y", NULL
22742 };
22743
22744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22748 }
22749 arg1 = reinterpret_cast< wxDC * >(argp1);
22750 ecode2 = SWIG_AsVal_int(obj1, &val2);
22751 if (!SWIG_IsOK(ecode2)) {
22752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetDeviceOrigin" "', expected argument " "2"" of type '" "int""'");
22753 }
22754 arg2 = static_cast< int >(val2);
22755 ecode3 = SWIG_AsVal_int(obj2, &val3);
22756 if (!SWIG_IsOK(ecode3)) {
22757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetDeviceOrigin" "', expected argument " "3"" of type '" "int""'");
22758 }
22759 arg3 = static_cast< int >(val3);
22760 {
22761 PyThreadState* __tstate = wxPyBeginAllowThreads();
22762 (arg1)->SetDeviceOrigin(arg2,arg3);
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = SWIG_Py_Void();
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22774 PyObject *resultobj = 0;
22775 wxDC *arg1 = (wxDC *) 0 ;
22776 wxPoint *arg2 = 0 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 wxPoint temp2 ;
22780 PyObject * obj0 = 0 ;
22781 PyObject * obj1 = 0 ;
22782 char * kwnames[] = {
22783 (char *) "self",(char *) "point", NULL
22784 };
22785
22786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) SWIG_fail;
22787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22788 if (!SWIG_IsOK(res1)) {
22789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetDeviceOriginPoint" "', expected argument " "1"" of type '" "wxDC *""'");
22790 }
22791 arg1 = reinterpret_cast< wxDC * >(argp1);
22792 {
22793 arg2 = &temp2;
22794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22795 }
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_Py_Void();
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *_wrap_DC_SetAxisOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22810 PyObject *resultobj = 0;
22811 wxDC *arg1 = (wxDC *) 0 ;
22812 bool arg2 ;
22813 bool arg3 ;
22814 void *argp1 = 0 ;
22815 int res1 = 0 ;
22816 bool val2 ;
22817 int ecode2 = 0 ;
22818 bool val3 ;
22819 int ecode3 = 0 ;
22820 PyObject * obj0 = 0 ;
22821 PyObject * obj1 = 0 ;
22822 PyObject * obj2 = 0 ;
22823 char * kwnames[] = {
22824 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
22825 };
22826
22827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22829 if (!SWIG_IsOK(res1)) {
22830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetAxisOrientation" "', expected argument " "1"" of type '" "wxDC *""'");
22831 }
22832 arg1 = reinterpret_cast< wxDC * >(argp1);
22833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22834 if (!SWIG_IsOK(ecode2)) {
22835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetAxisOrientation" "', expected argument " "2"" of type '" "bool""'");
22836 }
22837 arg2 = static_cast< bool >(val2);
22838 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22839 if (!SWIG_IsOK(ecode3)) {
22840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_SetAxisOrientation" "', expected argument " "3"" of type '" "bool""'");
22841 }
22842 arg3 = static_cast< bool >(val3);
22843 {
22844 PyThreadState* __tstate = wxPyBeginAllowThreads();
22845 (arg1)->SetAxisOrientation(arg2,arg3);
22846 wxPyEndAllowThreads(__tstate);
22847 if (PyErr_Occurred()) SWIG_fail;
22848 }
22849 resultobj = SWIG_Py_Void();
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 SWIGINTERN PyObject *_wrap_DC_GetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22857 PyObject *resultobj = 0;
22858 wxDC *arg1 = (wxDC *) 0 ;
22859 int result;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 PyObject *swig_obj[1] ;
22863
22864 if (!args) SWIG_fail;
22865 swig_obj[0] = args;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetLogicalFunction" "', expected argument " "1"" of type '" "wxDC const *""'");
22869 }
22870 arg1 = reinterpret_cast< wxDC * >(argp1);
22871 {
22872 PyThreadState* __tstate = wxPyBeginAllowThreads();
22873 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
22874 wxPyEndAllowThreads(__tstate);
22875 if (PyErr_Occurred()) SWIG_fail;
22876 }
22877 resultobj = SWIG_From_int(static_cast< int >(result));
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_DC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22885 PyObject *resultobj = 0;
22886 wxDC *arg1 = (wxDC *) 0 ;
22887 int arg2 ;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 int val2 ;
22891 int ecode2 = 0 ;
22892 PyObject * obj0 = 0 ;
22893 PyObject * obj1 = 0 ;
22894 char * kwnames[] = {
22895 (char *) "self",(char *) "function", NULL
22896 };
22897
22898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxDC *""'");
22902 }
22903 arg1 = reinterpret_cast< wxDC * >(argp1);
22904 ecode2 = SWIG_AsVal_int(obj1, &val2);
22905 if (!SWIG_IsOK(ecode2)) {
22906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
22907 }
22908 arg2 = static_cast< int >(val2);
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 (arg1)->SetLogicalFunction(arg2);
22912 wxPyEndAllowThreads(__tstate);
22913 if (PyErr_Occurred()) SWIG_fail;
22914 }
22915 resultobj = SWIG_Py_Void();
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxDC *arg1 = (wxDC *) 0 ;
22925 void *argp1 = 0 ;
22926 int res1 = 0 ;
22927 PyObject *swig_obj[1] ;
22928
22929 if (!args) SWIG_fail;
22930 swig_obj[0] = args;
22931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22932 if (!SWIG_IsOK(res1)) {
22933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ComputeScaleAndOrigin" "', expected argument " "1"" of type '" "wxDC *""'");
22934 }
22935 arg1 = reinterpret_cast< wxDC * >(argp1);
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 (arg1)->ComputeScaleAndOrigin();
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 resultobj = SWIG_Py_Void();
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22950 PyObject *resultobj = 0;
22951 wxDC *arg1 = (wxDC *) 0 ;
22952 int arg2 ;
22953 int arg3 ;
22954 void *argp1 = 0 ;
22955 int res1 = 0 ;
22956 int val2 ;
22957 int ecode2 = 0 ;
22958 int val3 ;
22959 int ecode3 = 0 ;
22960 PyObject * obj0 = 0 ;
22961 PyObject * obj1 = 0 ;
22962 PyObject * obj2 = 0 ;
22963 char * kwnames[] = {
22964 (char *) "self",(char *) "x",(char *) "y", NULL
22965 };
22966
22967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
22971 }
22972 arg1 = reinterpret_cast< wxDC * >(argp1);
22973 ecode2 = SWIG_AsVal_int(obj1, &val2);
22974 if (!SWIG_IsOK(ecode2)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DC_CalcBoundingBox" "', expected argument " "2"" of type '" "int""'");
22976 }
22977 arg2 = static_cast< int >(val2);
22978 ecode3 = SWIG_AsVal_int(obj2, &val3);
22979 if (!SWIG_IsOK(ecode3)) {
22980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DC_CalcBoundingBox" "', expected argument " "3"" of type '" "int""'");
22981 }
22982 arg3 = static_cast< int >(val3);
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 (arg1)->CalcBoundingBox(arg2,arg3);
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 resultobj = SWIG_Py_Void();
22990 return resultobj;
22991 fail:
22992 return NULL;
22993 }
22994
22995
22996 SWIGINTERN PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22997 PyObject *resultobj = 0;
22998 wxDC *arg1 = (wxDC *) 0 ;
22999 wxPoint *arg2 = 0 ;
23000 void *argp1 = 0 ;
23001 int res1 = 0 ;
23002 wxPoint temp2 ;
23003 PyObject * obj0 = 0 ;
23004 PyObject * obj1 = 0 ;
23005 char * kwnames[] = {
23006 (char *) "self",(char *) "point", NULL
23007 };
23008
23009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) SWIG_fail;
23010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23011 if (!SWIG_IsOK(res1)) {
23012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_CalcBoundingBoxPoint" "', expected argument " "1"" of type '" "wxDC *""'");
23013 }
23014 arg1 = reinterpret_cast< wxDC * >(argp1);
23015 {
23016 arg2 = &temp2;
23017 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_Py_Void();
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_DC_ResetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23033 PyObject *resultobj = 0;
23034 wxDC *arg1 = (wxDC *) 0 ;
23035 void *argp1 = 0 ;
23036 int res1 = 0 ;
23037 PyObject *swig_obj[1] ;
23038
23039 if (!args) SWIG_fail;
23040 swig_obj[0] = args;
23041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23042 if (!SWIG_IsOK(res1)) {
23043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_ResetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
23044 }
23045 arg1 = reinterpret_cast< wxDC * >(argp1);
23046 {
23047 PyThreadState* __tstate = wxPyBeginAllowThreads();
23048 (arg1)->ResetBoundingBox();
23049 wxPyEndAllowThreads(__tstate);
23050 if (PyErr_Occurred()) SWIG_fail;
23051 }
23052 resultobj = SWIG_Py_Void();
23053 return resultobj;
23054 fail:
23055 return NULL;
23056 }
23057
23058
23059 SWIGINTERN PyObject *_wrap_DC_MinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23060 PyObject *resultobj = 0;
23061 wxDC *arg1 = (wxDC *) 0 ;
23062 int result;
23063 void *argp1 = 0 ;
23064 int res1 = 0 ;
23065 PyObject *swig_obj[1] ;
23066
23067 if (!args) SWIG_fail;
23068 swig_obj[0] = args;
23069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23070 if (!SWIG_IsOK(res1)) {
23071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinX" "', expected argument " "1"" of type '" "wxDC const *""'");
23072 }
23073 arg1 = reinterpret_cast< wxDC * >(argp1);
23074 {
23075 PyThreadState* __tstate = wxPyBeginAllowThreads();
23076 result = (int)((wxDC const *)arg1)->MinX();
23077 wxPyEndAllowThreads(__tstate);
23078 if (PyErr_Occurred()) SWIG_fail;
23079 }
23080 resultobj = SWIG_From_int(static_cast< int >(result));
23081 return resultobj;
23082 fail:
23083 return NULL;
23084 }
23085
23086
23087 SWIGINTERN PyObject *_wrap_DC_MaxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23088 PyObject *resultobj = 0;
23089 wxDC *arg1 = (wxDC *) 0 ;
23090 int result;
23091 void *argp1 = 0 ;
23092 int res1 = 0 ;
23093 PyObject *swig_obj[1] ;
23094
23095 if (!args) SWIG_fail;
23096 swig_obj[0] = args;
23097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23098 if (!SWIG_IsOK(res1)) {
23099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxX" "', expected argument " "1"" of type '" "wxDC const *""'");
23100 }
23101 arg1 = reinterpret_cast< wxDC * >(argp1);
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 result = (int)((wxDC const *)arg1)->MaxX();
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 resultobj = SWIG_From_int(static_cast< int >(result));
23109 return resultobj;
23110 fail:
23111 return NULL;
23112 }
23113
23114
23115 SWIGINTERN PyObject *_wrap_DC_MinY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23116 PyObject *resultobj = 0;
23117 wxDC *arg1 = (wxDC *) 0 ;
23118 int result;
23119 void *argp1 = 0 ;
23120 int res1 = 0 ;
23121 PyObject *swig_obj[1] ;
23122
23123 if (!args) SWIG_fail;
23124 swig_obj[0] = args;
23125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23126 if (!SWIG_IsOK(res1)) {
23127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MinY" "', expected argument " "1"" of type '" "wxDC const *""'");
23128 }
23129 arg1 = reinterpret_cast< wxDC * >(argp1);
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (int)((wxDC const *)arg1)->MinY();
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 resultobj = SWIG_From_int(static_cast< int >(result));
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 SWIGINTERN PyObject *_wrap_DC_MaxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23144 PyObject *resultobj = 0;
23145 wxDC *arg1 = (wxDC *) 0 ;
23146 int result;
23147 void *argp1 = 0 ;
23148 int res1 = 0 ;
23149 PyObject *swig_obj[1] ;
23150
23151 if (!args) SWIG_fail;
23152 swig_obj[0] = args;
23153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_MaxY" "', expected argument " "1"" of type '" "wxDC const *""'");
23156 }
23157 arg1 = reinterpret_cast< wxDC * >(argp1);
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = (int)((wxDC const *)arg1)->MaxY();
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 resultobj = SWIG_From_int(static_cast< int >(result));
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_DC_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxDC *arg1 = (wxDC *) 0 ;
23174 int *arg2 = (int *) 0 ;
23175 int *arg3 = (int *) 0 ;
23176 int *arg4 = (int *) 0 ;
23177 int *arg5 = (int *) 0 ;
23178 void *argp1 = 0 ;
23179 int res1 = 0 ;
23180 int temp2 ;
23181 int res2 = SWIG_TMPOBJ ;
23182 int temp3 ;
23183 int res3 = SWIG_TMPOBJ ;
23184 int temp4 ;
23185 int res4 = SWIG_TMPOBJ ;
23186 int temp5 ;
23187 int res5 = SWIG_TMPOBJ ;
23188 PyObject *swig_obj[1] ;
23189
23190 arg2 = &temp2;
23191 arg3 = &temp3;
23192 arg4 = &temp4;
23193 arg5 = &temp5;
23194 if (!args) SWIG_fail;
23195 swig_obj[0] = args;
23196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23197 if (!SWIG_IsOK(res1)) {
23198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetBoundingBox" "', expected argument " "1"" of type '" "wxDC *""'");
23199 }
23200 arg1 = reinterpret_cast< wxDC * >(argp1);
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_Py_Void();
23208 if (SWIG_IsTmpObj(res2)) {
23209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
23210 } else {
23211 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
23213 }
23214 if (SWIG_IsTmpObj(res3)) {
23215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
23216 } else {
23217 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
23219 }
23220 if (SWIG_IsTmpObj(res4)) {
23221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
23222 } else {
23223 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
23225 }
23226 if (SWIG_IsTmpObj(res5)) {
23227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
23228 } else {
23229 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
23231 }
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_DC_GetHDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23239 PyObject *resultobj = 0;
23240 wxDC *arg1 = (wxDC *) 0 ;
23241 long result;
23242 void *argp1 = 0 ;
23243 int res1 = 0 ;
23244 PyObject *swig_obj[1] ;
23245
23246 if (!args) SWIG_fail;
23247 swig_obj[0] = args;
23248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23249 if (!SWIG_IsOK(res1)) {
23250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC_GetHDC" "', expected argument " "1"" of type '" "wxDC *""'");
23251 }
23252 arg1 = reinterpret_cast< wxDC * >(argp1);
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (long)(arg1)->GetHDC();
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_From_long(static_cast< long >(result));
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_DC__DrawPointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj = 0;
23268 wxDC *arg1 = (wxDC *) 0 ;
23269 PyObject *arg2 = (PyObject *) 0 ;
23270 PyObject *arg3 = (PyObject *) 0 ;
23271 PyObject *arg4 = (PyObject *) 0 ;
23272 PyObject *result = 0 ;
23273 void *argp1 = 0 ;
23274 int res1 = 0 ;
23275 PyObject * obj0 = 0 ;
23276 PyObject * obj1 = 0 ;
23277 PyObject * obj2 = 0 ;
23278 PyObject * obj3 = 0 ;
23279 char * kwnames[] = {
23280 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
23281 };
23282
23283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23285 if (!SWIG_IsOK(res1)) {
23286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPointList" "', expected argument " "1"" of type '" "wxDC *""'");
23287 }
23288 arg1 = reinterpret_cast< wxDC * >(argp1);
23289 arg2 = obj1;
23290 arg3 = obj2;
23291 arg4 = obj3;
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = result;
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DC__DrawLineList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 wxDC *arg1 = (wxDC *) 0 ;
23308 PyObject *arg2 = (PyObject *) 0 ;
23309 PyObject *arg3 = (PyObject *) 0 ;
23310 PyObject *arg4 = (PyObject *) 0 ;
23311 PyObject *result = 0 ;
23312 void *argp1 = 0 ;
23313 int res1 = 0 ;
23314 PyObject * obj0 = 0 ;
23315 PyObject * obj1 = 0 ;
23316 PyObject * obj2 = 0 ;
23317 PyObject * obj3 = 0 ;
23318 char * kwnames[] = {
23319 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
23320 };
23321
23322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23324 if (!SWIG_IsOK(res1)) {
23325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawLineList" "', expected argument " "1"" of type '" "wxDC *""'");
23326 }
23327 arg1 = reinterpret_cast< wxDC * >(argp1);
23328 arg2 = obj1;
23329 arg3 = obj2;
23330 arg4 = obj3;
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
23334 wxPyEndAllowThreads(__tstate);
23335 if (PyErr_Occurred()) SWIG_fail;
23336 }
23337 resultobj = result;
23338 return resultobj;
23339 fail:
23340 return NULL;
23341 }
23342
23343
23344 SWIGINTERN PyObject *_wrap_DC__DrawRectangleList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23345 PyObject *resultobj = 0;
23346 wxDC *arg1 = (wxDC *) 0 ;
23347 PyObject *arg2 = (PyObject *) 0 ;
23348 PyObject *arg3 = (PyObject *) 0 ;
23349 PyObject *arg4 = (PyObject *) 0 ;
23350 PyObject *result = 0 ;
23351 void *argp1 = 0 ;
23352 int res1 = 0 ;
23353 PyObject * obj0 = 0 ;
23354 PyObject * obj1 = 0 ;
23355 PyObject * obj2 = 0 ;
23356 PyObject * obj3 = 0 ;
23357 char * kwnames[] = {
23358 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
23359 };
23360
23361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23363 if (!SWIG_IsOK(res1)) {
23364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawRectangleList" "', expected argument " "1"" of type '" "wxDC *""'");
23365 }
23366 arg1 = reinterpret_cast< wxDC * >(argp1);
23367 arg2 = obj1;
23368 arg3 = obj2;
23369 arg4 = obj3;
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 resultobj = result;
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 SWIGINTERN PyObject *_wrap_DC__DrawEllipseList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj = 0;
23385 wxDC *arg1 = (wxDC *) 0 ;
23386 PyObject *arg2 = (PyObject *) 0 ;
23387 PyObject *arg3 = (PyObject *) 0 ;
23388 PyObject *arg4 = (PyObject *) 0 ;
23389 PyObject *result = 0 ;
23390 void *argp1 = 0 ;
23391 int res1 = 0 ;
23392 PyObject * obj0 = 0 ;
23393 PyObject * obj1 = 0 ;
23394 PyObject * obj2 = 0 ;
23395 PyObject * obj3 = 0 ;
23396 char * kwnames[] = {
23397 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
23398 };
23399
23400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23402 if (!SWIG_IsOK(res1)) {
23403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawEllipseList" "', expected argument " "1"" of type '" "wxDC *""'");
23404 }
23405 arg1 = reinterpret_cast< wxDC * >(argp1);
23406 arg2 = obj1;
23407 arg3 = obj2;
23408 arg4 = obj3;
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
23412 wxPyEndAllowThreads(__tstate);
23413 if (PyErr_Occurred()) SWIG_fail;
23414 }
23415 resultobj = result;
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_DC__DrawPolygonList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23423 PyObject *resultobj = 0;
23424 wxDC *arg1 = (wxDC *) 0 ;
23425 PyObject *arg2 = (PyObject *) 0 ;
23426 PyObject *arg3 = (PyObject *) 0 ;
23427 PyObject *arg4 = (PyObject *) 0 ;
23428 PyObject *result = 0 ;
23429 void *argp1 = 0 ;
23430 int res1 = 0 ;
23431 PyObject * obj0 = 0 ;
23432 PyObject * obj1 = 0 ;
23433 PyObject * obj2 = 0 ;
23434 PyObject * obj3 = 0 ;
23435 char * kwnames[] = {
23436 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
23437 };
23438
23439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23441 if (!SWIG_IsOK(res1)) {
23442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawPolygonList" "', expected argument " "1"" of type '" "wxDC *""'");
23443 }
23444 arg1 = reinterpret_cast< wxDC * >(argp1);
23445 arg2 = obj1;
23446 arg3 = obj2;
23447 arg4 = obj3;
23448 {
23449 PyThreadState* __tstate = wxPyBeginAllowThreads();
23450 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 resultobj = result;
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 SWIGINTERN PyObject *_wrap_DC__DrawTextList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj = 0;
23463 wxDC *arg1 = (wxDC *) 0 ;
23464 PyObject *arg2 = (PyObject *) 0 ;
23465 PyObject *arg3 = (PyObject *) 0 ;
23466 PyObject *arg4 = (PyObject *) 0 ;
23467 PyObject *arg5 = (PyObject *) 0 ;
23468 PyObject *result = 0 ;
23469 void *argp1 = 0 ;
23470 int res1 = 0 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 PyObject * obj2 = 0 ;
23474 PyObject * obj3 = 0 ;
23475 PyObject * obj4 = 0 ;
23476 char * kwnames[] = {
23477 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
23478 };
23479
23480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DC__DrawTextList" "', expected argument " "1"" of type '" "wxDC *""'");
23484 }
23485 arg1 = reinterpret_cast< wxDC * >(argp1);
23486 arg2 = obj1;
23487 arg3 = obj2;
23488 arg4 = obj3;
23489 arg5 = obj4;
23490 {
23491 PyThreadState* __tstate = wxPyBeginAllowThreads();
23492 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 resultobj = result;
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 SWIGINTERN PyObject *DC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 PyObject *obj;
23505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23506 SWIG_TypeNewClientData(SWIGTYPE_p_wxDC, SWIG_NewClientData(obj));
23507 return SWIG_Py_Void();
23508 }
23509
23510 SWIGINTERN PyObject *_wrap_new_MemoryDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23511 PyObject *resultobj = 0;
23512 wxMemoryDC *result = 0 ;
23513
23514 if (!SWIG_Python_UnpackTuple(args,"new_MemoryDC",0,0,0)) SWIG_fail;
23515 {
23516 if (!wxPyCheckForApp()) SWIG_fail;
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (wxMemoryDC *)new wxMemoryDC();
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_NEW | 0 );
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 SWIGINTERN PyObject *_wrap_new_MemoryDCFromDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj = 0;
23531 wxDC *arg1 = (wxDC *) 0 ;
23532 wxMemoryDC *result = 0 ;
23533 void *argp1 = 0 ;
23534 int res1 = 0 ;
23535 PyObject * obj0 = 0 ;
23536 char * kwnames[] = {
23537 (char *) "oldDC", NULL
23538 };
23539
23540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) SWIG_fail;
23541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23542 if (!SWIG_IsOK(res1)) {
23543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MemoryDCFromDC" "', expected argument " "1"" of type '" "wxDC *""'");
23544 }
23545 arg1 = reinterpret_cast< wxDC * >(argp1);
23546 {
23547 if (!wxPyCheckForApp()) SWIG_fail;
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (wxMemoryDC *)new wxMemoryDC(arg1);
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_OWN | 0 );
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_MemoryDC_SelectObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj = 0;
23562 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
23563 wxBitmap *arg2 = 0 ;
23564 void *argp1 = 0 ;
23565 int res1 = 0 ;
23566 void *argp2 = 0 ;
23567 int res2 = 0 ;
23568 PyObject * obj0 = 0 ;
23569 PyObject * obj1 = 0 ;
23570 char * kwnames[] = {
23571 (char *) "self",(char *) "bitmap", NULL
23572 };
23573
23574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) SWIG_fail;
23575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryDC, 0 | 0 );
23576 if (!SWIG_IsOK(res1)) {
23577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryDC_SelectObject" "', expected argument " "1"" of type '" "wxMemoryDC *""'");
23578 }
23579 arg1 = reinterpret_cast< wxMemoryDC * >(argp1);
23580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23581 if (!SWIG_IsOK(res2)) {
23582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23583 }
23584 if (!argp2) {
23585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryDC_SelectObject" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23586 }
23587 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 (arg1)->SelectObject((wxBitmap const &)*arg2);
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_Py_Void();
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *MemoryDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *obj;
23603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23604 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryDC, SWIG_NewClientData(obj));
23605 return SWIG_Py_Void();
23606 }
23607
23608 SWIGINTERN PyObject *MemoryDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 return SWIG_Python_InitShadowInstance(args);
23610 }
23611
23612 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
23613 PyObject *resultobj = 0;
23614 wxDC *arg1 = (wxDC *) 0 ;
23615 wxBitmap const &arg2_defvalue = wxNullBitmap ;
23616 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
23617 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
23618 wxBufferedDC *result = 0 ;
23619 void *argp1 = 0 ;
23620 int res1 = 0 ;
23621 void *argp2 = 0 ;
23622 int res2 = 0 ;
23623 int val3 ;
23624 int ecode3 = 0 ;
23625
23626 if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
23630 }
23631 arg1 = reinterpret_cast< wxDC * >(argp1);
23632 if (swig_obj[1]) {
23633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23634 if (!SWIG_IsOK(res2)) {
23635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23636 }
23637 if (!argp2) {
23638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23639 }
23640 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23641 }
23642 if (swig_obj[2]) {
23643 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
23644 if (!SWIG_IsOK(ecode3)) {
23645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
23646 }
23647 arg3 = static_cast< int >(val3);
23648 }
23649 {
23650 if (!wxPyCheckForApp()) SWIG_fail;
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
23653 wxPyEndAllowThreads(__tstate);
23654 if (PyErr_Occurred()) SWIG_fail;
23655 }
23656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
23657 return resultobj;
23658 fail:
23659 return NULL;
23660 }
23661
23662
23663 SWIGINTERN PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
23664 PyObject *resultobj = 0;
23665 wxDC *arg1 = (wxDC *) 0 ;
23666 wxSize *arg2 = 0 ;
23667 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
23668 wxBufferedDC *result = 0 ;
23669 void *argp1 = 0 ;
23670 int res1 = 0 ;
23671 wxSize temp2 ;
23672 int val3 ;
23673 int ecode3 = 0 ;
23674
23675 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
23676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDC, 0 | 0 );
23677 if (!SWIG_IsOK(res1)) {
23678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedDC" "', expected argument " "1"" of type '" "wxDC *""'");
23679 }
23680 arg1 = reinterpret_cast< wxDC * >(argp1);
23681 {
23682 arg2 = &temp2;
23683 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
23684 }
23685 if (swig_obj[2]) {
23686 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
23687 if (!SWIG_IsOK(ecode3)) {
23688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedDC" "', expected argument " "3"" of type '" "int""'");
23689 }
23690 arg3 = static_cast< int >(val3);
23691 }
23692 {
23693 if (!wxPyCheckForApp()) SWIG_fail;
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_NEW | 0 );
23700 return resultobj;
23701 fail:
23702 return NULL;
23703 }
23704
23705
23706 SWIGINTERN PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
23707 int argc;
23708 PyObject *argv[4];
23709
23710 if (!(argc = SWIG_Python_UnpackTuple(args,"new_BufferedDC",0,3,argv))) SWIG_fail;
23711 --argc;
23712 if ((argc >= 1) && (argc <= 3)) {
23713 int _v = 0;
23714 if (argc > 1) {
23715 {
23716 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxBitmap, 0);
23717 _v = SWIG_CheckState(res);
23718 }
23719 if (!_v) goto check_1;
23720 }
23721 return _wrap_new_BufferedDC__SWIG_0(self, argc, argv);
23722 }
23723 check_1:
23724
23725 if ((argc >= 2) && (argc <= 3)) {
23726 return _wrap_new_BufferedDC__SWIG_1(self, argc, argv);
23727 }
23728
23729 fail:
23730 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_delete_BufferedDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 PyObject *resultobj = 0;
23737 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23738 void *argp1 = 0 ;
23739 int res1 = 0 ;
23740 PyObject *swig_obj[1] ;
23741
23742 if (!args) SWIG_fail;
23743 swig_obj[0] = args;
23744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_DISOWN | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BufferedDC" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23747 }
23748 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 delete arg1;
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 resultobj = SWIG_Py_Void();
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 SWIGINTERN PyObject *_wrap_BufferedDC_UnMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 PyObject *resultobj = 0;
23765 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 PyObject *swig_obj[1] ;
23769
23770 if (!args) SWIG_fail;
23771 swig_obj[0] = args;
23772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBufferedDC, 0 | 0 );
23773 if (!SWIG_IsOK(res1)) {
23774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BufferedDC_UnMask" "', expected argument " "1"" of type '" "wxBufferedDC *""'");
23775 }
23776 arg1 = reinterpret_cast< wxBufferedDC * >(argp1);
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 (arg1)->UnMask();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_Py_Void();
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *BufferedDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23791 PyObject *obj;
23792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23793 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedDC, SWIG_NewClientData(obj));
23794 return SWIG_Py_Void();
23795 }
23796
23797 SWIGINTERN PyObject *BufferedDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23798 return SWIG_Python_InitShadowInstance(args);
23799 }
23800
23801 SWIGINTERN PyObject *_wrap_new_BufferedPaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23802 PyObject *resultobj = 0;
23803 wxWindow *arg1 = (wxWindow *) 0 ;
23804 wxBitmap const &arg2_defvalue = wxNullBitmap ;
23805 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
23806 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
23807 wxBufferedPaintDC *result = 0 ;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 void *argp2 = 0 ;
23811 int res2 = 0 ;
23812 int val3 ;
23813 int ecode3 = 0 ;
23814 PyObject * obj0 = 0 ;
23815 PyObject * obj1 = 0 ;
23816 PyObject * obj2 = 0 ;
23817 char * kwnames[] = {
23818 (char *) "window",(char *) "buffer",(char *) "style", NULL
23819 };
23820
23821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23823 if (!SWIG_IsOK(res1)) {
23824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BufferedPaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
23825 }
23826 arg1 = reinterpret_cast< wxWindow * >(argp1);
23827 if (obj1) {
23828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
23829 if (!SWIG_IsOK(res2)) {
23830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23831 }
23832 if (!argp2) {
23833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BufferedPaintDC" "', expected argument " "2"" of type '" "wxBitmap const &""'");
23834 }
23835 arg2 = reinterpret_cast< wxBitmap * >(argp2);
23836 }
23837 if (obj2) {
23838 ecode3 = SWIG_AsVal_int(obj2, &val3);
23839 if (!SWIG_IsOK(ecode3)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BufferedPaintDC" "', expected argument " "3"" of type '" "int""'");
23841 }
23842 arg3 = static_cast< int >(val3);
23843 }
23844 {
23845 if (!wxPyCheckForApp()) SWIG_fail;
23846 PyThreadState* __tstate = wxPyBeginAllowThreads();
23847 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
23848 wxPyEndAllowThreads(__tstate);
23849 if (PyErr_Occurred()) SWIG_fail;
23850 }
23851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBufferedPaintDC, SWIG_POINTER_NEW | 0 );
23852 return resultobj;
23853 fail:
23854 return NULL;
23855 }
23856
23857
23858 SWIGINTERN PyObject *BufferedPaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23859 PyObject *obj;
23860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23861 SWIG_TypeNewClientData(SWIGTYPE_p_wxBufferedPaintDC, SWIG_NewClientData(obj));
23862 return SWIG_Py_Void();
23863 }
23864
23865 SWIGINTERN PyObject *BufferedPaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 return SWIG_Python_InitShadowInstance(args);
23867 }
23868
23869 SWIGINTERN PyObject *_wrap_new_ScreenDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *resultobj = 0;
23871 wxScreenDC *result = 0 ;
23872
23873 if (!SWIG_Python_UnpackTuple(args,"new_ScreenDC",0,0,0)) SWIG_fail;
23874 {
23875 if (!wxPyCheckForApp()) SWIG_fail;
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = (wxScreenDC *)new wxScreenDC();
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScreenDC, SWIG_POINTER_NEW | 0 );
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23889 PyObject *resultobj = 0;
23890 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23891 wxWindow *arg2 = (wxWindow *) 0 ;
23892 bool result;
23893 void *argp1 = 0 ;
23894 int res1 = 0 ;
23895 void *argp2 = 0 ;
23896 int res2 = 0 ;
23897 PyObject * obj0 = 0 ;
23898 PyObject * obj1 = 0 ;
23899 char * kwnames[] = {
23900 (char *) "self",(char *) "window", NULL
23901 };
23902
23903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) SWIG_fail;
23904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23905 if (!SWIG_IsOK(res1)) {
23906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23907 }
23908 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23910 if (!SWIG_IsOK(res2)) {
23911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTopWin" "', expected argument " "2"" of type '" "wxWindow *""'");
23912 }
23913 arg2 = reinterpret_cast< wxWindow * >(argp2);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj = 0;
23931 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23932 wxRect *arg2 = (wxRect *) NULL ;
23933 bool result;
23934 void *argp1 = 0 ;
23935 int res1 = 0 ;
23936 void *argp2 = 0 ;
23937 int res2 = 0 ;
23938 PyObject * obj0 = 0 ;
23939 PyObject * obj1 = 0 ;
23940 char * kwnames[] = {
23941 (char *) "self",(char *) "rect", NULL
23942 };
23943
23944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) SWIG_fail;
23945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23946 if (!SWIG_IsOK(res1)) {
23947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23948 }
23949 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23950 if (obj1) {
23951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23952 if (!SWIG_IsOK(res2)) {
23953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenDC_StartDrawingOnTop" "', expected argument " "2"" of type '" "wxRect *""'");
23954 }
23955 arg2 = reinterpret_cast< wxRect * >(argp2);
23956 }
23957 {
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 result = (bool)(arg1)->StartDrawingOnTop(arg2);
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 {
23964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23965 }
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 SWIGINTERN PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23973 PyObject *resultobj = 0;
23974 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
23975 bool result;
23976 void *argp1 = 0 ;
23977 int res1 = 0 ;
23978 PyObject *swig_obj[1] ;
23979
23980 if (!args) SWIG_fail;
23981 swig_obj[0] = args;
23982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScreenDC, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenDC_EndDrawingOnTop" "', expected argument " "1"" of type '" "wxScreenDC *""'");
23985 }
23986 arg1 = reinterpret_cast< wxScreenDC * >(argp1);
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = (bool)(arg1)->EndDrawingOnTop();
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 {
23994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23995 }
23996 return resultobj;
23997 fail:
23998 return NULL;
23999 }
24000
24001
24002 SWIGINTERN PyObject *ScreenDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24003 PyObject *obj;
24004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24005 SWIG_TypeNewClientData(SWIGTYPE_p_wxScreenDC, SWIG_NewClientData(obj));
24006 return SWIG_Py_Void();
24007 }
24008
24009 SWIGINTERN PyObject *ScreenDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24010 return SWIG_Python_InitShadowInstance(args);
24011 }
24012
24013 SWIGINTERN PyObject *_wrap_new_ClientDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24014 PyObject *resultobj = 0;
24015 wxWindow *arg1 = (wxWindow *) 0 ;
24016 wxClientDC *result = 0 ;
24017 void *argp1 = 0 ;
24018 int res1 = 0 ;
24019 PyObject * obj0 = 0 ;
24020 char * kwnames[] = {
24021 (char *) "win", NULL
24022 };
24023
24024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) SWIG_fail;
24025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24026 if (!SWIG_IsOK(res1)) {
24027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientDC" "', expected argument " "1"" of type '" "wxWindow *""'");
24028 }
24029 arg1 = reinterpret_cast< wxWindow * >(argp1);
24030 {
24031 if (!wxPyCheckForApp()) SWIG_fail;
24032 PyThreadState* __tstate = wxPyBeginAllowThreads();
24033 result = (wxClientDC *)new wxClientDC(arg1);
24034 wxPyEndAllowThreads(__tstate);
24035 if (PyErr_Occurred()) SWIG_fail;
24036 }
24037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClientDC, SWIG_POINTER_NEW | 0 );
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *ClientDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24045 PyObject *obj;
24046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24047 SWIG_TypeNewClientData(SWIGTYPE_p_wxClientDC, SWIG_NewClientData(obj));
24048 return SWIG_Py_Void();
24049 }
24050
24051 SWIGINTERN PyObject *ClientDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24052 return SWIG_Python_InitShadowInstance(args);
24053 }
24054
24055 SWIGINTERN PyObject *_wrap_new_PaintDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj = 0;
24057 wxWindow *arg1 = (wxWindow *) 0 ;
24058 wxPaintDC *result = 0 ;
24059 void *argp1 = 0 ;
24060 int res1 = 0 ;
24061 PyObject * obj0 = 0 ;
24062 char * kwnames[] = {
24063 (char *) "win", NULL
24064 };
24065
24066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) SWIG_fail;
24067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24068 if (!SWIG_IsOK(res1)) {
24069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaintDC" "', expected argument " "1"" of type '" "wxWindow *""'");
24070 }
24071 arg1 = reinterpret_cast< wxWindow * >(argp1);
24072 {
24073 if (!wxPyCheckForApp()) SWIG_fail;
24074 PyThreadState* __tstate = wxPyBeginAllowThreads();
24075 result = (wxPaintDC *)new wxPaintDC(arg1);
24076 wxPyEndAllowThreads(__tstate);
24077 if (PyErr_Occurred()) SWIG_fail;
24078 }
24079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintDC, SWIG_POINTER_NEW | 0 );
24080 return resultobj;
24081 fail:
24082 return NULL;
24083 }
24084
24085
24086 SWIGINTERN PyObject *PaintDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 PyObject *obj;
24088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24089 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintDC, SWIG_NewClientData(obj));
24090 return SWIG_Py_Void();
24091 }
24092
24093 SWIGINTERN PyObject *PaintDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24094 return SWIG_Python_InitShadowInstance(args);
24095 }
24096
24097 SWIGINTERN PyObject *_wrap_new_WindowDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj = 0;
24099 wxWindow *arg1 = (wxWindow *) 0 ;
24100 wxWindowDC *result = 0 ;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 PyObject * obj0 = 0 ;
24104 char * kwnames[] = {
24105 (char *) "win", NULL
24106 };
24107
24108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) SWIG_fail;
24109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24110 if (!SWIG_IsOK(res1)) {
24111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDC" "', expected argument " "1"" of type '" "wxWindow *""'");
24112 }
24113 arg1 = reinterpret_cast< wxWindow * >(argp1);
24114 {
24115 if (!wxPyCheckForApp()) SWIG_fail;
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (wxWindowDC *)new wxWindowDC(arg1);
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDC, SWIG_POINTER_NEW | 0 );
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 SWIGINTERN PyObject *WindowDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24129 PyObject *obj;
24130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24131 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDC, SWIG_NewClientData(obj));
24132 return SWIG_Py_Void();
24133 }
24134
24135 SWIGINTERN PyObject *WindowDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24136 return SWIG_Python_InitShadowInstance(args);
24137 }
24138
24139 SWIGINTERN PyObject *_wrap_new_MirrorDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24140 PyObject *resultobj = 0;
24141 wxDC *arg1 = 0 ;
24142 bool arg2 ;
24143 wxMirrorDC *result = 0 ;
24144 void *argp1 = 0 ;
24145 int res1 = 0 ;
24146 bool val2 ;
24147 int ecode2 = 0 ;
24148 PyObject * obj0 = 0 ;
24149 PyObject * obj1 = 0 ;
24150 char * kwnames[] = {
24151 (char *) "dc",(char *) "mirror", NULL
24152 };
24153
24154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) SWIG_fail;
24155 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDC, 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
24158 }
24159 if (!argp1) {
24160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorDC" "', expected argument " "1"" of type '" "wxDC &""'");
24161 }
24162 arg1 = reinterpret_cast< wxDC * >(argp1);
24163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24164 if (!SWIG_IsOK(ecode2)) {
24165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MirrorDC" "', expected argument " "2"" of type '" "bool""'");
24166 }
24167 arg2 = static_cast< bool >(val2);
24168 {
24169 if (!wxPyCheckForApp()) SWIG_fail;
24170 PyThreadState* __tstate = wxPyBeginAllowThreads();
24171 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMirrorDC, SWIG_POINTER_NEW | 0 );
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 SWIGINTERN PyObject *MirrorDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24183 PyObject *obj;
24184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24185 SWIG_TypeNewClientData(SWIGTYPE_p_wxMirrorDC, SWIG_NewClientData(obj));
24186 return SWIG_Py_Void();
24187 }
24188
24189 SWIGINTERN PyObject *MirrorDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 return SWIG_Python_InitShadowInstance(args);
24191 }
24192
24193 SWIGINTERN PyObject *_wrap_new_PostScriptDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24194 PyObject *resultobj = 0;
24195 wxPrintData *arg1 = 0 ;
24196 wxPostScriptDC *result = 0 ;
24197 void *argp1 = 0 ;
24198 int res1 = 0 ;
24199 PyObject * obj0 = 0 ;
24200 char * kwnames[] = {
24201 (char *) "printData", NULL
24202 };
24203
24204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) SWIG_fail;
24205 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
24206 if (!SWIG_IsOK(res1)) {
24207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24208 }
24209 if (!argp1) {
24210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PostScriptDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24211 }
24212 arg1 = reinterpret_cast< wxPrintData * >(argp1);
24213 {
24214 if (!wxPyCheckForApp()) SWIG_fail;
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_NEW | 0 );
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24228 PyObject *resultobj = 0;
24229 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
24230 wxPrintData *result = 0 ;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 PyObject *swig_obj[1] ;
24234
24235 if (!args) SWIG_fail;
24236 swig_obj[0] = args;
24237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
24238 if (!SWIG_IsOK(res1)) {
24239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_GetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
24240 }
24241 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 {
24245 wxPrintData &_result_ref = (arg1)->GetPrintData();
24246 result = (wxPrintData *) &_result_ref;
24247 }
24248 wxPyEndAllowThreads(__tstate);
24249 if (PyErr_Occurred()) SWIG_fail;
24250 }
24251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );
24252 return resultobj;
24253 fail:
24254 return NULL;
24255 }
24256
24257
24258 SWIGINTERN PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24259 PyObject *resultobj = 0;
24260 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
24261 wxPrintData *arg2 = 0 ;
24262 void *argp1 = 0 ;
24263 int res1 = 0 ;
24264 void *argp2 = 0 ;
24265 int res2 = 0 ;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 char * kwnames[] = {
24269 (char *) "self",(char *) "data", NULL
24270 };
24271
24272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;
24273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPostScriptDC, 0 | 0 );
24274 if (!SWIG_IsOK(res1)) {
24275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "1"" of type '" "wxPostScriptDC *""'");
24276 }
24277 arg1 = reinterpret_cast< wxPostScriptDC * >(argp1);
24278 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);
24279 if (!SWIG_IsOK(res2)) {
24280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
24281 }
24282 if (!argp2) {
24283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostScriptDC_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");
24284 }
24285 arg2 = reinterpret_cast< wxPrintData * >(argp2);
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 (arg1)->SetPrintData((wxPrintData const &)*arg2);
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_Py_Void();
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *_wrap_PostScriptDC_SetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj = 0;
24301 int arg1 ;
24302 int val1 ;
24303 int ecode1 = 0 ;
24304 PyObject * obj0 = 0 ;
24305 char * kwnames[] = {
24306 (char *) "ppi", NULL
24307 };
24308
24309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) SWIG_fail;
24310 ecode1 = SWIG_AsVal_int(obj0, &val1);
24311 if (!SWIG_IsOK(ecode1)) {
24312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PostScriptDC_SetResolution" "', expected argument " "1"" of type '" "int""'");
24313 }
24314 arg1 = static_cast< int >(val1);
24315 {
24316 PyThreadState* __tstate = wxPyBeginAllowThreads();
24317 wxPostScriptDC::SetResolution(arg1);
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_Py_Void();
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 SWIGINTERN PyObject *_wrap_PostScriptDC_GetResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24329 PyObject *resultobj = 0;
24330 int result;
24331
24332 if (!SWIG_Python_UnpackTuple(args,"PostScriptDC_GetResolution",0,0,0)) SWIG_fail;
24333 {
24334 PyThreadState* __tstate = wxPyBeginAllowThreads();
24335 result = (int)wxPostScriptDC::GetResolution();
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 resultobj = SWIG_From_int(static_cast< int >(result));
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 SWIGINTERN PyObject *PostScriptDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24347 PyObject *obj;
24348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24349 SWIG_TypeNewClientData(SWIGTYPE_p_wxPostScriptDC, SWIG_NewClientData(obj));
24350 return SWIG_Py_Void();
24351 }
24352
24353 SWIGINTERN PyObject *PostScriptDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24354 return SWIG_Python_InitShadowInstance(args);
24355 }
24356
24357 SWIGINTERN PyObject *_wrap_new_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24358 PyObject *resultobj = 0;
24359 wxString const &arg1_defvalue = wxPyEmptyString ;
24360 wxString *arg1 = (wxString *) &arg1_defvalue ;
24361 wxMetaFile *result = 0 ;
24362 bool temp1 = false ;
24363 PyObject * obj0 = 0 ;
24364 char * kwnames[] = {
24365 (char *) "filename", NULL
24366 };
24367
24368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) SWIG_fail;
24369 if (obj0) {
24370 {
24371 arg1 = wxString_in_helper(obj0);
24372 if (arg1 == NULL) SWIG_fail;
24373 temp1 = true;
24374 }
24375 }
24376 {
24377 if (!wxPyCheckForApp()) SWIG_fail;
24378 PyThreadState* __tstate = wxPyBeginAllowThreads();
24379 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
24380 wxPyEndAllowThreads(__tstate);
24381 if (PyErr_Occurred()) SWIG_fail;
24382 }
24383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, SWIG_POINTER_NEW | 0 );
24384 {
24385 if (temp1)
24386 delete arg1;
24387 }
24388 return resultobj;
24389 fail:
24390 {
24391 if (temp1)
24392 delete arg1;
24393 }
24394 return NULL;
24395 }
24396
24397
24398 SWIGINTERN PyObject *_wrap_delete_MetaFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24399 PyObject *resultobj = 0;
24400 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24401 void *argp1 = 0 ;
24402 int res1 = 0 ;
24403 PyObject *swig_obj[1] ;
24404
24405 if (!args) SWIG_fail;
24406 swig_obj[0] = args;
24407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, SWIG_POINTER_DISOWN | 0 );
24408 if (!SWIG_IsOK(res1)) {
24409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaFile" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24410 }
24411 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24412 {
24413 PyThreadState* __tstate = wxPyBeginAllowThreads();
24414 delete arg1;
24415
24416 wxPyEndAllowThreads(__tstate);
24417 if (PyErr_Occurred()) SWIG_fail;
24418 }
24419 resultobj = SWIG_Py_Void();
24420 return resultobj;
24421 fail:
24422 return NULL;
24423 }
24424
24425
24426 SWIGINTERN PyObject *_wrap_MetaFile_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24427 PyObject *resultobj = 0;
24428 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24429 bool result;
24430 void *argp1 = 0 ;
24431 int res1 = 0 ;
24432 PyObject *swig_obj[1] ;
24433
24434 if (!args) SWIG_fail;
24435 swig_obj[0] = args;
24436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24437 if (!SWIG_IsOK(res1)) {
24438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_Ok" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24439 }
24440 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24441 {
24442 PyThreadState* __tstate = wxPyBeginAllowThreads();
24443 result = (bool)(arg1)->Ok();
24444 wxPyEndAllowThreads(__tstate);
24445 if (PyErr_Occurred()) SWIG_fail;
24446 }
24447 {
24448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24449 }
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 SWIGINTERN PyObject *_wrap_MetaFile_SetClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24457 PyObject *resultobj = 0;
24458 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24459 int arg2 = (int) 0 ;
24460 int arg3 = (int) 0 ;
24461 bool result;
24462 void *argp1 = 0 ;
24463 int res1 = 0 ;
24464 int val2 ;
24465 int ecode2 = 0 ;
24466 int val3 ;
24467 int ecode3 = 0 ;
24468 PyObject * obj0 = 0 ;
24469 PyObject * obj1 = 0 ;
24470 PyObject * obj2 = 0 ;
24471 char * kwnames[] = {
24472 (char *) "self",(char *) "width",(char *) "height", NULL
24473 };
24474
24475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24477 if (!SWIG_IsOK(res1)) {
24478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_SetClipboard" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24479 }
24480 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24481 if (obj1) {
24482 ecode2 = SWIG_AsVal_int(obj1, &val2);
24483 if (!SWIG_IsOK(ecode2)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MetaFile_SetClipboard" "', expected argument " "2"" of type '" "int""'");
24485 }
24486 arg2 = static_cast< int >(val2);
24487 }
24488 if (obj2) {
24489 ecode3 = SWIG_AsVal_int(obj2, &val3);
24490 if (!SWIG_IsOK(ecode3)) {
24491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MetaFile_SetClipboard" "', expected argument " "3"" of type '" "int""'");
24492 }
24493 arg3 = static_cast< int >(val3);
24494 }
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 result = (bool)(arg1)->SetClipboard(arg2,arg3);
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 {
24502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24503 }
24504 return resultobj;
24505 fail:
24506 return NULL;
24507 }
24508
24509
24510 SWIGINTERN PyObject *_wrap_MetaFile_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24511 PyObject *resultobj = 0;
24512 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24513 wxSize result;
24514 void *argp1 = 0 ;
24515 int res1 = 0 ;
24516 PyObject *swig_obj[1] ;
24517
24518 if (!args) SWIG_fail;
24519 swig_obj[0] = args;
24520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24521 if (!SWIG_IsOK(res1)) {
24522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetSize" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24523 }
24524 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24525 {
24526 PyThreadState* __tstate = wxPyBeginAllowThreads();
24527 result = (arg1)->GetSize();
24528 wxPyEndAllowThreads(__tstate);
24529 if (PyErr_Occurred()) SWIG_fail;
24530 }
24531 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *_wrap_MetaFile_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 PyObject *resultobj = 0;
24540 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24541 int result;
24542 void *argp1 = 0 ;
24543 int res1 = 0 ;
24544 PyObject *swig_obj[1] ;
24545
24546 if (!args) SWIG_fail;
24547 swig_obj[0] = args;
24548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24549 if (!SWIG_IsOK(res1)) {
24550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetWidth" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24551 }
24552 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 result = (int)(arg1)->GetWidth();
24556 wxPyEndAllowThreads(__tstate);
24557 if (PyErr_Occurred()) SWIG_fail;
24558 }
24559 resultobj = SWIG_From_int(static_cast< int >(result));
24560 return resultobj;
24561 fail:
24562 return NULL;
24563 }
24564
24565
24566 SWIGINTERN PyObject *_wrap_MetaFile_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24567 PyObject *resultobj = 0;
24568 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24569 int result;
24570 void *argp1 = 0 ;
24571 int res1 = 0 ;
24572 PyObject *swig_obj[1] ;
24573
24574 if (!args) SWIG_fail;
24575 swig_obj[0] = args;
24576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetHeight" "', expected argument " "1"" of type '" "wxMetaFile *""'");
24579 }
24580 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24581 {
24582 PyThreadState* __tstate = wxPyBeginAllowThreads();
24583 result = (int)(arg1)->GetHeight();
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 resultobj = SWIG_From_int(static_cast< int >(result));
24588 return resultobj;
24589 fail:
24590 return NULL;
24591 }
24592
24593
24594 SWIGINTERN PyObject *_wrap_MetaFile_GetFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24595 PyObject *resultobj = 0;
24596 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
24597 wxString *result = 0 ;
24598 void *argp1 = 0 ;
24599 int res1 = 0 ;
24600 PyObject *swig_obj[1] ;
24601
24602 if (!args) SWIG_fail;
24603 swig_obj[0] = args;
24604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFile, 0 | 0 );
24605 if (!SWIG_IsOK(res1)) {
24606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFile_GetFileName" "', expected argument " "1"" of type '" "wxMetaFile const *""'");
24607 }
24608 arg1 = reinterpret_cast< wxMetaFile * >(argp1);
24609 {
24610 PyThreadState* __tstate = wxPyBeginAllowThreads();
24611 {
24612 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
24613 result = (wxString *) &_result_ref;
24614 }
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 {
24619 #if wxUSE_UNICODE
24620 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
24621 #else
24622 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
24623 #endif
24624 }
24625 return resultobj;
24626 fail:
24627 return NULL;
24628 }
24629
24630
24631 SWIGINTERN PyObject *MetaFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24632 PyObject *obj;
24633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24634 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFile, SWIG_NewClientData(obj));
24635 return SWIG_Py_Void();
24636 }
24637
24638 SWIGINTERN PyObject *MetaFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24639 return SWIG_Python_InitShadowInstance(args);
24640 }
24641
24642 SWIGINTERN PyObject *_wrap_new_MetaFileDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24643 PyObject *resultobj = 0;
24644 wxString const &arg1_defvalue = wxPyEmptyString ;
24645 wxString *arg1 = (wxString *) &arg1_defvalue ;
24646 int arg2 = (int) 0 ;
24647 int arg3 = (int) 0 ;
24648 wxString const &arg4_defvalue = wxPyEmptyString ;
24649 wxString *arg4 = (wxString *) &arg4_defvalue ;
24650 wxMetaFileDC *result = 0 ;
24651 bool temp1 = false ;
24652 int val2 ;
24653 int ecode2 = 0 ;
24654 int val3 ;
24655 int ecode3 = 0 ;
24656 bool temp4 = false ;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 PyObject * obj2 = 0 ;
24660 PyObject * obj3 = 0 ;
24661 char * kwnames[] = {
24662 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
24663 };
24664
24665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24666 if (obj0) {
24667 {
24668 arg1 = wxString_in_helper(obj0);
24669 if (arg1 == NULL) SWIG_fail;
24670 temp1 = true;
24671 }
24672 }
24673 if (obj1) {
24674 ecode2 = SWIG_AsVal_int(obj1, &val2);
24675 if (!SWIG_IsOK(ecode2)) {
24676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MetaFileDC" "', expected argument " "2"" of type '" "int""'");
24677 }
24678 arg2 = static_cast< int >(val2);
24679 }
24680 if (obj2) {
24681 ecode3 = SWIG_AsVal_int(obj2, &val3);
24682 if (!SWIG_IsOK(ecode3)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MetaFileDC" "', expected argument " "3"" of type '" "int""'");
24684 }
24685 arg3 = static_cast< int >(val3);
24686 }
24687 if (obj3) {
24688 {
24689 arg4 = wxString_in_helper(obj3);
24690 if (arg4 == NULL) SWIG_fail;
24691 temp4 = true;
24692 }
24693 }
24694 {
24695 if (!wxPyCheckForApp()) SWIG_fail;
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_NEW | 0 );
24702 {
24703 if (temp1)
24704 delete arg1;
24705 }
24706 {
24707 if (temp4)
24708 delete arg4;
24709 }
24710 return resultobj;
24711 fail:
24712 {
24713 if (temp1)
24714 delete arg1;
24715 }
24716 {
24717 if (temp4)
24718 delete arg4;
24719 }
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_MetaFileDC_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
24727 wxMetaFile *result = 0 ;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetaFileDC, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaFileDC_Close" "', expected argument " "1"" of type '" "wxMetaFileDC *""'");
24737 }
24738 arg1 = reinterpret_cast< wxMetaFileDC * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (wxMetaFile *)(arg1)->Close();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetaFile, 0 | 0 );
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *MetaFileDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *obj;
24754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24755 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetaFileDC, SWIG_NewClientData(obj));
24756 return SWIG_Py_Void();
24757 }
24758
24759 SWIGINTERN PyObject *MetaFileDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24760 return SWIG_Python_InitShadowInstance(args);
24761 }
24762
24763 SWIGINTERN PyObject *_wrap_new_PrinterDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj = 0;
24765 wxPrintData *arg1 = 0 ;
24766 wxPrinterDC *result = 0 ;
24767 void *argp1 = 0 ;
24768 int res1 = 0 ;
24769 PyObject * obj0 = 0 ;
24770 char * kwnames[] = {
24771 (char *) "printData", NULL
24772 };
24773
24774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) SWIG_fail;
24775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxPrintData, 0 | 0);
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24778 }
24779 if (!argp1) {
24780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrinterDC" "', expected argument " "1"" of type '" "wxPrintData const &""'");
24781 }
24782 arg1 = reinterpret_cast< wxPrintData * >(argp1);
24783 {
24784 if (!wxPyCheckForApp()) SWIG_fail;
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrinterDC, SWIG_POINTER_NEW | 0 );
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *PrinterDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24798 PyObject *obj;
24799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24800 SWIG_TypeNewClientData(SWIGTYPE_p_wxPrinterDC, SWIG_NewClientData(obj));
24801 return SWIG_Py_Void();
24802 }
24803
24804 SWIGINTERN PyObject *PrinterDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24805 return SWIG_Python_InitShadowInstance(args);
24806 }
24807
24808 SWIGINTERN PyObject *_wrap_new_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24809 PyObject *resultobj = 0;
24810 int arg1 ;
24811 int arg2 ;
24812 int arg3 = (int) true ;
24813 int arg4 = (int) 1 ;
24814 wxImageList *result = 0 ;
24815 int val1 ;
24816 int ecode1 = 0 ;
24817 int val2 ;
24818 int ecode2 = 0 ;
24819 int val3 ;
24820 int ecode3 = 0 ;
24821 int val4 ;
24822 int ecode4 = 0 ;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 PyObject * obj2 = 0 ;
24826 PyObject * obj3 = 0 ;
24827 char * kwnames[] = {
24828 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
24829 };
24830
24831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24832 ecode1 = SWIG_AsVal_int(obj0, &val1);
24833 if (!SWIG_IsOK(ecode1)) {
24834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageList" "', expected argument " "1"" of type '" "int""'");
24835 }
24836 arg1 = static_cast< int >(val1);
24837 ecode2 = SWIG_AsVal_int(obj1, &val2);
24838 if (!SWIG_IsOK(ecode2)) {
24839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageList" "', expected argument " "2"" of type '" "int""'");
24840 }
24841 arg2 = static_cast< int >(val2);
24842 if (obj2) {
24843 ecode3 = SWIG_AsVal_int(obj2, &val3);
24844 if (!SWIG_IsOK(ecode3)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageList" "', expected argument " "3"" of type '" "int""'");
24846 }
24847 arg3 = static_cast< int >(val3);
24848 }
24849 if (obj3) {
24850 ecode4 = SWIG_AsVal_int(obj3, &val4);
24851 if (!SWIG_IsOK(ecode4)) {
24852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImageList" "', expected argument " "4"" of type '" "int""'");
24853 }
24854 arg4 = static_cast< int >(val4);
24855 }
24856 {
24857 if (!wxPyCheckForApp()) SWIG_fail;
24858 PyThreadState* __tstate = wxPyBeginAllowThreads();
24859 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 {
24864 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
24865 }
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_delete_ImageList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxImageList *arg1 = (wxImageList *) 0 ;
24875 void *argp1 = 0 ;
24876 int res1 = 0 ;
24877 PyObject *swig_obj[1] ;
24878
24879 if (!args) SWIG_fail;
24880 swig_obj[0] = args;
24881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, SWIG_POINTER_DISOWN | 0 );
24882 if (!SWIG_IsOK(res1)) {
24883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImageList" "', expected argument " "1"" of type '" "wxImageList *""'");
24884 }
24885 arg1 = reinterpret_cast< wxImageList * >(argp1);
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 delete arg1;
24889
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 resultobj = SWIG_Py_Void();
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_ImageList_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24901 PyObject *resultobj = 0;
24902 wxImageList *arg1 = (wxImageList *) 0 ;
24903 wxBitmap *arg2 = 0 ;
24904 wxBitmap const &arg3_defvalue = wxNullBitmap ;
24905 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
24906 int result;
24907 void *argp1 = 0 ;
24908 int res1 = 0 ;
24909 void *argp2 = 0 ;
24910 int res2 = 0 ;
24911 void *argp3 = 0 ;
24912 int res3 = 0 ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 PyObject * obj2 = 0 ;
24916 char * kwnames[] = {
24917 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
24918 };
24919
24920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24922 if (!SWIG_IsOK(res1)) {
24923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Add" "', expected argument " "1"" of type '" "wxImageList *""'");
24924 }
24925 arg1 = reinterpret_cast< wxImageList * >(argp1);
24926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
24927 if (!SWIG_IsOK(res2)) {
24928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24929 }
24930 if (!argp2) {
24931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24932 }
24933 arg2 = reinterpret_cast< wxBitmap * >(argp2);
24934 if (obj2) {
24935 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
24936 if (!SWIG_IsOK(res3)) {
24937 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24938 }
24939 if (!argp3) {
24940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Add" "', expected argument " "3"" of type '" "wxBitmap const &""'");
24941 }
24942 arg3 = reinterpret_cast< wxBitmap * >(argp3);
24943 }
24944 {
24945 PyThreadState* __tstate = wxPyBeginAllowThreads();
24946 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 resultobj = SWIG_From_int(static_cast< int >(result));
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 SWIGINTERN PyObject *_wrap_ImageList_AddWithColourMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj = 0;
24959 wxImageList *arg1 = (wxImageList *) 0 ;
24960 wxBitmap *arg2 = 0 ;
24961 wxColour *arg3 = 0 ;
24962 int result;
24963 void *argp1 = 0 ;
24964 int res1 = 0 ;
24965 void *argp2 = 0 ;
24966 int res2 = 0 ;
24967 wxColour temp3 ;
24968 PyObject * obj0 = 0 ;
24969 PyObject * obj1 = 0 ;
24970 PyObject * obj2 = 0 ;
24971 char * kwnames[] = {
24972 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
24973 };
24974
24975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
24977 if (!SWIG_IsOK(res1)) {
24978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddWithColourMask" "', expected argument " "1"" of type '" "wxImageList *""'");
24979 }
24980 arg1 = reinterpret_cast< wxImageList * >(argp1);
24981 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
24982 if (!SWIG_IsOK(res2)) {
24983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24984 }
24985 if (!argp2) {
24986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddWithColourMask" "', expected argument " "2"" of type '" "wxBitmap const &""'");
24987 }
24988 arg2 = reinterpret_cast< wxBitmap * >(argp2);
24989 {
24990 arg3 = &temp3;
24991 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
24992 }
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_From_int(static_cast< int >(result));
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_ImageList_AddIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj = 0;
25008 wxImageList *arg1 = (wxImageList *) 0 ;
25009 wxIcon *arg2 = 0 ;
25010 int result;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 void *argp2 = 0 ;
25014 int res2 = 0 ;
25015 PyObject * obj0 = 0 ;
25016 PyObject * obj1 = 0 ;
25017 char * kwnames[] = {
25018 (char *) "self",(char *) "icon", NULL
25019 };
25020
25021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) SWIG_fail;
25022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_AddIcon" "', expected argument " "1"" of type '" "wxImageList *""'");
25025 }
25026 arg1 = reinterpret_cast< wxImageList * >(argp1);
25027 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
25028 if (!SWIG_IsOK(res2)) {
25029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
25030 }
25031 if (!argp2) {
25032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_AddIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
25033 }
25034 arg2 = reinterpret_cast< wxIcon * >(argp2);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (int)(arg1)->Add((wxIcon const &)*arg2);
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_From_int(static_cast< int >(result));
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_ImageList_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj = 0;
25050 wxImageList *arg1 = (wxImageList *) 0 ;
25051 int arg2 ;
25052 SwigValueWrapper<wxBitmap > result;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 int val2 ;
25056 int ecode2 = 0 ;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 char * kwnames[] = {
25060 (char *) "self",(char *) "index", NULL
25061 };
25062
25063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
25064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetBitmap" "', expected argument " "1"" of type '" "wxImageList const *""'");
25067 }
25068 arg1 = reinterpret_cast< wxImageList * >(argp1);
25069 ecode2 = SWIG_AsVal_int(obj1, &val2);
25070 if (!SWIG_IsOK(ecode2)) {
25071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetBitmap" "', expected argument " "2"" of type '" "int""'");
25072 }
25073 arg2 = static_cast< int >(val2);
25074 {
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
25077 wxPyEndAllowThreads(__tstate);
25078 if (PyErr_Occurred()) SWIG_fail;
25079 }
25080 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 SWIGINTERN PyObject *_wrap_ImageList_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25088 PyObject *resultobj = 0;
25089 wxImageList *arg1 = (wxImageList *) 0 ;
25090 int arg2 ;
25091 wxIcon result;
25092 void *argp1 = 0 ;
25093 int res1 = 0 ;
25094 int val2 ;
25095 int ecode2 = 0 ;
25096 PyObject * obj0 = 0 ;
25097 PyObject * obj1 = 0 ;
25098 char * kwnames[] = {
25099 (char *) "self",(char *) "index", NULL
25100 };
25101
25102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
25103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetIcon" "', expected argument " "1"" of type '" "wxImageList const *""'");
25106 }
25107 arg1 = reinterpret_cast< wxImageList * >(argp1);
25108 ecode2 = SWIG_AsVal_int(obj1, &val2);
25109 if (!SWIG_IsOK(ecode2)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetIcon" "', expected argument " "2"" of type '" "int""'");
25111 }
25112 arg2 = static_cast< int >(val2);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = ((wxImageList const *)arg1)->GetIcon(arg2);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_ImageList_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxImageList *arg1 = (wxImageList *) 0 ;
25129 int arg2 ;
25130 wxBitmap *arg3 = 0 ;
25131 wxBitmap const &arg4_defvalue = wxNullBitmap ;
25132 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
25133 bool result;
25134 void *argp1 = 0 ;
25135 int res1 = 0 ;
25136 int val2 ;
25137 int ecode2 = 0 ;
25138 void *argp3 = 0 ;
25139 int res3 = 0 ;
25140 void *argp4 = 0 ;
25141 int res4 = 0 ;
25142 PyObject * obj0 = 0 ;
25143 PyObject * obj1 = 0 ;
25144 PyObject * obj2 = 0 ;
25145 PyObject * obj3 = 0 ;
25146 char * kwnames[] = {
25147 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
25148 };
25149
25150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25152 if (!SWIG_IsOK(res1)) {
25153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Replace" "', expected argument " "1"" of type '" "wxImageList *""'");
25154 }
25155 arg1 = reinterpret_cast< wxImageList * >(argp1);
25156 ecode2 = SWIG_AsVal_int(obj1, &val2);
25157 if (!SWIG_IsOK(ecode2)) {
25158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Replace" "', expected argument " "2"" of type '" "int""'");
25159 }
25160 arg2 = static_cast< int >(val2);
25161 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
25162 if (!SWIG_IsOK(res3)) {
25163 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
25164 }
25165 if (!argp3) {
25166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "3"" of type '" "wxBitmap const &""'");
25167 }
25168 arg3 = reinterpret_cast< wxBitmap * >(argp3);
25169 if (obj3) {
25170 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 | 0);
25171 if (!SWIG_IsOK(res4)) {
25172 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
25173 }
25174 if (!argp4) {
25175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Replace" "', expected argument " "4"" of type '" "wxBitmap const &""'");
25176 }
25177 arg4 = reinterpret_cast< wxBitmap * >(argp4);
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 {
25186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25187 }
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 SWIGINTERN PyObject *_wrap_ImageList_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25195 PyObject *resultobj = 0;
25196 wxImageList *arg1 = (wxImageList *) 0 ;
25197 int arg2 ;
25198 wxDC *arg3 = 0 ;
25199 int arg4 ;
25200 int arg5 ;
25201 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
25202 bool arg7 = (bool) (bool)false ;
25203 bool result;
25204 void *argp1 = 0 ;
25205 int res1 = 0 ;
25206 int val2 ;
25207 int ecode2 = 0 ;
25208 void *argp3 = 0 ;
25209 int res3 = 0 ;
25210 int val4 ;
25211 int ecode4 = 0 ;
25212 int val5 ;
25213 int ecode5 = 0 ;
25214 int val6 ;
25215 int ecode6 = 0 ;
25216 bool val7 ;
25217 int ecode7 = 0 ;
25218 PyObject * obj0 = 0 ;
25219 PyObject * obj1 = 0 ;
25220 PyObject * obj2 = 0 ;
25221 PyObject * obj3 = 0 ;
25222 PyObject * obj4 = 0 ;
25223 PyObject * obj5 = 0 ;
25224 PyObject * obj6 = 0 ;
25225 char * kwnames[] = {
25226 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
25227 };
25228
25229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Draw" "', expected argument " "1"" of type '" "wxImageList *""'");
25233 }
25234 arg1 = reinterpret_cast< wxImageList * >(argp1);
25235 ecode2 = SWIG_AsVal_int(obj1, &val2);
25236 if (!SWIG_IsOK(ecode2)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Draw" "', expected argument " "2"" of type '" "int""'");
25238 }
25239 arg2 = static_cast< int >(val2);
25240 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
25241 if (!SWIG_IsOK(res3)) {
25242 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
25243 }
25244 if (!argp3) {
25245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImageList_Draw" "', expected argument " "3"" of type '" "wxDC &""'");
25246 }
25247 arg3 = reinterpret_cast< wxDC * >(argp3);
25248 ecode4 = SWIG_AsVal_int(obj3, &val4);
25249 if (!SWIG_IsOK(ecode4)) {
25250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageList_Draw" "', expected argument " "4"" of type '" "int""'");
25251 }
25252 arg4 = static_cast< int >(val4);
25253 ecode5 = SWIG_AsVal_int(obj4, &val5);
25254 if (!SWIG_IsOK(ecode5)) {
25255 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageList_Draw" "', expected argument " "5"" of type '" "int""'");
25256 }
25257 arg5 = static_cast< int >(val5);
25258 if (obj5) {
25259 ecode6 = SWIG_AsVal_int(obj5, &val6);
25260 if (!SWIG_IsOK(ecode6)) {
25261 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageList_Draw" "', expected argument " "6"" of type '" "int""'");
25262 }
25263 arg6 = static_cast< int >(val6);
25264 }
25265 if (obj6) {
25266 ecode7 = SWIG_AsVal_bool(obj6, &val7);
25267 if (!SWIG_IsOK(ecode7)) {
25268 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageList_Draw" "', expected argument " "7"" of type '" "bool""'");
25269 }
25270 arg7 = static_cast< bool >(val7);
25271 }
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 {
25279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25280 }
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 SWIGINTERN PyObject *_wrap_ImageList_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25288 PyObject *resultobj = 0;
25289 wxImageList *arg1 = (wxImageList *) 0 ;
25290 int result;
25291 void *argp1 = 0 ;
25292 int res1 = 0 ;
25293 PyObject *swig_obj[1] ;
25294
25295 if (!args) SWIG_fail;
25296 swig_obj[0] = args;
25297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25298 if (!SWIG_IsOK(res1)) {
25299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetImageCount" "', expected argument " "1"" of type '" "wxImageList *""'");
25300 }
25301 arg1 = reinterpret_cast< wxImageList * >(argp1);
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = (int)(arg1)->GetImageCount();
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_From_int(static_cast< int >(result));
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 SWIGINTERN PyObject *_wrap_ImageList_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj = 0;
25317 wxImageList *arg1 = (wxImageList *) 0 ;
25318 int arg2 ;
25319 bool result;
25320 void *argp1 = 0 ;
25321 int res1 = 0 ;
25322 int val2 ;
25323 int ecode2 = 0 ;
25324 PyObject * obj0 = 0 ;
25325 PyObject * obj1 = 0 ;
25326 char * kwnames[] = {
25327 (char *) "self",(char *) "index", NULL
25328 };
25329
25330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
25331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25332 if (!SWIG_IsOK(res1)) {
25333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_Remove" "', expected argument " "1"" of type '" "wxImageList *""'");
25334 }
25335 arg1 = reinterpret_cast< wxImageList * >(argp1);
25336 ecode2 = SWIG_AsVal_int(obj1, &val2);
25337 if (!SWIG_IsOK(ecode2)) {
25338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_Remove" "', expected argument " "2"" of type '" "int""'");
25339 }
25340 arg2 = static_cast< int >(val2);
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (bool)(arg1)->Remove(arg2);
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 {
25348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25349 }
25350 return resultobj;
25351 fail:
25352 return NULL;
25353 }
25354
25355
25356 SWIGINTERN PyObject *_wrap_ImageList_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25357 PyObject *resultobj = 0;
25358 wxImageList *arg1 = (wxImageList *) 0 ;
25359 bool result;
25360 void *argp1 = 0 ;
25361 int res1 = 0 ;
25362 PyObject *swig_obj[1] ;
25363
25364 if (!args) SWIG_fail;
25365 swig_obj[0] = args;
25366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25367 if (!SWIG_IsOK(res1)) {
25368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_RemoveAll" "', expected argument " "1"" of type '" "wxImageList *""'");
25369 }
25370 arg1 = reinterpret_cast< wxImageList * >(argp1);
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (bool)(arg1)->RemoveAll();
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 {
25378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25379 }
25380 return resultobj;
25381 fail:
25382 return NULL;
25383 }
25384
25385
25386 SWIGINTERN PyObject *_wrap_ImageList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj = 0;
25388 wxImageList *arg1 = (wxImageList *) 0 ;
25389 int arg2 ;
25390 int *arg3 = 0 ;
25391 int *arg4 = 0 ;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 int val2 ;
25395 int ecode2 = 0 ;
25396 int temp3 ;
25397 int res3 = SWIG_TMPOBJ ;
25398 int temp4 ;
25399 int res4 = SWIG_TMPOBJ ;
25400 PyObject * obj0 = 0 ;
25401 PyObject * obj1 = 0 ;
25402 char * kwnames[] = {
25403 (char *) "self",(char *) "index", NULL
25404 };
25405
25406 arg3 = &temp3;
25407 arg4 = &temp4;
25408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
25409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageList, 0 | 0 );
25410 if (!SWIG_IsOK(res1)) {
25411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageList_GetSize" "', expected argument " "1"" of type '" "wxImageList *""'");
25412 }
25413 arg1 = reinterpret_cast< wxImageList * >(argp1);
25414 ecode2 = SWIG_AsVal_int(obj1, &val2);
25415 if (!SWIG_IsOK(ecode2)) {
25416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageList_GetSize" "', expected argument " "2"" of type '" "int""'");
25417 }
25418 arg2 = static_cast< int >(val2);
25419 {
25420 PyThreadState* __tstate = wxPyBeginAllowThreads();
25421 (arg1)->GetSize(arg2,*arg3,*arg4);
25422 wxPyEndAllowThreads(__tstate);
25423 if (PyErr_Occurred()) SWIG_fail;
25424 }
25425 resultobj = SWIG_Py_Void();
25426 if (SWIG_IsTmpObj(res3)) {
25427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
25428 } else {
25429 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
25431 }
25432 if (SWIG_IsTmpObj(res4)) {
25433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
25434 } else {
25435 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
25437 }
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *ImageList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *obj;
25446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25447 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageList, SWIG_NewClientData(obj));
25448 return SWIG_Py_Void();
25449 }
25450
25451 SWIGINTERN PyObject *ImageList_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25452 return SWIG_Python_InitShadowInstance(args);
25453 }
25454
25455 SWIGINTERN PyObject *_wrap_new_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *resultobj = 0;
25457 wxStockGDI *result = 0 ;
25458
25459 if (!SWIG_Python_UnpackTuple(args,"new_StockGDI",0,0,0)) SWIG_fail;
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (wxStockGDI *)new wxStockGDI();
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, SWIG_POINTER_NEW | 0 );
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 SWIGINTERN PyObject *_wrap_delete_StockGDI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25474 PyObject *resultobj = 0;
25475 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
25476 void *argp1 = 0 ;
25477 int res1 = 0 ;
25478 PyObject *swig_obj[1] ;
25479
25480 if (!args) SWIG_fail;
25481 swig_obj[0] = args;
25482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStockGDI, SWIG_POINTER_DISOWN | 0 );
25483 if (!SWIG_IsOK(res1)) {
25484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StockGDI" "', expected argument " "1"" of type '" "wxStockGDI *""'");
25485 }
25486 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
25487 {
25488 PyThreadState* __tstate = wxPyBeginAllowThreads();
25489 delete arg1;
25490
25491 wxPyEndAllowThreads(__tstate);
25492 if (PyErr_Occurred()) SWIG_fail;
25493 }
25494 resultobj = SWIG_Py_Void();
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *_wrap_StockGDI_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25502 PyObject *resultobj = 0;
25503
25504 if (!SWIG_Python_UnpackTuple(args,"StockGDI_DeleteAll",0,0,0)) SWIG_fail;
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 wxStockGDI::DeleteAll();
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 resultobj = SWIG_Py_Void();
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 SWIGINTERN PyObject *_wrap_StockGDI_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 PyObject *resultobj = 0;
25520 wxStockGDI *result = 0 ;
25521
25522 if (!SWIG_Python_UnpackTuple(args,"StockGDI_instance",0,0,0)) SWIG_fail;
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 {
25526 wxStockGDI &_result_ref = wxStockGDI::instance();
25527 result = (wxStockGDI *) &_result_ref;
25528 }
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStockGDI, 0 | 0 );
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_StockGDI_GetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = 0;
25541 wxStockGDI::Item arg1 ;
25542 wxBrush *result = 0 ;
25543 int val1 ;
25544 int ecode1 = 0 ;
25545 PyObject * obj0 = 0 ;
25546 char * kwnames[] = {
25547 (char *) "item", NULL
25548 };
25549
25550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetBrush",kwnames,&obj0)) SWIG_fail;
25551 ecode1 = SWIG_AsVal_int(obj0, &val1);
25552 if (!SWIG_IsOK(ecode1)) {
25553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetBrush" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
25554 }
25555 arg1 = static_cast< wxStockGDI::Item >(val1);
25556 {
25557 PyThreadState* __tstate = wxPyBeginAllowThreads();
25558 result = (wxBrush *)wxStockGDI::GetBrush(arg1);
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 SWIGINTERN PyObject *_wrap_StockGDI_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj = 0;
25571 wxStockGDI::Item arg1 ;
25572 wxColour *result = 0 ;
25573 int val1 ;
25574 int ecode1 = 0 ;
25575 PyObject * obj0 = 0 ;
25576 char * kwnames[] = {
25577 (char *) "item", NULL
25578 };
25579
25580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetColour",kwnames,&obj0)) SWIG_fail;
25581 ecode1 = SWIG_AsVal_int(obj0, &val1);
25582 if (!SWIG_IsOK(ecode1)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetColour" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
25584 }
25585 arg1 = static_cast< wxStockGDI::Item >(val1);
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = (wxColour *)wxStockGDI::GetColour(arg1);
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
25593 return resultobj;
25594 fail:
25595 return NULL;
25596 }
25597
25598
25599 SWIGINTERN PyObject *_wrap_StockGDI_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25600 PyObject *resultobj = 0;
25601 wxStockGDI::Item arg1 ;
25602 wxCursor *result = 0 ;
25603 int val1 ;
25604 int ecode1 = 0 ;
25605 PyObject * obj0 = 0 ;
25606 char * kwnames[] = {
25607 (char *) "item", NULL
25608 };
25609
25610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetCursor",kwnames,&obj0)) SWIG_fail;
25611 ecode1 = SWIG_AsVal_int(obj0, &val1);
25612 if (!SWIG_IsOK(ecode1)) {
25613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetCursor" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
25614 }
25615 arg1 = static_cast< wxStockGDI::Item >(val1);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (wxCursor *)wxStockGDI::GetCursor(arg1);
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCursor, 0 | 0 );
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 SWIGINTERN PyObject *_wrap_StockGDI_GetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25630 PyObject *resultobj = 0;
25631 wxStockGDI::Item arg1 ;
25632 wxPen *result = 0 ;
25633 int val1 ;
25634 int ecode1 = 0 ;
25635 PyObject * obj0 = 0 ;
25636 char * kwnames[] = {
25637 (char *) "item", NULL
25638 };
25639
25640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StockGDI_GetPen",kwnames,&obj0)) SWIG_fail;
25641 ecode1 = SWIG_AsVal_int(obj0, &val1);
25642 if (!SWIG_IsOK(ecode1)) {
25643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "StockGDI_GetPen" "', expected argument " "1"" of type '" "wxStockGDI::Item""'");
25644 }
25645 arg1 = static_cast< wxStockGDI::Item >(val1);
25646 {
25647 PyThreadState* __tstate = wxPyBeginAllowThreads();
25648 result = (wxPen *)wxStockGDI::GetPen(arg1);
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_StockGDI_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj = 0;
25661 wxStockGDI *arg1 = (wxStockGDI *) 0 ;
25662 wxStockGDI::Item arg2 ;
25663 wxFont *result = 0 ;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 int val2 ;
25667 int ecode2 = 0 ;
25668 PyObject * obj0 = 0 ;
25669 PyObject * obj1 = 0 ;
25670 char * kwnames[] = {
25671 (char *) "self",(char *) "item", NULL
25672 };
25673
25674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StockGDI_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStockGDI, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StockGDI_GetFont" "', expected argument " "1"" of type '" "wxStockGDI *""'");
25678 }
25679 arg1 = reinterpret_cast< wxStockGDI * >(argp1);
25680 ecode2 = SWIG_AsVal_int(obj1, &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StockGDI_GetFont" "', expected argument " "2"" of type '" "wxStockGDI::Item""'");
25683 }
25684 arg2 = static_cast< wxStockGDI::Item >(val2);
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 result = (wxFont *)(arg1)->GetFont(arg2);
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *StockGDI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25699 PyObject *obj;
25700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25701 SWIG_TypeNewClientData(SWIGTYPE_p_wxStockGDI, SWIG_NewClientData(obj));
25702 return SWIG_Py_Void();
25703 }
25704
25705 SWIGINTERN PyObject *StockGDI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 return SWIG_Python_InitShadowInstance(args);
25707 }
25708
25709 SWIGINTERN int NullBitmap_set(PyObject *) {
25710 SWIG_Error(SWIG_AttributeError,"Variable NullBitmap is read-only.");
25711 return 1;
25712 }
25713
25714
25715 SWIGINTERN PyObject *NullBitmap_get(void) {
25716 PyObject *pyobj = 0;
25717
25718 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0 );
25719 return pyobj;
25720 }
25721
25722
25723 SWIGINTERN int NullIcon_set(PyObject *) {
25724 SWIG_Error(SWIG_AttributeError,"Variable NullIcon is read-only.");
25725 return 1;
25726 }
25727
25728
25729 SWIGINTERN PyObject *NullIcon_get(void) {
25730 PyObject *pyobj = 0;
25731
25732 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullIcon), SWIGTYPE_p_wxIcon, 0 );
25733 return pyobj;
25734 }
25735
25736
25737 SWIGINTERN int NullCursor_set(PyObject *) {
25738 SWIG_Error(SWIG_AttributeError,"Variable NullCursor is read-only.");
25739 return 1;
25740 }
25741
25742
25743 SWIGINTERN PyObject *NullCursor_get(void) {
25744 PyObject *pyobj = 0;
25745
25746 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullCursor), SWIGTYPE_p_wxCursor, 0 );
25747 return pyobj;
25748 }
25749
25750
25751 SWIGINTERN int NullPen_set(PyObject *) {
25752 SWIG_Error(SWIG_AttributeError,"Variable NullPen is read-only.");
25753 return 1;
25754 }
25755
25756
25757 SWIGINTERN PyObject *NullPen_get(void) {
25758 PyObject *pyobj = 0;
25759
25760 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPen), SWIGTYPE_p_wxPen, 0 );
25761 return pyobj;
25762 }
25763
25764
25765 SWIGINTERN int NullBrush_set(PyObject *) {
25766 SWIG_Error(SWIG_AttributeError,"Variable NullBrush is read-only.");
25767 return 1;
25768 }
25769
25770
25771 SWIGINTERN PyObject *NullBrush_get(void) {
25772 PyObject *pyobj = 0;
25773
25774 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullBrush), SWIGTYPE_p_wxBrush, 0 );
25775 return pyobj;
25776 }
25777
25778
25779 SWIGINTERN int NullPalette_set(PyObject *) {
25780 SWIG_Error(SWIG_AttributeError,"Variable NullPalette is read-only.");
25781 return 1;
25782 }
25783
25784
25785 SWIGINTERN PyObject *NullPalette_get(void) {
25786 PyObject *pyobj = 0;
25787
25788 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullPalette), SWIGTYPE_p_wxPalette, 0 );
25789 return pyobj;
25790 }
25791
25792
25793 SWIGINTERN int NullFont_set(PyObject *) {
25794 SWIG_Error(SWIG_AttributeError,"Variable NullFont is read-only.");
25795 return 1;
25796 }
25797
25798
25799 SWIGINTERN PyObject *NullFont_get(void) {
25800 PyObject *pyobj = 0;
25801
25802 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullFont), SWIGTYPE_p_wxFont, 0 );
25803 return pyobj;
25804 }
25805
25806
25807 SWIGINTERN int NullColour_set(PyObject *) {
25808 SWIG_Error(SWIG_AttributeError,"Variable NullColour is read-only.");
25809 return 1;
25810 }
25811
25812
25813 SWIGINTERN PyObject *NullColour_get(void) {
25814 PyObject *pyobj = 0;
25815
25816 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullColour), SWIGTYPE_p_wxColour, 0 );
25817 return pyobj;
25818 }
25819
25820
25821 SWIGINTERN PyObject *_wrap_new_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25822 PyObject *resultobj = 0;
25823 wxGDIObjListBase *result = 0 ;
25824
25825 if (!SWIG_Python_UnpackTuple(args,"new_GDIObjListBase",0,0,0)) SWIG_fail;
25826 {
25827 PyThreadState* __tstate = wxPyBeginAllowThreads();
25828 result = (wxGDIObjListBase *)new wxGDIObjListBase();
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_NEW | 0 );
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *_wrap_delete_GDIObjListBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25840 PyObject *resultobj = 0;
25841 wxGDIObjListBase *arg1 = (wxGDIObjListBase *) 0 ;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 PyObject *swig_obj[1] ;
25845
25846 if (!args) SWIG_fail;
25847 swig_obj[0] = args;
25848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGDIObjListBase, SWIG_POINTER_DISOWN | 0 );
25849 if (!SWIG_IsOK(res1)) {
25850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GDIObjListBase" "', expected argument " "1"" of type '" "wxGDIObjListBase *""'");
25851 }
25852 arg1 = reinterpret_cast< wxGDIObjListBase * >(argp1);
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 delete arg1;
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 resultobj = SWIG_Py_Void();
25861 return resultobj;
25862 fail:
25863 return NULL;
25864 }
25865
25866
25867 SWIGINTERN PyObject *GDIObjListBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25868 PyObject *obj;
25869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25870 SWIG_TypeNewClientData(SWIGTYPE_p_wxGDIObjListBase, SWIG_NewClientData(obj));
25871 return SWIG_Py_Void();
25872 }
25873
25874 SWIGINTERN PyObject *GDIObjListBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25875 return SWIG_Python_InitShadowInstance(args);
25876 }
25877
25878 SWIGINTERN PyObject *_wrap_PenList_FindOrCreatePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25879 PyObject *resultobj = 0;
25880 wxPenList *arg1 = (wxPenList *) 0 ;
25881 wxColour *arg2 = 0 ;
25882 int arg3 ;
25883 int arg4 ;
25884 wxPen *result = 0 ;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 wxColour temp2 ;
25888 int val3 ;
25889 int ecode3 = 0 ;
25890 int val4 ;
25891 int ecode4 = 0 ;
25892 PyObject * obj0 = 0 ;
25893 PyObject * obj1 = 0 ;
25894 PyObject * obj2 = 0 ;
25895 PyObject * obj3 = 0 ;
25896 char * kwnames[] = {
25897 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
25898 };
25899
25900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_FindOrCreatePen" "', expected argument " "1"" of type '" "wxPenList *""'");
25904 }
25905 arg1 = reinterpret_cast< wxPenList * >(argp1);
25906 {
25907 arg2 = &temp2;
25908 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
25909 }
25910 ecode3 = SWIG_AsVal_int(obj2, &val3);
25911 if (!SWIG_IsOK(ecode3)) {
25912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PenList_FindOrCreatePen" "', expected argument " "3"" of type '" "int""'");
25913 }
25914 arg3 = static_cast< int >(val3);
25915 ecode4 = SWIG_AsVal_int(obj3, &val4);
25916 if (!SWIG_IsOK(ecode4)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PenList_FindOrCreatePen" "', expected argument " "4"" of type '" "int""'");
25918 }
25919 arg4 = static_cast< int >(val4);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPen, 0 | 0 );
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_PenList_AddPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj = 0;
25935 wxPenList *arg1 = (wxPenList *) 0 ;
25936 wxPen *arg2 = (wxPen *) 0 ;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 void *argp2 = 0 ;
25940 int res2 = 0 ;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char * kwnames[] = {
25944 (char *) "self",(char *) "pen", NULL
25945 };
25946
25947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_AddPen" "', expected argument " "1"" of type '" "wxPenList *""'");
25951 }
25952 arg1 = reinterpret_cast< wxPenList * >(argp1);
25953 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25954 if (!SWIG_IsOK(res2)) {
25955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_AddPen" "', expected argument " "2"" of type '" "wxPen *""'");
25956 }
25957 arg2 = reinterpret_cast< wxPen * >(argp2);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 (arg1)->AddPen(arg2);
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_Py_Void();
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_PenList_RemovePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj = 0;
25973 wxPenList *arg1 = (wxPenList *) 0 ;
25974 wxPen *arg2 = (wxPen *) 0 ;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 void *argp2 = 0 ;
25978 int res2 = 0 ;
25979 PyObject * obj0 = 0 ;
25980 PyObject * obj1 = 0 ;
25981 char * kwnames[] = {
25982 (char *) "self",(char *) "pen", NULL
25983 };
25984
25985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) SWIG_fail;
25986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPenList, 0 | 0 );
25987 if (!SWIG_IsOK(res1)) {
25988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PenList_RemovePen" "', expected argument " "1"" of type '" "wxPenList *""'");
25989 }
25990 arg1 = reinterpret_cast< wxPenList * >(argp1);
25991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPen, 0 | 0 );
25992 if (!SWIG_IsOK(res2)) {
25993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PenList_RemovePen" "', expected argument " "2"" of type '" "wxPen *""'");
25994 }
25995 arg2 = reinterpret_cast< wxPen * >(argp2);
25996 {
25997 PyThreadState* __tstate = wxPyBeginAllowThreads();
25998 (arg1)->RemovePen(arg2);
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 resultobj = SWIG_Py_Void();
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *PenList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26010 PyObject *obj;
26011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26012 SWIG_TypeNewClientData(SWIGTYPE_p_wxPenList, SWIG_NewClientData(obj));
26013 return SWIG_Py_Void();
26014 }
26015
26016 SWIGINTERN PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj = 0;
26018 wxBrushList *arg1 = (wxBrushList *) 0 ;
26019 wxColour *arg2 = 0 ;
26020 int arg3 = (int) wxSOLID ;
26021 wxBrush *result = 0 ;
26022 void *argp1 = 0 ;
26023 int res1 = 0 ;
26024 wxColour temp2 ;
26025 int val3 ;
26026 int ecode3 = 0 ;
26027 PyObject * obj0 = 0 ;
26028 PyObject * obj1 = 0 ;
26029 PyObject * obj2 = 0 ;
26030 char * kwnames[] = {
26031 (char *) "self",(char *) "colour",(char *) "style", NULL
26032 };
26033
26034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
26036 if (!SWIG_IsOK(res1)) {
26037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
26038 }
26039 arg1 = reinterpret_cast< wxBrushList * >(argp1);
26040 {
26041 arg2 = &temp2;
26042 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26043 }
26044 if (obj2) {
26045 ecode3 = SWIG_AsVal_int(obj2, &val3);
26046 if (!SWIG_IsOK(ecode3)) {
26047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrushList_FindOrCreateBrush" "', expected argument " "3"" of type '" "int""'");
26048 }
26049 arg3 = static_cast< int >(val3);
26050 }
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrush, 0 | 0 );
26058 return resultobj;
26059 fail:
26060 return NULL;
26061 }
26062
26063
26064 SWIGINTERN PyObject *_wrap_BrushList_AddBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26065 PyObject *resultobj = 0;
26066 wxBrushList *arg1 = (wxBrushList *) 0 ;
26067 wxBrush *arg2 = (wxBrush *) 0 ;
26068 void *argp1 = 0 ;
26069 int res1 = 0 ;
26070 void *argp2 = 0 ;
26071 int res2 = 0 ;
26072 PyObject * obj0 = 0 ;
26073 PyObject * obj1 = 0 ;
26074 char * kwnames[] = {
26075 (char *) "self",(char *) "brush", NULL
26076 };
26077
26078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) SWIG_fail;
26079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
26080 if (!SWIG_IsOK(res1)) {
26081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_AddBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
26082 }
26083 arg1 = reinterpret_cast< wxBrushList * >(argp1);
26084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
26085 if (!SWIG_IsOK(res2)) {
26086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_AddBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
26087 }
26088 arg2 = reinterpret_cast< wxBrush * >(argp2);
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 (arg1)->AddBrush(arg2);
26092 wxPyEndAllowThreads(__tstate);
26093 if (PyErr_Occurred()) SWIG_fail;
26094 }
26095 resultobj = SWIG_Py_Void();
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 SWIGINTERN PyObject *_wrap_BrushList_RemoveBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26103 PyObject *resultobj = 0;
26104 wxBrushList *arg1 = (wxBrushList *) 0 ;
26105 wxBrush *arg2 = (wxBrush *) 0 ;
26106 void *argp1 = 0 ;
26107 int res1 = 0 ;
26108 void *argp2 = 0 ;
26109 int res2 = 0 ;
26110 PyObject * obj0 = 0 ;
26111 PyObject * obj1 = 0 ;
26112 char * kwnames[] = {
26113 (char *) "self",(char *) "brush", NULL
26114 };
26115
26116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) SWIG_fail;
26117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBrushList, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrushList_RemoveBrush" "', expected argument " "1"" of type '" "wxBrushList *""'");
26120 }
26121 arg1 = reinterpret_cast< wxBrushList * >(argp1);
26122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxBrush, 0 | 0 );
26123 if (!SWIG_IsOK(res2)) {
26124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrushList_RemoveBrush" "', expected argument " "2"" of type '" "wxBrush *""'");
26125 }
26126 arg2 = reinterpret_cast< wxBrush * >(argp2);
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 (arg1)->RemoveBrush(arg2);
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 resultobj = SWIG_Py_Void();
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 SWIGINTERN PyObject *BrushList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26141 PyObject *obj;
26142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26143 SWIG_TypeNewClientData(SWIGTYPE_p_wxBrushList, SWIG_NewClientData(obj));
26144 return SWIG_Py_Void();
26145 }
26146
26147 SWIGINTERN PyObject *_wrap_FontList_FindOrCreateFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj = 0;
26149 wxFontList *arg1 = (wxFontList *) 0 ;
26150 int arg2 ;
26151 int arg3 ;
26152 int arg4 ;
26153 int arg5 ;
26154 bool arg6 = (bool) false ;
26155 wxString const &arg7_defvalue = wxPyEmptyString ;
26156 wxString *arg7 = (wxString *) &arg7_defvalue ;
26157 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
26158 wxFont *result = 0 ;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 int val2 ;
26162 int ecode2 = 0 ;
26163 int val3 ;
26164 int ecode3 = 0 ;
26165 int val4 ;
26166 int ecode4 = 0 ;
26167 int val5 ;
26168 int ecode5 = 0 ;
26169 bool val6 ;
26170 int ecode6 = 0 ;
26171 bool temp7 = false ;
26172 int val8 ;
26173 int ecode8 = 0 ;
26174 PyObject * obj0 = 0 ;
26175 PyObject * obj1 = 0 ;
26176 PyObject * obj2 = 0 ;
26177 PyObject * obj3 = 0 ;
26178 PyObject * obj4 = 0 ;
26179 PyObject * obj5 = 0 ;
26180 PyObject * obj6 = 0 ;
26181 PyObject * obj7 = 0 ;
26182 char * kwnames[] = {
26183 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
26184 };
26185
26186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
26187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
26188 if (!SWIG_IsOK(res1)) {
26189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_FindOrCreateFont" "', expected argument " "1"" of type '" "wxFontList *""'");
26190 }
26191 arg1 = reinterpret_cast< wxFontList * >(argp1);
26192 ecode2 = SWIG_AsVal_int(obj1, &val2);
26193 if (!SWIG_IsOK(ecode2)) {
26194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FontList_FindOrCreateFont" "', expected argument " "2"" of type '" "int""'");
26195 }
26196 arg2 = static_cast< int >(val2);
26197 ecode3 = SWIG_AsVal_int(obj2, &val3);
26198 if (!SWIG_IsOK(ecode3)) {
26199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FontList_FindOrCreateFont" "', expected argument " "3"" of type '" "int""'");
26200 }
26201 arg3 = static_cast< int >(val3);
26202 ecode4 = SWIG_AsVal_int(obj3, &val4);
26203 if (!SWIG_IsOK(ecode4)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FontList_FindOrCreateFont" "', expected argument " "4"" of type '" "int""'");
26205 }
26206 arg4 = static_cast< int >(val4);
26207 ecode5 = SWIG_AsVal_int(obj4, &val5);
26208 if (!SWIG_IsOK(ecode5)) {
26209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FontList_FindOrCreateFont" "', expected argument " "5"" of type '" "int""'");
26210 }
26211 arg5 = static_cast< int >(val5);
26212 if (obj5) {
26213 ecode6 = SWIG_AsVal_bool(obj5, &val6);
26214 if (!SWIG_IsOK(ecode6)) {
26215 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FontList_FindOrCreateFont" "', expected argument " "6"" of type '" "bool""'");
26216 }
26217 arg6 = static_cast< bool >(val6);
26218 }
26219 if (obj6) {
26220 {
26221 arg7 = wxString_in_helper(obj6);
26222 if (arg7 == NULL) SWIG_fail;
26223 temp7 = true;
26224 }
26225 }
26226 if (obj7) {
26227 ecode8 = SWIG_AsVal_int(obj7, &val8);
26228 if (!SWIG_IsOK(ecode8)) {
26229 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FontList_FindOrCreateFont" "', expected argument " "8"" of type '" "wxFontEncoding""'");
26230 }
26231 arg8 = static_cast< wxFontEncoding >(val8);
26232 }
26233 {
26234 PyThreadState* __tstate = wxPyBeginAllowThreads();
26235 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,arg8);
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
26240 {
26241 if (temp7)
26242 delete arg7;
26243 }
26244 return resultobj;
26245 fail:
26246 {
26247 if (temp7)
26248 delete arg7;
26249 }
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *_wrap_FontList_AddFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26255 PyObject *resultobj = 0;
26256 wxFontList *arg1 = (wxFontList *) 0 ;
26257 wxFont *arg2 = (wxFont *) 0 ;
26258 void *argp1 = 0 ;
26259 int res1 = 0 ;
26260 void *argp2 = 0 ;
26261 int res2 = 0 ;
26262 PyObject * obj0 = 0 ;
26263 PyObject * obj1 = 0 ;
26264 char * kwnames[] = {
26265 (char *) "self",(char *) "font", NULL
26266 };
26267
26268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) SWIG_fail;
26269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_AddFont" "', expected argument " "1"" of type '" "wxFontList *""'");
26272 }
26273 arg1 = reinterpret_cast< wxFontList * >(argp1);
26274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
26275 if (!SWIG_IsOK(res2)) {
26276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_AddFont" "', expected argument " "2"" of type '" "wxFont *""'");
26277 }
26278 arg2 = reinterpret_cast< wxFont * >(argp2);
26279 {
26280 PyThreadState* __tstate = wxPyBeginAllowThreads();
26281 (arg1)->AddFont(arg2);
26282 wxPyEndAllowThreads(__tstate);
26283 if (PyErr_Occurred()) SWIG_fail;
26284 }
26285 resultobj = SWIG_Py_Void();
26286 return resultobj;
26287 fail:
26288 return NULL;
26289 }
26290
26291
26292 SWIGINTERN PyObject *_wrap_FontList_RemoveFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26293 PyObject *resultobj = 0;
26294 wxFontList *arg1 = (wxFontList *) 0 ;
26295 wxFont *arg2 = (wxFont *) 0 ;
26296 void *argp1 = 0 ;
26297 int res1 = 0 ;
26298 void *argp2 = 0 ;
26299 int res2 = 0 ;
26300 PyObject * obj0 = 0 ;
26301 PyObject * obj1 = 0 ;
26302 char * kwnames[] = {
26303 (char *) "self",(char *) "font", NULL
26304 };
26305
26306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) SWIG_fail;
26307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFontList, 0 | 0 );
26308 if (!SWIG_IsOK(res1)) {
26309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FontList_RemoveFont" "', expected argument " "1"" of type '" "wxFontList *""'");
26310 }
26311 arg1 = reinterpret_cast< wxFontList * >(argp1);
26312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
26313 if (!SWIG_IsOK(res2)) {
26314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FontList_RemoveFont" "', expected argument " "2"" of type '" "wxFont *""'");
26315 }
26316 arg2 = reinterpret_cast< wxFont * >(argp2);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 (arg1)->RemoveFont(arg2);
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_Py_Void();
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *FontList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *obj;
26332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26333 SWIG_TypeNewClientData(SWIGTYPE_p_wxFontList, SWIG_NewClientData(obj));
26334 return SWIG_Py_Void();
26335 }
26336
26337 SWIGINTERN PyObject *_wrap_new_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26338 PyObject *resultobj = 0;
26339 wxColourDatabase *result = 0 ;
26340
26341 if (!SWIG_Python_UnpackTuple(args,"new_ColourDatabase",0,0,0)) SWIG_fail;
26342 {
26343 if (!wxPyCheckForApp()) SWIG_fail;
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (wxColourDatabase *)new wxColourDatabase();
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_NEW | 0 );
26350 return resultobj;
26351 fail:
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_delete_ColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26357 PyObject *resultobj = 0;
26358 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 PyObject *swig_obj[1] ;
26362
26363 if (!args) SWIG_fail;
26364 swig_obj[0] = args;
26365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_DISOWN | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDatabase" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
26368 }
26369 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
26370 {
26371 PyThreadState* __tstate = wxPyBeginAllowThreads();
26372 delete arg1;
26373
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 resultobj = SWIG_Py_Void();
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *_wrap_ColourDatabase_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj = 0;
26386 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
26387 wxString *arg2 = 0 ;
26388 wxColour result;
26389 void *argp1 = 0 ;
26390 int res1 = 0 ;
26391 bool temp2 = false ;
26392 PyObject * obj0 = 0 ;
26393 PyObject * obj1 = 0 ;
26394 char * kwnames[] = {
26395 (char *) "self",(char *) "name", NULL
26396 };
26397
26398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) SWIG_fail;
26399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
26400 if (!SWIG_IsOK(res1)) {
26401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Find" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
26402 }
26403 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
26404 {
26405 arg2 = wxString_in_helper(obj1);
26406 if (arg2 == NULL) SWIG_fail;
26407 temp2 = true;
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26416 {
26417 if (temp2)
26418 delete arg2;
26419 }
26420 return resultobj;
26421 fail:
26422 {
26423 if (temp2)
26424 delete arg2;
26425 }
26426 return NULL;
26427 }
26428
26429
26430 SWIGINTERN PyObject *_wrap_ColourDatabase_FindName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26431 PyObject *resultobj = 0;
26432 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
26433 wxColour *arg2 = 0 ;
26434 wxString result;
26435 void *argp1 = 0 ;
26436 int res1 = 0 ;
26437 wxColour temp2 ;
26438 PyObject * obj0 = 0 ;
26439 PyObject * obj1 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "self",(char *) "colour", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) SWIG_fail;
26445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
26446 if (!SWIG_IsOK(res1)) {
26447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_FindName" "', expected argument " "1"" of type '" "wxColourDatabase const *""'");
26448 }
26449 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
26450 {
26451 arg2 = &temp2;
26452 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26453 }
26454 {
26455 PyThreadState* __tstate = wxPyBeginAllowThreads();
26456 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
26457 wxPyEndAllowThreads(__tstate);
26458 if (PyErr_Occurred()) SWIG_fail;
26459 }
26460 {
26461 #if wxUSE_UNICODE
26462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26463 #else
26464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26465 #endif
26466 }
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 SWIGINTERN PyObject *_wrap_ColourDatabase_AddColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj = 0;
26475 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
26476 wxString *arg2 = 0 ;
26477 wxColour *arg3 = 0 ;
26478 void *argp1 = 0 ;
26479 int res1 = 0 ;
26480 bool temp2 = false ;
26481 wxColour temp3 ;
26482 PyObject * obj0 = 0 ;
26483 PyObject * obj1 = 0 ;
26484 PyObject * obj2 = 0 ;
26485 char * kwnames[] = {
26486 (char *) "self",(char *) "name",(char *) "colour", NULL
26487 };
26488
26489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
26491 if (!SWIG_IsOK(res1)) {
26492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_AddColour" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
26493 }
26494 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
26495 {
26496 arg2 = wxString_in_helper(obj1);
26497 if (arg2 == NULL) SWIG_fail;
26498 temp2 = true;
26499 }
26500 {
26501 arg3 = &temp3;
26502 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
26503 }
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 resultobj = SWIG_Py_Void();
26511 {
26512 if (temp2)
26513 delete arg2;
26514 }
26515 return resultobj;
26516 fail:
26517 {
26518 if (temp2)
26519 delete arg2;
26520 }
26521 return NULL;
26522 }
26523
26524
26525 SWIGINTERN PyObject *_wrap_ColourDatabase_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26526 PyObject *resultobj = 0;
26527 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
26528 wxString *arg2 = 0 ;
26529 int arg3 ;
26530 int arg4 ;
26531 int arg5 ;
26532 void *argp1 = 0 ;
26533 int res1 = 0 ;
26534 bool temp2 = false ;
26535 int val3 ;
26536 int ecode3 = 0 ;
26537 int val4 ;
26538 int ecode4 = 0 ;
26539 int val5 ;
26540 int ecode5 = 0 ;
26541 PyObject * obj0 = 0 ;
26542 PyObject * obj1 = 0 ;
26543 PyObject * obj2 = 0 ;
26544 PyObject * obj3 = 0 ;
26545 PyObject * obj4 = 0 ;
26546 char * kwnames[] = {
26547 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
26548 };
26549
26550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxColourDatabase, 0 | 0 );
26552 if (!SWIG_IsOK(res1)) {
26553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDatabase_Append" "', expected argument " "1"" of type '" "wxColourDatabase *""'");
26554 }
26555 arg1 = reinterpret_cast< wxColourDatabase * >(argp1);
26556 {
26557 arg2 = wxString_in_helper(obj1);
26558 if (arg2 == NULL) SWIG_fail;
26559 temp2 = true;
26560 }
26561 ecode3 = SWIG_AsVal_int(obj2, &val3);
26562 if (!SWIG_IsOK(ecode3)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourDatabase_Append" "', expected argument " "3"" of type '" "int""'");
26564 }
26565 arg3 = static_cast< int >(val3);
26566 ecode4 = SWIG_AsVal_int(obj3, &val4);
26567 if (!SWIG_IsOK(ecode4)) {
26568 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourDatabase_Append" "', expected argument " "4"" of type '" "int""'");
26569 }
26570 arg4 = static_cast< int >(val4);
26571 ecode5 = SWIG_AsVal_int(obj4, &val5);
26572 if (!SWIG_IsOK(ecode5)) {
26573 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourDatabase_Append" "', expected argument " "5"" of type '" "int""'");
26574 }
26575 arg5 = static_cast< int >(val5);
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
26579 wxPyEndAllowThreads(__tstate);
26580 if (PyErr_Occurred()) SWIG_fail;
26581 }
26582 resultobj = SWIG_Py_Void();
26583 {
26584 if (temp2)
26585 delete arg2;
26586 }
26587 return resultobj;
26588 fail:
26589 {
26590 if (temp2)
26591 delete arg2;
26592 }
26593 return NULL;
26594 }
26595
26596
26597 SWIGINTERN PyObject *ColourDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26598 PyObject *obj;
26599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26600 SWIG_TypeNewClientData(SWIGTYPE_p_wxColourDatabase, SWIG_NewClientData(obj));
26601 return SWIG_Py_Void();
26602 }
26603
26604 SWIGINTERN PyObject *ColourDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26605 return SWIG_Python_InitShadowInstance(args);
26606 }
26607
26608 SWIGINTERN PyObject *_wrap__wxPyInitTheFontList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 PyObject *resultobj = 0;
26610 wxFontList *result = 0 ;
26611
26612 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheFontList",0,0,0)) SWIG_fail;
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (wxFontList *)_wxPyInitTheFontList();
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFontList, 0 | 0 );
26620 return resultobj;
26621 fail:
26622 return NULL;
26623 }
26624
26625
26626 SWIGINTERN PyObject *_wrap__wxPyInitThePenList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26627 PyObject *resultobj = 0;
26628 wxPenList *result = 0 ;
26629
26630 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitThePenList",0,0,0)) SWIG_fail;
26631 {
26632 PyThreadState* __tstate = wxPyBeginAllowThreads();
26633 result = (wxPenList *)_wxPyInitThePenList();
26634 wxPyEndAllowThreads(__tstate);
26635 if (PyErr_Occurred()) SWIG_fail;
26636 }
26637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPenList, 0 | 0 );
26638 return resultobj;
26639 fail:
26640 return NULL;
26641 }
26642
26643
26644 SWIGINTERN PyObject *_wrap__wxPyInitTheBrushList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26645 PyObject *resultobj = 0;
26646 wxBrushList *result = 0 ;
26647
26648 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheBrushList",0,0,0)) SWIG_fail;
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (wxBrushList *)_wxPyInitTheBrushList();
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBrushList, 0 | 0 );
26656 return resultobj;
26657 fail:
26658 return NULL;
26659 }
26660
26661
26662 SWIGINTERN PyObject *_wrap__wxPyInitTheColourDatabase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26663 PyObject *resultobj = 0;
26664 wxColourDatabase *result = 0 ;
26665
26666 if (!SWIG_Python_UnpackTuple(args,"_wxPyInitTheColourDatabase",0,0,0)) SWIG_fail;
26667 {
26668 PyThreadState* __tstate = wxPyBeginAllowThreads();
26669 result = (wxColourDatabase *)_wxPyInitTheColourDatabase();
26670 wxPyEndAllowThreads(__tstate);
26671 if (PyErr_Occurred()) SWIG_fail;
26672 }
26673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColourDatabase, 0 | 0 );
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_new_Effects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26681 PyObject *resultobj = 0;
26682 wxEffects *result = 0 ;
26683
26684 if (!SWIG_Python_UnpackTuple(args,"new_Effects",0,0,0)) SWIG_fail;
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxEffects *)new wxEffects();
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEffects, SWIG_POINTER_NEW | 0 );
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_Effects_GetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 PyObject *resultobj = 0;
26700 wxEffects *arg1 = (wxEffects *) 0 ;
26701 wxColour result;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject *swig_obj[1] ;
26705
26706 if (!args) SWIG_fail;
26707 swig_obj[0] = args;
26708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetHighlightColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxEffects * >(argp1);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = ((wxEffects const *)arg1)->GetHighlightColour();
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26720 return resultobj;
26721 fail:
26722 return NULL;
26723 }
26724
26725
26726 SWIGINTERN PyObject *_wrap_Effects_GetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26727 PyObject *resultobj = 0;
26728 wxEffects *arg1 = (wxEffects *) 0 ;
26729 wxColour result;
26730 void *argp1 = 0 ;
26731 int res1 = 0 ;
26732 PyObject *swig_obj[1] ;
26733
26734 if (!args) SWIG_fail;
26735 swig_obj[0] = args;
26736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26737 if (!SWIG_IsOK(res1)) {
26738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetLightShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26739 }
26740 arg1 = reinterpret_cast< wxEffects * >(argp1);
26741 {
26742 PyThreadState* __tstate = wxPyBeginAllowThreads();
26743 result = ((wxEffects const *)arg1)->GetLightShadow();
26744 wxPyEndAllowThreads(__tstate);
26745 if (PyErr_Occurred()) SWIG_fail;
26746 }
26747 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *_wrap_Effects_GetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 PyObject *resultobj = 0;
26756 wxEffects *arg1 = (wxEffects *) 0 ;
26757 wxColour result;
26758 void *argp1 = 0 ;
26759 int res1 = 0 ;
26760 PyObject *swig_obj[1] ;
26761
26762 if (!args) SWIG_fail;
26763 swig_obj[0] = args;
26764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26765 if (!SWIG_IsOK(res1)) {
26766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetFaceColour" "', expected argument " "1"" of type '" "wxEffects const *""'");
26767 }
26768 arg1 = reinterpret_cast< wxEffects * >(argp1);
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = ((wxEffects const *)arg1)->GetFaceColour();
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26776 return resultobj;
26777 fail:
26778 return NULL;
26779 }
26780
26781
26782 SWIGINTERN PyObject *_wrap_Effects_GetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26783 PyObject *resultobj = 0;
26784 wxEffects *arg1 = (wxEffects *) 0 ;
26785 wxColour result;
26786 void *argp1 = 0 ;
26787 int res1 = 0 ;
26788 PyObject *swig_obj[1] ;
26789
26790 if (!args) SWIG_fail;
26791 swig_obj[0] = args;
26792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26793 if (!SWIG_IsOK(res1)) {
26794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetMediumShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26795 }
26796 arg1 = reinterpret_cast< wxEffects * >(argp1);
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = ((wxEffects const *)arg1)->GetMediumShadow();
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *_wrap_Effects_GetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26811 PyObject *resultobj = 0;
26812 wxEffects *arg1 = (wxEffects *) 0 ;
26813 wxColour result;
26814 void *argp1 = 0 ;
26815 int res1 = 0 ;
26816 PyObject *swig_obj[1] ;
26817
26818 if (!args) SWIG_fail;
26819 swig_obj[0] = args;
26820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26821 if (!SWIG_IsOK(res1)) {
26822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_GetDarkShadow" "', expected argument " "1"" of type '" "wxEffects const *""'");
26823 }
26824 arg1 = reinterpret_cast< wxEffects * >(argp1);
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = ((wxEffects const *)arg1)->GetDarkShadow();
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
26832 return resultobj;
26833 fail:
26834 return NULL;
26835 }
26836
26837
26838 SWIGINTERN PyObject *_wrap_Effects_SetHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj = 0;
26840 wxEffects *arg1 = (wxEffects *) 0 ;
26841 wxColour *arg2 = 0 ;
26842 void *argp1 = 0 ;
26843 int res1 = 0 ;
26844 wxColour temp2 ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "c", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetHighlightColour" "', expected argument " "1"" of type '" "wxEffects *""'");
26855 }
26856 arg1 = reinterpret_cast< wxEffects * >(argp1);
26857 {
26858 arg2 = &temp2;
26859 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26860 }
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 (arg1)->SetHighlightColour((wxColour const &)*arg2);
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 resultobj = SWIG_Py_Void();
26868 return resultobj;
26869 fail:
26870 return NULL;
26871 }
26872
26873
26874 SWIGINTERN PyObject *_wrap_Effects_SetLightShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26875 PyObject *resultobj = 0;
26876 wxEffects *arg1 = (wxEffects *) 0 ;
26877 wxColour *arg2 = 0 ;
26878 void *argp1 = 0 ;
26879 int res1 = 0 ;
26880 wxColour temp2 ;
26881 PyObject * obj0 = 0 ;
26882 PyObject * obj1 = 0 ;
26883 char * kwnames[] = {
26884 (char *) "self",(char *) "c", NULL
26885 };
26886
26887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26889 if (!SWIG_IsOK(res1)) {
26890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetLightShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26891 }
26892 arg1 = reinterpret_cast< wxEffects * >(argp1);
26893 {
26894 arg2 = &temp2;
26895 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26896 }
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 (arg1)->SetLightShadow((wxColour const &)*arg2);
26900 wxPyEndAllowThreads(__tstate);
26901 if (PyErr_Occurred()) SWIG_fail;
26902 }
26903 resultobj = SWIG_Py_Void();
26904 return resultobj;
26905 fail:
26906 return NULL;
26907 }
26908
26909
26910 SWIGINTERN PyObject *_wrap_Effects_SetFaceColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26911 PyObject *resultobj = 0;
26912 wxEffects *arg1 = (wxEffects *) 0 ;
26913 wxColour *arg2 = 0 ;
26914 void *argp1 = 0 ;
26915 int res1 = 0 ;
26916 wxColour temp2 ;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char * kwnames[] = {
26920 (char *) "self",(char *) "c", NULL
26921 };
26922
26923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) SWIG_fail;
26924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26925 if (!SWIG_IsOK(res1)) {
26926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetFaceColour" "', expected argument " "1"" of type '" "wxEffects *""'");
26927 }
26928 arg1 = reinterpret_cast< wxEffects * >(argp1);
26929 {
26930 arg2 = &temp2;
26931 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26932 }
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 (arg1)->SetFaceColour((wxColour const &)*arg2);
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 resultobj = SWIG_Py_Void();
26940 return resultobj;
26941 fail:
26942 return NULL;
26943 }
26944
26945
26946 SWIGINTERN PyObject *_wrap_Effects_SetMediumShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26947 PyObject *resultobj = 0;
26948 wxEffects *arg1 = (wxEffects *) 0 ;
26949 wxColour *arg2 = 0 ;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 wxColour temp2 ;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "self",(char *) "c", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetMediumShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26963 }
26964 arg1 = reinterpret_cast< wxEffects * >(argp1);
26965 {
26966 arg2 = &temp2;
26967 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
26968 }
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 (arg1)->SetMediumShadow((wxColour const &)*arg2);
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 resultobj = SWIG_Py_Void();
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 SWIGINTERN PyObject *_wrap_Effects_SetDarkShadow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26983 PyObject *resultobj = 0;
26984 wxEffects *arg1 = (wxEffects *) 0 ;
26985 wxColour *arg2 = 0 ;
26986 void *argp1 = 0 ;
26987 int res1 = 0 ;
26988 wxColour temp2 ;
26989 PyObject * obj0 = 0 ;
26990 PyObject * obj1 = 0 ;
26991 char * kwnames[] = {
26992 (char *) "self",(char *) "c", NULL
26993 };
26994
26995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) SWIG_fail;
26996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
26997 if (!SWIG_IsOK(res1)) {
26998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_SetDarkShadow" "', expected argument " "1"" of type '" "wxEffects *""'");
26999 }
27000 arg1 = reinterpret_cast< wxEffects * >(argp1);
27001 {
27002 arg2 = &temp2;
27003 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
27004 }
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 (arg1)->SetDarkShadow((wxColour const &)*arg2);
27008 wxPyEndAllowThreads(__tstate);
27009 if (PyErr_Occurred()) SWIG_fail;
27010 }
27011 resultobj = SWIG_Py_Void();
27012 return resultobj;
27013 fail:
27014 return NULL;
27015 }
27016
27017
27018 SWIGINTERN PyObject *_wrap_Effects_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27019 PyObject *resultobj = 0;
27020 wxEffects *arg1 = (wxEffects *) 0 ;
27021 wxColour *arg2 = 0 ;
27022 wxColour *arg3 = 0 ;
27023 wxColour *arg4 = 0 ;
27024 wxColour *arg5 = 0 ;
27025 wxColour *arg6 = 0 ;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 wxColour temp2 ;
27029 wxColour temp3 ;
27030 wxColour temp4 ;
27031 wxColour temp5 ;
27032 wxColour temp6 ;
27033 PyObject * obj0 = 0 ;
27034 PyObject * obj1 = 0 ;
27035 PyObject * obj2 = 0 ;
27036 PyObject * obj3 = 0 ;
27037 PyObject * obj4 = 0 ;
27038 PyObject * obj5 = 0 ;
27039 char * kwnames[] = {
27040 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
27041 };
27042
27043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
27045 if (!SWIG_IsOK(res1)) {
27046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_Set" "', expected argument " "1"" of type '" "wxEffects *""'");
27047 }
27048 arg1 = reinterpret_cast< wxEffects * >(argp1);
27049 {
27050 arg2 = &temp2;
27051 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
27052 }
27053 {
27054 arg3 = &temp3;
27055 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
27056 }
27057 {
27058 arg4 = &temp4;
27059 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
27060 }
27061 {
27062 arg5 = &temp5;
27063 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
27064 }
27065 {
27066 arg6 = &temp6;
27067 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
27068 }
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = SWIG_Py_Void();
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj = 0;
27084 wxEffects *arg1 = (wxEffects *) 0 ;
27085 wxDC *arg2 = 0 ;
27086 wxRect *arg3 = 0 ;
27087 int arg4 = (int) 1 ;
27088 void *argp1 = 0 ;
27089 int res1 = 0 ;
27090 void *argp2 = 0 ;
27091 int res2 = 0 ;
27092 wxRect temp3 ;
27093 int val4 ;
27094 int ecode4 = 0 ;
27095 PyObject * obj0 = 0 ;
27096 PyObject * obj1 = 0 ;
27097 PyObject * obj2 = 0 ;
27098 PyObject * obj3 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "1"" of type '" "wxEffects *""'");
27107 }
27108 arg1 = reinterpret_cast< wxEffects * >(argp1);
27109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
27110 if (!SWIG_IsOK(res2)) {
27111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
27112 }
27113 if (!argp2) {
27114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_DrawSunkenEdge" "', expected argument " "2"" of type '" "wxDC &""'");
27115 }
27116 arg2 = reinterpret_cast< wxDC * >(argp2);
27117 {
27118 arg3 = &temp3;
27119 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
27120 }
27121 if (obj3) {
27122 ecode4 = SWIG_AsVal_int(obj3, &val4);
27123 if (!SWIG_IsOK(ecode4)) {
27124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Effects_DrawSunkenEdge" "', expected argument " "4"" of type '" "int""'");
27125 }
27126 arg4 = static_cast< int >(val4);
27127 }
27128 {
27129 PyThreadState* __tstate = wxPyBeginAllowThreads();
27130 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
27131 wxPyEndAllowThreads(__tstate);
27132 if (PyErr_Occurred()) SWIG_fail;
27133 }
27134 resultobj = SWIG_Py_Void();
27135 return resultobj;
27136 fail:
27137 return NULL;
27138 }
27139
27140
27141 SWIGINTERN PyObject *_wrap_Effects_TileBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27142 PyObject *resultobj = 0;
27143 wxEffects *arg1 = (wxEffects *) 0 ;
27144 wxRect *arg2 = 0 ;
27145 wxDC *arg3 = 0 ;
27146 wxBitmap *arg4 = 0 ;
27147 bool result;
27148 void *argp1 = 0 ;
27149 int res1 = 0 ;
27150 wxRect temp2 ;
27151 void *argp3 = 0 ;
27152 int res3 = 0 ;
27153 void *argp4 = 0 ;
27154 int res4 = 0 ;
27155 PyObject * obj0 = 0 ;
27156 PyObject * obj1 = 0 ;
27157 PyObject * obj2 = 0 ;
27158 PyObject * obj3 = 0 ;
27159 char * kwnames[] = {
27160 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
27161 };
27162
27163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEffects, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Effects_TileBitmap" "', expected argument " "1"" of type '" "wxEffects *""'");
27167 }
27168 arg1 = reinterpret_cast< wxEffects * >(argp1);
27169 {
27170 arg2 = &temp2;
27171 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
27172 }
27173 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27174 if (!SWIG_IsOK(res3)) {
27175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
27176 }
27177 if (!argp3) {
27178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "3"" of type '" "wxDC &""'");
27179 }
27180 arg3 = reinterpret_cast< wxDC * >(argp3);
27181 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxBitmap, 0 );
27182 if (!SWIG_IsOK(res4)) {
27183 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
27184 }
27185 if (!argp4) {
27186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Effects_TileBitmap" "', expected argument " "4"" of type '" "wxBitmap &""'");
27187 }
27188 arg4 = reinterpret_cast< wxBitmap * >(argp4);
27189 {
27190 PyThreadState* __tstate = wxPyBeginAllowThreads();
27191 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 SWIGINTERN PyObject *Effects_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27205 PyObject *obj;
27206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27207 SWIG_TypeNewClientData(SWIGTYPE_p_wxEffects, SWIG_NewClientData(obj));
27208 return SWIG_Py_Void();
27209 }
27210
27211 SWIGINTERN PyObject *Effects_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27212 return SWIG_Python_InitShadowInstance(args);
27213 }
27214
27215 SWIGINTERN PyObject *_wrap_new_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27216 PyObject *resultobj = 0;
27217 int arg1 ;
27218 int arg2 ;
27219 bool arg3 ;
27220 wxSplitterRenderParams *result = 0 ;
27221 int val1 ;
27222 int ecode1 = 0 ;
27223 int val2 ;
27224 int ecode2 = 0 ;
27225 bool val3 ;
27226 int ecode3 = 0 ;
27227 PyObject * obj0 = 0 ;
27228 PyObject * obj1 = 0 ;
27229 PyObject * obj2 = 0 ;
27230 char * kwnames[] = {
27231 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
27232 };
27233
27234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27235 ecode1 = SWIG_AsVal_int(obj0, &val1);
27236 if (!SWIG_IsOK(ecode1)) {
27237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplitterRenderParams" "', expected argument " "1"" of type '" "int""'");
27238 }
27239 arg1 = static_cast< int >(val1);
27240 ecode2 = SWIG_AsVal_int(obj1, &val2);
27241 if (!SWIG_IsOK(ecode2)) {
27242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SplitterRenderParams" "', expected argument " "2"" of type '" "int""'");
27243 }
27244 arg2 = static_cast< int >(val2);
27245 ecode3 = SWIG_AsVal_bool(obj2, &val3);
27246 if (!SWIG_IsOK(ecode3)) {
27247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SplitterRenderParams" "', expected argument " "3"" of type '" "bool""'");
27248 }
27249 arg3 = static_cast< bool >(val3);
27250 {
27251 PyThreadState* __tstate = wxPyBeginAllowThreads();
27252 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_NEW | 0 );
27257 return resultobj;
27258 fail:
27259 return NULL;
27260 }
27261
27262
27263 SWIGINTERN PyObject *_wrap_delete_SplitterRenderParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27264 PyObject *resultobj = 0;
27265 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
27266 void *argp1 = 0 ;
27267 int res1 = 0 ;
27268 PyObject *swig_obj[1] ;
27269
27270 if (!args) SWIG_fail;
27271 swig_obj[0] = args;
27272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_DISOWN | 0 );
27273 if (!SWIG_IsOK(res1)) {
27274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplitterRenderParams" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
27275 }
27276 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 delete arg1;
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *resultobj = 0;
27293 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
27294 int result;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 PyObject *swig_obj[1] ;
27298
27299 if (!args) SWIG_fail;
27300 swig_obj[0] = args;
27301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
27302 if (!SWIG_IsOK(res1)) {
27303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_widthSash_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
27304 }
27305 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
27306 result = (int)(int) ((arg1)->widthSash);
27307 resultobj = SWIG_From_int(static_cast< int >(result));
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 SWIGINTERN PyObject *_wrap_SplitterRenderParams_border_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27315 PyObject *resultobj = 0;
27316 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
27317 int result;
27318 void *argp1 = 0 ;
27319 int res1 = 0 ;
27320 PyObject *swig_obj[1] ;
27321
27322 if (!args) SWIG_fail;
27323 swig_obj[0] = args;
27324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
27325 if (!SWIG_IsOK(res1)) {
27326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_border_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
27327 }
27328 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
27329 result = (int)(int) ((arg1)->border);
27330 resultobj = SWIG_From_int(static_cast< int >(result));
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 SWIGINTERN PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27338 PyObject *resultobj = 0;
27339 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 PyObject *swig_obj[1] ;
27344
27345 if (!args) SWIG_fail;
27346 swig_obj[0] = args;
27347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSplitterRenderParams, 0 | 0 );
27348 if (!SWIG_IsOK(res1)) {
27349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SplitterRenderParams_isHotSensitive_get" "', expected argument " "1"" of type '" "wxSplitterRenderParams *""'");
27350 }
27351 arg1 = reinterpret_cast< wxSplitterRenderParams * >(argp1);
27352 result = (bool)(bool) ((arg1)->isHotSensitive);
27353 resultobj = SWIG_From_bool(static_cast< bool >(result));
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 SWIGINTERN PyObject *SplitterRenderParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27361 PyObject *obj;
27362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27363 SWIG_TypeNewClientData(SWIGTYPE_p_wxSplitterRenderParams, SWIG_NewClientData(obj));
27364 return SWIG_Py_Void();
27365 }
27366
27367 SWIGINTERN PyObject *SplitterRenderParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 return SWIG_Python_InitShadowInstance(args);
27369 }
27370
27371 SWIGINTERN PyObject *_wrap_new_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = 0;
27373 int arg1 ;
27374 int arg2 ;
27375 wxRendererVersion *result = 0 ;
27376 int val1 ;
27377 int ecode1 = 0 ;
27378 int val2 ;
27379 int ecode2 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "version_",(char *) "age_", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) SWIG_fail;
27387 ecode1 = SWIG_AsVal_int(obj0, &val1);
27388 if (!SWIG_IsOK(ecode1)) {
27389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RendererVersion" "', expected argument " "1"" of type '" "int""'");
27390 }
27391 arg1 = static_cast< int >(val1);
27392 ecode2 = SWIG_AsVal_int(obj1, &val2);
27393 if (!SWIG_IsOK(ecode2)) {
27394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RendererVersion" "', expected argument " "2"" of type '" "int""'");
27395 }
27396 arg2 = static_cast< int >(val2);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_NEW | 0 );
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_delete_RendererVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
27413 void *argp1 = 0 ;
27414 int res1 = 0 ;
27415 PyObject *swig_obj[1] ;
27416
27417 if (!args) SWIG_fail;
27418 swig_obj[0] = args;
27419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_DISOWN | 0 );
27420 if (!SWIG_IsOK(res1)) {
27421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RendererVersion" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
27422 }
27423 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 delete arg1;
27427
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_Py_Void();
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_RendererVersion_IsCompatible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj = 0;
27440 wxRendererVersion *arg1 = 0 ;
27441 bool result;
27442 void *argp1 = 0 ;
27443 int res1 = 0 ;
27444 PyObject * obj0 = 0 ;
27445 char * kwnames[] = {
27446 (char *) "ver", NULL
27447 };
27448
27449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) SWIG_fail;
27450 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxRendererVersion, 0 | 0);
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
27453 }
27454 if (!argp1) {
27455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererVersion_IsCompatible" "', expected argument " "1"" of type '" "wxRendererVersion const &""'");
27456 }
27457 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27466 }
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_RendererVersion_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27474 PyObject *resultobj = 0;
27475 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
27476 int result;
27477 void *argp1 = 0 ;
27478 int res1 = 0 ;
27479 PyObject *swig_obj[1] ;
27480
27481 if (!args) SWIG_fail;
27482 swig_obj[0] = args;
27483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_version_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
27486 }
27487 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
27488 result = (int)(int) ((arg1)->version);
27489 resultobj = SWIG_From_int(static_cast< int >(result));
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_RendererVersion_age_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27497 PyObject *resultobj = 0;
27498 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
27499 int result;
27500 void *argp1 = 0 ;
27501 int res1 = 0 ;
27502 PyObject *swig_obj[1] ;
27503
27504 if (!args) SWIG_fail;
27505 swig_obj[0] = args;
27506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererVersion, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererVersion_age_get" "', expected argument " "1"" of type '" "wxRendererVersion *""'");
27509 }
27510 arg1 = reinterpret_cast< wxRendererVersion * >(argp1);
27511 result = (int)(int) ((arg1)->age);
27512 resultobj = SWIG_From_int(static_cast< int >(result));
27513 return resultobj;
27514 fail:
27515 return NULL;
27516 }
27517
27518
27519 SWIGINTERN PyObject *RendererVersion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27520 PyObject *obj;
27521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27522 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererVersion, SWIG_NewClientData(obj));
27523 return SWIG_Py_Void();
27524 }
27525
27526 SWIGINTERN PyObject *RendererVersion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 return SWIG_Python_InitShadowInstance(args);
27528 }
27529
27530 SWIGINTERN PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj = 0;
27532 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27533 wxWindow *arg2 = (wxWindow *) 0 ;
27534 wxDC *arg3 = 0 ;
27535 wxRect *arg4 = 0 ;
27536 int arg5 = (int) 0 ;
27537 void *argp1 = 0 ;
27538 int res1 = 0 ;
27539 void *argp2 = 0 ;
27540 int res2 = 0 ;
27541 void *argp3 = 0 ;
27542 int res3 = 0 ;
27543 wxRect temp4 ;
27544 int val5 ;
27545 int ecode5 = 0 ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 PyObject * obj2 = 0 ;
27549 PyObject * obj3 = 0 ;
27550 PyObject * obj4 = 0 ;
27551 char * kwnames[] = {
27552 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27553 };
27554
27555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27557 if (!SWIG_IsOK(res1)) {
27558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27559 }
27560 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27562 if (!SWIG_IsOK(res2)) {
27563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27564 }
27565 arg2 = reinterpret_cast< wxWindow * >(argp2);
27566 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27567 if (!SWIG_IsOK(res3)) {
27568 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
27569 }
27570 if (!argp3) {
27571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "3"" of type '" "wxDC &""'");
27572 }
27573 arg3 = reinterpret_cast< wxDC * >(argp3);
27574 {
27575 arg4 = &temp4;
27576 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27577 }
27578 if (obj4) {
27579 ecode5 = SWIG_AsVal_int(obj4, &val5);
27580 if (!SWIG_IsOK(ecode5)) {
27581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawHeaderButton" "', expected argument " "5"" of type '" "int""'");
27582 }
27583 arg5 = static_cast< int >(val5);
27584 }
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 resultobj = SWIG_Py_Void();
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 SWIGINTERN PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj = 0;
27600 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27601 wxWindow *arg2 = (wxWindow *) 0 ;
27602 wxDC *arg3 = 0 ;
27603 wxRect *arg4 = 0 ;
27604 int arg5 = (int) 0 ;
27605 void *argp1 = 0 ;
27606 int res1 = 0 ;
27607 void *argp2 = 0 ;
27608 int res2 = 0 ;
27609 void *argp3 = 0 ;
27610 int res3 = 0 ;
27611 wxRect temp4 ;
27612 int val5 ;
27613 int ecode5 = 0 ;
27614 PyObject * obj0 = 0 ;
27615 PyObject * obj1 = 0 ;
27616 PyObject * obj2 = 0 ;
27617 PyObject * obj3 = 0 ;
27618 PyObject * obj4 = 0 ;
27619 char * kwnames[] = {
27620 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27621 };
27622
27623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27625 if (!SWIG_IsOK(res1)) {
27626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27627 }
27628 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27630 if (!SWIG_IsOK(res2)) {
27631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27632 }
27633 arg2 = reinterpret_cast< wxWindow * >(argp2);
27634 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27635 if (!SWIG_IsOK(res3)) {
27636 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
27637 }
27638 if (!argp3) {
27639 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "3"" of type '" "wxDC &""'");
27640 }
27641 arg3 = reinterpret_cast< wxDC * >(argp3);
27642 {
27643 arg4 = &temp4;
27644 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27645 }
27646 if (obj4) {
27647 ecode5 = SWIG_AsVal_int(obj4, &val5);
27648 if (!SWIG_IsOK(ecode5)) {
27649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawTreeItemButton" "', expected argument " "5"" of type '" "int""'");
27650 }
27651 arg5 = static_cast< int >(val5);
27652 }
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 resultobj = SWIG_Py_Void();
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj = 0;
27668 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27669 wxWindow *arg2 = (wxWindow *) 0 ;
27670 wxDC *arg3 = 0 ;
27671 wxRect *arg4 = 0 ;
27672 int arg5 = (int) 0 ;
27673 void *argp1 = 0 ;
27674 int res1 = 0 ;
27675 void *argp2 = 0 ;
27676 int res2 = 0 ;
27677 void *argp3 = 0 ;
27678 int res3 = 0 ;
27679 wxRect temp4 ;
27680 int val5 ;
27681 int ecode5 = 0 ;
27682 PyObject * obj0 = 0 ;
27683 PyObject * obj1 = 0 ;
27684 PyObject * obj2 = 0 ;
27685 PyObject * obj3 = 0 ;
27686 PyObject * obj4 = 0 ;
27687 char * kwnames[] = {
27688 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27689 };
27690
27691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27695 }
27696 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27698 if (!SWIG_IsOK(res2)) {
27699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "2"" of type '" "wxWindow *""'");
27700 }
27701 arg2 = reinterpret_cast< wxWindow * >(argp2);
27702 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27703 if (!SWIG_IsOK(res3)) {
27704 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
27705 }
27706 if (!argp3) {
27707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "3"" of type '" "wxDC &""'");
27708 }
27709 arg3 = reinterpret_cast< wxDC * >(argp3);
27710 {
27711 arg4 = &temp4;
27712 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27713 }
27714 if (obj4) {
27715 ecode5 = SWIG_AsVal_int(obj4, &val5);
27716 if (!SWIG_IsOK(ecode5)) {
27717 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterBorder" "', expected argument " "5"" of type '" "int""'");
27718 }
27719 arg5 = static_cast< int >(val5);
27720 }
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 resultobj = SWIG_Py_Void();
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj = 0;
27736 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27737 wxWindow *arg2 = (wxWindow *) 0 ;
27738 wxDC *arg3 = 0 ;
27739 wxSize *arg4 = 0 ;
27740 int arg5 ;
27741 wxOrientation arg6 ;
27742 int arg7 = (int) 0 ;
27743 void *argp1 = 0 ;
27744 int res1 = 0 ;
27745 void *argp2 = 0 ;
27746 int res2 = 0 ;
27747 void *argp3 = 0 ;
27748 int res3 = 0 ;
27749 wxSize temp4 ;
27750 int val5 ;
27751 int ecode5 = 0 ;
27752 int val6 ;
27753 int ecode6 = 0 ;
27754 int val7 ;
27755 int ecode7 = 0 ;
27756 PyObject * obj0 = 0 ;
27757 PyObject * obj1 = 0 ;
27758 PyObject * obj2 = 0 ;
27759 PyObject * obj3 = 0 ;
27760 PyObject * obj4 = 0 ;
27761 PyObject * obj5 = 0 ;
27762 PyObject * obj6 = 0 ;
27763 char * kwnames[] = {
27764 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
27765 };
27766
27767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27769 if (!SWIG_IsOK(res1)) {
27770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27771 }
27772 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27774 if (!SWIG_IsOK(res2)) {
27775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "2"" of type '" "wxWindow *""'");
27776 }
27777 arg2 = reinterpret_cast< wxWindow * >(argp2);
27778 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27779 if (!SWIG_IsOK(res3)) {
27780 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
27781 }
27782 if (!argp3) {
27783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "3"" of type '" "wxDC &""'");
27784 }
27785 arg3 = reinterpret_cast< wxDC * >(argp3);
27786 {
27787 arg4 = &temp4;
27788 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27789 }
27790 ecode5 = SWIG_AsVal_int(obj4, &val5);
27791 if (!SWIG_IsOK(ecode5)) {
27792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "5"" of type '" "int""'");
27793 }
27794 arg5 = static_cast< int >(val5);
27795 ecode6 = SWIG_AsVal_int(obj5, &val6);
27796 if (!SWIG_IsOK(ecode6)) {
27797 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "6"" of type '" "wxOrientation""'");
27798 }
27799 arg6 = static_cast< wxOrientation >(val6);
27800 if (obj6) {
27801 ecode7 = SWIG_AsVal_int(obj6, &val7);
27802 if (!SWIG_IsOK(ecode7)) {
27803 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RendererNative_DrawSplitterSash" "', expected argument " "7"" of type '" "int""'");
27804 }
27805 arg7 = static_cast< int >(val7);
27806 }
27807 {
27808 PyThreadState* __tstate = wxPyBeginAllowThreads();
27809 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,arg6,arg7);
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 resultobj = SWIG_Py_Void();
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj = 0;
27822 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27823 wxWindow *arg2 = (wxWindow *) 0 ;
27824 wxDC *arg3 = 0 ;
27825 wxRect *arg4 = 0 ;
27826 int arg5 = (int) 0 ;
27827 void *argp1 = 0 ;
27828 int res1 = 0 ;
27829 void *argp2 = 0 ;
27830 int res2 = 0 ;
27831 void *argp3 = 0 ;
27832 int res3 = 0 ;
27833 wxRect temp4 ;
27834 int val5 ;
27835 int ecode5 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 PyObject * obj2 = 0 ;
27839 PyObject * obj3 = 0 ;
27840 PyObject * obj4 = 0 ;
27841 char * kwnames[] = {
27842 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27843 };
27844
27845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27849 }
27850 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27851 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27852 if (!SWIG_IsOK(res2)) {
27853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "2"" of type '" "wxWindow *""'");
27854 }
27855 arg2 = reinterpret_cast< wxWindow * >(argp2);
27856 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27857 if (!SWIG_IsOK(res3)) {
27858 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
27859 }
27860 if (!argp3) {
27861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "3"" of type '" "wxDC &""'");
27862 }
27863 arg3 = reinterpret_cast< wxDC * >(argp3);
27864 {
27865 arg4 = &temp4;
27866 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27867 }
27868 if (obj4) {
27869 ecode5 = SWIG_AsVal_int(obj4, &val5);
27870 if (!SWIG_IsOK(ecode5)) {
27871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawComboBoxDropButton" "', expected argument " "5"" of type '" "int""'");
27872 }
27873 arg5 = static_cast< int >(val5);
27874 }
27875 {
27876 PyThreadState* __tstate = wxPyBeginAllowThreads();
27877 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
27878 wxPyEndAllowThreads(__tstate);
27879 if (PyErr_Occurred()) SWIG_fail;
27880 }
27881 resultobj = SWIG_Py_Void();
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 SWIGINTERN PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj = 0;
27890 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27891 wxWindow *arg2 = (wxWindow *) 0 ;
27892 wxDC *arg3 = 0 ;
27893 wxRect *arg4 = 0 ;
27894 int arg5 = (int) 0 ;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 void *argp2 = 0 ;
27898 int res2 = 0 ;
27899 void *argp3 = 0 ;
27900 int res3 = 0 ;
27901 wxRect temp4 ;
27902 int val5 ;
27903 int ecode5 = 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 PyObject * obj2 = 0 ;
27907 PyObject * obj3 = 0 ;
27908 PyObject * obj4 = 0 ;
27909 char * kwnames[] = {
27910 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27911 };
27912
27913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27915 if (!SWIG_IsOK(res1)) {
27916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27917 }
27918 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27920 if (!SWIG_IsOK(res2)) {
27921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "2"" of type '" "wxWindow *""'");
27922 }
27923 arg2 = reinterpret_cast< wxWindow * >(argp2);
27924 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27925 if (!SWIG_IsOK(res3)) {
27926 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
27927 }
27928 if (!argp3) {
27929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawDropArrow" "', expected argument " "3"" of type '" "wxDC &""'");
27930 }
27931 arg3 = reinterpret_cast< wxDC * >(argp3);
27932 {
27933 arg4 = &temp4;
27934 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
27935 }
27936 if (obj4) {
27937 ecode5 = SWIG_AsVal_int(obj4, &val5);
27938 if (!SWIG_IsOK(ecode5)) {
27939 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawDropArrow" "', expected argument " "5"" of type '" "int""'");
27940 }
27941 arg5 = static_cast< int >(val5);
27942 }
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 resultobj = SWIG_Py_Void();
27950 return resultobj;
27951 fail:
27952 return NULL;
27953 }
27954
27955
27956 SWIGINTERN PyObject *_wrap_RendererNative_DrawCheckBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj = 0;
27958 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
27959 wxWindow *arg2 = (wxWindow *) 0 ;
27960 wxDC *arg3 = 0 ;
27961 wxRect *arg4 = 0 ;
27962 int arg5 = (int) 0 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 void *argp2 = 0 ;
27966 int res2 = 0 ;
27967 void *argp3 = 0 ;
27968 int res3 = 0 ;
27969 wxRect temp4 ;
27970 int val5 ;
27971 int ecode5 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 PyObject * obj2 = 0 ;
27975 PyObject * obj3 = 0 ;
27976 PyObject * obj4 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawCheckBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "1"" of type '" "wxRendererNative *""'");
27985 }
27986 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
27987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27988 if (!SWIG_IsOK(res2)) {
27989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "2"" of type '" "wxWindow *""'");
27990 }
27991 arg2 = reinterpret_cast< wxWindow * >(argp2);
27992 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
27993 if (!SWIG_IsOK(res3)) {
27994 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27995 }
27996 if (!argp3) {
27997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawCheckBox" "', expected argument " "3"" of type '" "wxDC &""'");
27998 }
27999 arg3 = reinterpret_cast< wxDC * >(argp3);
28000 {
28001 arg4 = &temp4;
28002 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
28003 }
28004 if (obj4) {
28005 ecode5 = SWIG_AsVal_int(obj4, &val5);
28006 if (!SWIG_IsOK(ecode5)) {
28007 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawCheckBox" "', expected argument " "5"" of type '" "int""'");
28008 }
28009 arg5 = static_cast< int >(val5);
28010 }
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 (arg1)->DrawCheckBox(arg2,*arg3,(wxRect const &)*arg4,arg5);
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 resultobj = SWIG_Py_Void();
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 SWIGINTERN PyObject *_wrap_RendererNative_DrawPushButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28025 PyObject *resultobj = 0;
28026 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
28027 wxWindow *arg2 = (wxWindow *) 0 ;
28028 wxDC *arg3 = 0 ;
28029 wxRect *arg4 = 0 ;
28030 int arg5 = (int) 0 ;
28031 void *argp1 = 0 ;
28032 int res1 = 0 ;
28033 void *argp2 = 0 ;
28034 int res2 = 0 ;
28035 void *argp3 = 0 ;
28036 int res3 = 0 ;
28037 wxRect temp4 ;
28038 int val5 ;
28039 int ecode5 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 PyObject * obj2 = 0 ;
28043 PyObject * obj3 = 0 ;
28044 PyObject * obj4 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawPushButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawPushButton" "', expected argument " "1"" of type '" "wxRendererNative *""'");
28053 }
28054 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
28055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28056 if (!SWIG_IsOK(res2)) {
28057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawPushButton" "', expected argument " "2"" of type '" "wxWindow *""'");
28058 }
28059 arg2 = reinterpret_cast< wxWindow * >(argp2);
28060 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
28061 if (!SWIG_IsOK(res3)) {
28062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
28063 }
28064 if (!argp3) {
28065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawPushButton" "', expected argument " "3"" of type '" "wxDC &""'");
28066 }
28067 arg3 = reinterpret_cast< wxDC * >(argp3);
28068 {
28069 arg4 = &temp4;
28070 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
28071 }
28072 if (obj4) {
28073 ecode5 = SWIG_AsVal_int(obj4, &val5);
28074 if (!SWIG_IsOK(ecode5)) {
28075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawPushButton" "', expected argument " "5"" of type '" "int""'");
28076 }
28077 arg5 = static_cast< int >(val5);
28078 }
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 (arg1)->DrawPushButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_Py_Void();
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *_wrap_RendererNative_DrawItemSelectionRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28093 PyObject *resultobj = 0;
28094 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
28095 wxWindow *arg2 = (wxWindow *) 0 ;
28096 wxDC *arg3 = 0 ;
28097 wxRect *arg4 = 0 ;
28098 int arg5 = (int) 0 ;
28099 void *argp1 = 0 ;
28100 int res1 = 0 ;
28101 void *argp2 = 0 ;
28102 int res2 = 0 ;
28103 void *argp3 = 0 ;
28104 int res3 = 0 ;
28105 wxRect temp4 ;
28106 int val5 ;
28107 int ecode5 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 PyObject * obj1 = 0 ;
28110 PyObject * obj2 = 0 ;
28111 PyObject * obj3 = 0 ;
28112 PyObject * obj4 = 0 ;
28113 char * kwnames[] = {
28114 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
28115 };
28116
28117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawItemSelectionRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
28119 if (!SWIG_IsOK(res1)) {
28120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "1"" of type '" "wxRendererNative *""'");
28121 }
28122 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
28123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28124 if (!SWIG_IsOK(res2)) {
28125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "2"" of type '" "wxWindow *""'");
28126 }
28127 arg2 = reinterpret_cast< wxWindow * >(argp2);
28128 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );
28129 if (!SWIG_IsOK(res3)) {
28130 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
28131 }
28132 if (!argp3) {
28133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "3"" of type '" "wxDC &""'");
28134 }
28135 arg3 = reinterpret_cast< wxDC * >(argp3);
28136 {
28137 arg4 = &temp4;
28138 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
28139 }
28140 if (obj4) {
28141 ecode5 = SWIG_AsVal_int(obj4, &val5);
28142 if (!SWIG_IsOK(ecode5)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RendererNative_DrawItemSelectionRect" "', expected argument " "5"" of type '" "int""'");
28144 }
28145 arg5 = static_cast< int >(val5);
28146 }
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 (arg1)->DrawItemSelectionRect(arg2,*arg3,(wxRect const &)*arg4,arg5);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 resultobj = SWIG_Py_Void();
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28161 PyObject *resultobj = 0;
28162 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
28163 wxWindow *arg2 = (wxWindow *) 0 ;
28164 SwigValueWrapper<wxSplitterRenderParams > result;
28165 void *argp1 = 0 ;
28166 int res1 = 0 ;
28167 void *argp2 = 0 ;
28168 int res2 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "self",(char *) "win", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) SWIG_fail;
28176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "1"" of type '" "wxRendererNative *""'");
28179 }
28180 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
28181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28182 if (!SWIG_IsOK(res2)) {
28183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RendererNative_GetSplitterParams" "', expected argument " "2"" of type '" "wxWindow const *""'");
28184 }
28185 arg2 = reinterpret_cast< wxWindow * >(argp2);
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
28189 wxPyEndAllowThreads(__tstate);
28190 if (PyErr_Occurred()) SWIG_fail;
28191 }
28192 resultobj = SWIG_NewPointerObj((new wxSplitterRenderParams(static_cast< const wxSplitterRenderParams& >(result))), SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_OWN | 0 );
28193 return resultobj;
28194 fail:
28195 return NULL;
28196 }
28197
28198
28199 SWIGINTERN PyObject *_wrap_RendererNative_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28200 PyObject *resultobj = 0;
28201 wxRendererNative *result = 0 ;
28202
28203 if (!SWIG_Python_UnpackTuple(args,"RendererNative_Get",0,0,0)) SWIG_fail;
28204 {
28205 if (!wxPyCheckForApp()) SWIG_fail;
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 {
28208 wxRendererNative &_result_ref = wxRendererNative::Get();
28209 result = (wxRendererNative *) &_result_ref;
28210 }
28211 wxPyEndAllowThreads(__tstate);
28212 if (PyErr_Occurred()) SWIG_fail;
28213 }
28214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
28215 return resultobj;
28216 fail:
28217 return NULL;
28218 }
28219
28220
28221 SWIGINTERN PyObject *_wrap_RendererNative_GetGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28222 PyObject *resultobj = 0;
28223 wxRendererNative *result = 0 ;
28224
28225 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetGeneric",0,0,0)) SWIG_fail;
28226 {
28227 if (!wxPyCheckForApp()) SWIG_fail;
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 {
28230 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
28231 result = (wxRendererNative *) &_result_ref;
28232 }
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_RendererNative_GetDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245 wxRendererNative *result = 0 ;
28246
28247 if (!SWIG_Python_UnpackTuple(args,"RendererNative_GetDefault",0,0,0)) SWIG_fail;
28248 {
28249 if (!wxPyCheckForApp()) SWIG_fail;
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 {
28252 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
28253 result = (wxRendererNative *) &_result_ref;
28254 }
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_RendererNative_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28266 PyObject *resultobj = 0;
28267 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
28268 wxRendererNative *result = 0 ;
28269 void *argp1 = 0 ;
28270 int res1 = 0 ;
28271 PyObject * obj0 = 0 ;
28272 char * kwnames[] = {
28273 (char *) "renderer", NULL
28274 };
28275
28276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) SWIG_fail;
28277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
28278 if (!SWIG_IsOK(res1)) {
28279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_Set" "', expected argument " "1"" of type '" "wxRendererNative *""'");
28280 }
28281 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
28282 {
28283 if (!wxPyCheckForApp()) SWIG_fail;
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (wxRendererNative *)wxRendererNative::Set(arg1);
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRendererNative, 0 | 0 );
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 SWIGINTERN PyObject *_wrap_RendererNative_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28297 PyObject *resultobj = 0;
28298 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
28299 SwigValueWrapper<wxRendererVersion > result;
28300 void *argp1 = 0 ;
28301 int res1 = 0 ;
28302 PyObject *swig_obj[1] ;
28303
28304 if (!args) SWIG_fail;
28305 swig_obj[0] = args;
28306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRendererNative, 0 | 0 );
28307 if (!SWIG_IsOK(res1)) {
28308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RendererNative_GetVersion" "', expected argument " "1"" of type '" "wxRendererNative const *""'");
28309 }
28310 arg1 = reinterpret_cast< wxRendererNative * >(argp1);
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = ((wxRendererNative const *)arg1)->GetVersion();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_NewPointerObj((new wxRendererVersion(static_cast< const wxRendererVersion& >(result))), SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_OWN | 0 );
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *RendererNative_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *obj;
28326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28327 SWIG_TypeNewClientData(SWIGTYPE_p_wxRendererNative, SWIG_NewClientData(obj));
28328 return SWIG_Py_Void();
28329 }
28330
28331 SWIGINTERN PyObject *_wrap_new_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28332 PyObject *resultobj = 0;
28333 wxPseudoDC *result = 0 ;
28334
28335 if (!SWIG_Python_UnpackTuple(args,"new_PseudoDC",0,0,0)) SWIG_fail;
28336 {
28337 PyThreadState* __tstate = wxPyBeginAllowThreads();
28338 result = (wxPseudoDC *)new wxPseudoDC();
28339 wxPyEndAllowThreads(__tstate);
28340 if (PyErr_Occurred()) SWIG_fail;
28341 }
28342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_NEW | 0 );
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 SWIGINTERN PyObject *_wrap_PseudoDC_BeginDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28350 PyObject *resultobj = 0;
28351 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28352 void *argp1 = 0 ;
28353 int res1 = 0 ;
28354 PyObject *swig_obj[1] ;
28355
28356 if (!args) SWIG_fail;
28357 swig_obj[0] = args;
28358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28359 if (!SWIG_IsOK(res1)) {
28360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_BeginDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28361 }
28362 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28363 {
28364 PyThreadState* __tstate = wxPyBeginAllowThreads();
28365 (arg1)->BeginDrawing();
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 resultobj = SWIG_Py_Void();
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 SWIGINTERN PyObject *_wrap_PseudoDC_EndDrawing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28377 PyObject *resultobj = 0;
28378 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28379 void *argp1 = 0 ;
28380 int res1 = 0 ;
28381 PyObject *swig_obj[1] ;
28382
28383 if (!args) SWIG_fail;
28384 swig_obj[0] = args;
28385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28386 if (!SWIG_IsOK(res1)) {
28387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_EndDrawing" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28388 }
28389 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 (arg1)->EndDrawing();
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 resultobj = SWIG_Py_Void();
28397 return resultobj;
28398 fail:
28399 return NULL;
28400 }
28401
28402
28403 SWIGINTERN PyObject *_wrap_delete_PseudoDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28404 PyObject *resultobj = 0;
28405 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28406 void *argp1 = 0 ;
28407 int res1 = 0 ;
28408 PyObject *swig_obj[1] ;
28409
28410 if (!args) SWIG_fail;
28411 swig_obj[0] = args;
28412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, SWIG_POINTER_DISOWN | 0 );
28413 if (!SWIG_IsOK(res1)) {
28414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PseudoDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28415 }
28416 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 delete arg1;
28420
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 resultobj = SWIG_Py_Void();
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28432 PyObject *resultobj = 0;
28433 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28434 void *argp1 = 0 ;
28435 int res1 = 0 ;
28436 PyObject *swig_obj[1] ;
28437
28438 if (!args) SWIG_fail;
28439 swig_obj[0] = args;
28440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28441 if (!SWIG_IsOK(res1)) {
28442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveAll" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28443 }
28444 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28445 {
28446 PyThreadState* __tstate = wxPyBeginAllowThreads();
28447 (arg1)->RemoveAll();
28448 wxPyEndAllowThreads(__tstate);
28449 if (PyErr_Occurred()) SWIG_fail;
28450 }
28451 resultobj = SWIG_Py_Void();
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 SWIGINTERN PyObject *_wrap_PseudoDC_GetLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 PyObject *resultobj = 0;
28460 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28461 int result;
28462 void *argp1 = 0 ;
28463 int res1 = 0 ;
28464 PyObject *swig_obj[1] ;
28465
28466 if (!args) SWIG_fail;
28467 swig_obj[0] = args;
28468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28469 if (!SWIG_IsOK(res1)) {
28470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetLen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28471 }
28472 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (int)(arg1)->GetLen();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = SWIG_From_int(static_cast< int >(result));
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_PseudoDC_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj = 0;
28488 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28489 int arg2 ;
28490 void *argp1 = 0 ;
28491 int res1 = 0 ;
28492 int val2 ;
28493 int ecode2 = 0 ;
28494 PyObject * obj0 = 0 ;
28495 PyObject * obj1 = 0 ;
28496 char * kwnames[] = {
28497 (char *) "self",(char *) "id", NULL
28498 };
28499
28500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
28501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28502 if (!SWIG_IsOK(res1)) {
28503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28504 }
28505 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28506 ecode2 = SWIG_AsVal_int(obj1, &val2);
28507 if (!SWIG_IsOK(ecode2)) {
28508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetId" "', expected argument " "2"" of type '" "int""'");
28509 }
28510 arg2 = static_cast< int >(val2);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 (arg1)->SetId(arg2);
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 resultobj = SWIG_Py_Void();
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_PseudoDC_ClearId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj = 0;
28526 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28527 int arg2 ;
28528 void *argp1 = 0 ;
28529 int res1 = 0 ;
28530 int val2 ;
28531 int ecode2 = 0 ;
28532 PyObject * obj0 = 0 ;
28533 PyObject * obj1 = 0 ;
28534 char * kwnames[] = {
28535 (char *) "self",(char *) "id", NULL
28536 };
28537
28538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_ClearId",kwnames,&obj0,&obj1)) SWIG_fail;
28539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28540 if (!SWIG_IsOK(res1)) {
28541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_ClearId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28542 }
28543 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28544 ecode2 = SWIG_AsVal_int(obj1, &val2);
28545 if (!SWIG_IsOK(ecode2)) {
28546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_ClearId" "', expected argument " "2"" of type '" "int""'");
28547 }
28548 arg2 = static_cast< int >(val2);
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 (arg1)->ClearId(arg2);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_Py_Void();
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_PseudoDC_RemoveId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28563 PyObject *resultobj = 0;
28564 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28565 int arg2 ;
28566 void *argp1 = 0 ;
28567 int res1 = 0 ;
28568 int val2 ;
28569 int ecode2 = 0 ;
28570 PyObject * obj0 = 0 ;
28571 PyObject * obj1 = 0 ;
28572 char * kwnames[] = {
28573 (char *) "self",(char *) "id", NULL
28574 };
28575
28576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_RemoveId",kwnames,&obj0,&obj1)) SWIG_fail;
28577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28578 if (!SWIG_IsOK(res1)) {
28579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_RemoveId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28580 }
28581 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28582 ecode2 = SWIG_AsVal_int(obj1, &val2);
28583 if (!SWIG_IsOK(ecode2)) {
28584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_RemoveId" "', expected argument " "2"" of type '" "int""'");
28585 }
28586 arg2 = static_cast< int >(val2);
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 (arg1)->RemoveId(arg2);
28590 wxPyEndAllowThreads(__tstate);
28591 if (PyErr_Occurred()) SWIG_fail;
28592 }
28593 resultobj = SWIG_Py_Void();
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_PseudoDC_TranslateId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28601 PyObject *resultobj = 0;
28602 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28603 int arg2 ;
28604 int arg3 ;
28605 int arg4 ;
28606 void *argp1 = 0 ;
28607 int res1 = 0 ;
28608 int val2 ;
28609 int ecode2 = 0 ;
28610 int val3 ;
28611 int ecode3 = 0 ;
28612 int val4 ;
28613 int ecode4 = 0 ;
28614 PyObject * obj0 = 0 ;
28615 PyObject * obj1 = 0 ;
28616 PyObject * obj2 = 0 ;
28617 PyObject * obj3 = 0 ;
28618 char * kwnames[] = {
28619 (char *) "self",(char *) "id",(char *) "dx",(char *) "dy", NULL
28620 };
28621
28622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_TranslateId",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_TranslateId" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28626 }
28627 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28628 ecode2 = SWIG_AsVal_int(obj1, &val2);
28629 if (!SWIG_IsOK(ecode2)) {
28630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_TranslateId" "', expected argument " "2"" of type '" "int""'");
28631 }
28632 arg2 = static_cast< int >(val2);
28633 ecode3 = SWIG_AsVal_int(obj2, &val3);
28634 if (!SWIG_IsOK(ecode3)) {
28635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_TranslateId" "', expected argument " "3"" of type '" "int""'");
28636 }
28637 arg3 = static_cast< int >(val3);
28638 ecode4 = SWIG_AsVal_int(obj3, &val4);
28639 if (!SWIG_IsOK(ecode4)) {
28640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_TranslateId" "', expected argument " "4"" of type '" "int""'");
28641 }
28642 arg4 = static_cast< int >(val4);
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 (arg1)->TranslateId(arg2,arg3,arg4);
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 resultobj = SWIG_Py_Void();
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIdToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj = 0;
28658 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28659 int arg2 ;
28660 wxDC *arg3 = (wxDC *) 0 ;
28661 void *argp1 = 0 ;
28662 int res1 = 0 ;
28663 int val2 ;
28664 int ecode2 = 0 ;
28665 void *argp3 = 0 ;
28666 int res3 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 PyObject * obj1 = 0 ;
28669 PyObject * obj2 = 0 ;
28670 char * kwnames[] = {
28671 (char *) "self",(char *) "id",(char *) "dc", NULL
28672 };
28673
28674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIdToDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28676 if (!SWIG_IsOK(res1)) {
28677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28678 }
28679 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28680 ecode2 = SWIG_AsVal_int(obj1, &val2);
28681 if (!SWIG_IsOK(ecode2)) {
28682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "2"" of type '" "int""'");
28683 }
28684 arg2 = static_cast< int >(val2);
28685 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxDC, 0 | 0 );
28686 if (!SWIG_IsOK(res3)) {
28687 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawIdToDC" "', expected argument " "3"" of type '" "wxDC *""'");
28688 }
28689 arg3 = reinterpret_cast< wxDC * >(argp3);
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 (arg1)->DrawIdToDC(arg2,arg3);
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_Py_Void();
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 SWIGINTERN PyObject *_wrap_PseudoDC_SetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj = 0;
28705 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28706 int arg2 ;
28707 wxRect *arg3 = 0 ;
28708 void *argp1 = 0 ;
28709 int res1 = 0 ;
28710 int val2 ;
28711 int ecode2 = 0 ;
28712 wxRect temp3 ;
28713 PyObject * obj0 = 0 ;
28714 PyObject * obj1 = 0 ;
28715 PyObject * obj2 = 0 ;
28716 char * kwnames[] = {
28717 (char *) "self",(char *) "id",(char *) "rect", NULL
28718 };
28719
28720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_SetIdBounds",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28724 }
28725 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28726 ecode2 = SWIG_AsVal_int(obj1, &val2);
28727 if (!SWIG_IsOK(ecode2)) {
28728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetIdBounds" "', expected argument " "2"" of type '" "int""'");
28729 }
28730 arg2 = static_cast< int >(val2);
28731 {
28732 arg3 = &temp3;
28733 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
28734 }
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 (arg1)->SetIdBounds(arg2,*arg3);
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_Py_Void();
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_PseudoDC_GetIdBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj = 0;
28750 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28751 int arg2 ;
28752 wxRect result;
28753 void *argp1 = 0 ;
28754 int res1 = 0 ;
28755 int val2 ;
28756 int ecode2 = 0 ;
28757 PyObject * obj0 = 0 ;
28758 PyObject * obj1 = 0 ;
28759 char * kwnames[] = {
28760 (char *) "self",(char *) "id", NULL
28761 };
28762
28763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_GetIdBounds",kwnames,&obj0,&obj1)) SWIG_fail;
28764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28765 if (!SWIG_IsOK(res1)) {
28766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28767 }
28768 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28769 ecode2 = SWIG_AsVal_int(obj1, &val2);
28770 if (!SWIG_IsOK(ecode2)) {
28771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_GetIdBounds" "', expected argument " "2"" of type '" "int""'");
28772 }
28773 arg2 = static_cast< int >(val2);
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = wxPseudoDC_GetIdBounds(arg1,arg2);
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj = 0;
28789 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28790 wxDC *arg2 = (wxDC *) 0 ;
28791 wxRect *arg3 = 0 ;
28792 void *argp1 = 0 ;
28793 int res1 = 0 ;
28794 void *argp2 = 0 ;
28795 int res2 = 0 ;
28796 wxRect temp3 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 PyObject * obj2 = 0 ;
28800 char * kwnames[] = {
28801 (char *) "self",(char *) "dc",(char *) "rect", NULL
28802 };
28803
28804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClipped",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28808 }
28809 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28811 if (!SWIG_IsOK(res2)) {
28812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClipped" "', expected argument " "2"" of type '" "wxDC *""'");
28813 }
28814 arg2 = reinterpret_cast< wxDC * >(argp2);
28815 {
28816 arg3 = &temp3;
28817 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 (arg1)->DrawToDCClipped(arg2,(wxRect const &)*arg3);
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 resultobj = SWIG_Py_Void();
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDCClippedRgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28833 PyObject *resultobj = 0;
28834 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28835 wxDC *arg2 = (wxDC *) 0 ;
28836 wxRegion *arg3 = 0 ;
28837 void *argp1 = 0 ;
28838 int res1 = 0 ;
28839 void *argp2 = 0 ;
28840 int res2 = 0 ;
28841 void *argp3 = 0 ;
28842 int res3 = 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 char * kwnames[] = {
28847 (char *) "self",(char *) "dc",(char *) "region", NULL
28848 };
28849
28850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawToDCClippedRgn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28852 if (!SWIG_IsOK(res1)) {
28853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28854 }
28855 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28857 if (!SWIG_IsOK(res2)) {
28858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "2"" of type '" "wxDC *""'");
28859 }
28860 arg2 = reinterpret_cast< wxDC * >(argp2);
28861 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRegion, 0 | 0);
28862 if (!SWIG_IsOK(res3)) {
28863 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
28864 }
28865 if (!argp3) {
28866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawToDCClippedRgn" "', expected argument " "3"" of type '" "wxRegion const &""'");
28867 }
28868 arg3 = reinterpret_cast< wxRegion * >(argp3);
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 (arg1)->DrawToDCClippedRgn(arg2,(wxRegion const &)*arg3);
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 resultobj = SWIG_Py_Void();
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 SWIGINTERN PyObject *_wrap_PseudoDC_DrawToDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28885 wxDC *arg2 = (wxDC *) 0 ;
28886 void *argp1 = 0 ;
28887 int res1 = 0 ;
28888 void *argp2 = 0 ;
28889 int res2 = 0 ;
28890 PyObject * obj0 = 0 ;
28891 PyObject * obj1 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "self",(char *) "dc", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawToDC",kwnames,&obj0,&obj1)) SWIG_fail;
28897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28898 if (!SWIG_IsOK(res1)) {
28899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawToDC" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28900 }
28901 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
28903 if (!SWIG_IsOK(res2)) {
28904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawToDC" "', expected argument " "2"" of type '" "wxDC *""'");
28905 }
28906 arg2 = reinterpret_cast< wxDC * >(argp2);
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 (arg1)->DrawToDC(arg2);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_Py_Void();
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28921 PyObject *resultobj = 0;
28922 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28923 int arg2 ;
28924 int arg3 ;
28925 wxColour *arg4 = 0 ;
28926 int arg5 = (int) wxFLOOD_SURFACE ;
28927 void *argp1 = 0 ;
28928 int res1 = 0 ;
28929 int val2 ;
28930 int ecode2 = 0 ;
28931 int val3 ;
28932 int ecode3 = 0 ;
28933 wxColour temp4 ;
28934 int val5 ;
28935 int ecode5 = 0 ;
28936 PyObject * obj0 = 0 ;
28937 PyObject * obj1 = 0 ;
28938 PyObject * obj2 = 0 ;
28939 PyObject * obj3 = 0 ;
28940 PyObject * obj4 = 0 ;
28941 char * kwnames[] = {
28942 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
28943 };
28944
28945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
28947 if (!SWIG_IsOK(res1)) {
28948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFill" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
28949 }
28950 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
28951 ecode2 = SWIG_AsVal_int(obj1, &val2);
28952 if (!SWIG_IsOK(ecode2)) {
28953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_FloodFill" "', expected argument " "2"" of type '" "int""'");
28954 }
28955 arg2 = static_cast< int >(val2);
28956 ecode3 = SWIG_AsVal_int(obj2, &val3);
28957 if (!SWIG_IsOK(ecode3)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_FloodFill" "', expected argument " "3"" of type '" "int""'");
28959 }
28960 arg3 = static_cast< int >(val3);
28961 {
28962 arg4 = &temp4;
28963 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
28964 }
28965 if (obj4) {
28966 ecode5 = SWIG_AsVal_int(obj4, &val5);
28967 if (!SWIG_IsOK(ecode5)) {
28968 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_FloodFill" "', expected argument " "5"" of type '" "int""'");
28969 }
28970 arg5 = static_cast< int >(val5);
28971 }
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 (arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_Py_Void();
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *_wrap_PseudoDC_FloodFillPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28986 PyObject *resultobj = 0;
28987 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
28988 wxPoint *arg2 = 0 ;
28989 wxColour *arg3 = 0 ;
28990 int arg4 = (int) wxFLOOD_SURFACE ;
28991 void *argp1 = 0 ;
28992 int res1 = 0 ;
28993 wxPoint temp2 ;
28994 wxColour temp3 ;
28995 int val4 ;
28996 int ecode4 = 0 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 PyObject * obj2 = 0 ;
29000 PyObject * obj3 = 0 ;
29001 char * kwnames[] = {
29002 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
29003 };
29004
29005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29007 if (!SWIG_IsOK(res1)) {
29008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29009 }
29010 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29011 {
29012 arg2 = &temp2;
29013 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29014 }
29015 {
29016 arg3 = &temp3;
29017 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
29018 }
29019 if (obj3) {
29020 ecode4 = SWIG_AsVal_int(obj3, &val4);
29021 if (!SWIG_IsOK(ecode4)) {
29022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_FloodFillPoint" "', expected argument " "4"" of type '" "int""'");
29023 }
29024 arg4 = static_cast< int >(val4);
29025 }
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 (arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_Py_Void();
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29040 PyObject *resultobj = 0;
29041 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29042 int arg2 ;
29043 int arg3 ;
29044 int arg4 ;
29045 int arg5 ;
29046 void *argp1 = 0 ;
29047 int res1 = 0 ;
29048 int val2 ;
29049 int ecode2 = 0 ;
29050 int val3 ;
29051 int ecode3 = 0 ;
29052 int val4 ;
29053 int ecode4 = 0 ;
29054 int val5 ;
29055 int ecode5 = 0 ;
29056 PyObject * obj0 = 0 ;
29057 PyObject * obj1 = 0 ;
29058 PyObject * obj2 = 0 ;
29059 PyObject * obj3 = 0 ;
29060 PyObject * obj4 = 0 ;
29061 char * kwnames[] = {
29062 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
29063 };
29064
29065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29067 if (!SWIG_IsOK(res1)) {
29068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLine" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29069 }
29070 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29071 ecode2 = SWIG_AsVal_int(obj1, &val2);
29072 if (!SWIG_IsOK(ecode2)) {
29073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawLine" "', expected argument " "2"" of type '" "int""'");
29074 }
29075 arg2 = static_cast< int >(val2);
29076 ecode3 = SWIG_AsVal_int(obj2, &val3);
29077 if (!SWIG_IsOK(ecode3)) {
29078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawLine" "', expected argument " "3"" of type '" "int""'");
29079 }
29080 arg3 = static_cast< int >(val3);
29081 ecode4 = SWIG_AsVal_int(obj3, &val4);
29082 if (!SWIG_IsOK(ecode4)) {
29083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLine" "', expected argument " "4"" of type '" "int""'");
29084 }
29085 arg4 = static_cast< int >(val4);
29086 ecode5 = SWIG_AsVal_int(obj4, &val5);
29087 if (!SWIG_IsOK(ecode5)) {
29088 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLine" "', expected argument " "5"" of type '" "int""'");
29089 }
29090 arg5 = static_cast< int >(val5);
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 resultobj = SWIG_Py_Void();
29098 return resultobj;
29099 fail:
29100 return NULL;
29101 }
29102
29103
29104 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLinePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29105 PyObject *resultobj = 0;
29106 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29107 wxPoint *arg2 = 0 ;
29108 wxPoint *arg3 = 0 ;
29109 void *argp1 = 0 ;
29110 int res1 = 0 ;
29111 wxPoint temp2 ;
29112 wxPoint temp3 ;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 PyObject * obj2 = 0 ;
29116 char * kwnames[] = {
29117 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
29118 };
29119
29120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29122 if (!SWIG_IsOK(res1)) {
29123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLinePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29124 }
29125 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29126 {
29127 arg2 = &temp2;
29128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29129 }
29130 {
29131 arg3 = &temp3;
29132 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29133 }
29134 {
29135 PyThreadState* __tstate = wxPyBeginAllowThreads();
29136 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
29137 wxPyEndAllowThreads(__tstate);
29138 if (PyErr_Occurred()) SWIG_fail;
29139 }
29140 resultobj = SWIG_Py_Void();
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHair(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj = 0;
29149 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29150 int arg2 ;
29151 int arg3 ;
29152 void *argp1 = 0 ;
29153 int res1 = 0 ;
29154 int val2 ;
29155 int ecode2 = 0 ;
29156 int val3 ;
29157 int ecode3 = 0 ;
29158 PyObject * obj0 = 0 ;
29159 PyObject * obj1 = 0 ;
29160 PyObject * obj2 = 0 ;
29161 char * kwnames[] = {
29162 (char *) "self",(char *) "x",(char *) "y", NULL
29163 };
29164
29165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_CrossHair",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHair" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29169 }
29170 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29171 ecode2 = SWIG_AsVal_int(obj1, &val2);
29172 if (!SWIG_IsOK(ecode2)) {
29173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_CrossHair" "', expected argument " "2"" of type '" "int""'");
29174 }
29175 arg2 = static_cast< int >(val2);
29176 ecode3 = SWIG_AsVal_int(obj2, &val3);
29177 if (!SWIG_IsOK(ecode3)) {
29178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_CrossHair" "', expected argument " "3"" of type '" "int""'");
29179 }
29180 arg3 = static_cast< int >(val3);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 (arg1)->CrossHair(arg2,arg3);
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_Py_Void();
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_PseudoDC_CrossHairPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj = 0;
29196 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29197 wxPoint *arg2 = 0 ;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 wxPoint temp2 ;
29201 PyObject * obj0 = 0 ;
29202 PyObject * obj1 = 0 ;
29203 char * kwnames[] = {
29204 (char *) "self",(char *) "pt", NULL
29205 };
29206
29207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_CrossHairPoint",kwnames,&obj0,&obj1)) SWIG_fail;
29208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29209 if (!SWIG_IsOK(res1)) {
29210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_CrossHairPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29211 }
29212 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29213 {
29214 arg2 = &temp2;
29215 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29216 }
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 (arg1)->CrossHair((wxPoint const &)*arg2);
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 resultobj = SWIG_Py_Void();
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj = 0;
29232 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29233 int arg2 ;
29234 int arg3 ;
29235 int arg4 ;
29236 int arg5 ;
29237 int arg6 ;
29238 int arg7 ;
29239 void *argp1 = 0 ;
29240 int res1 = 0 ;
29241 int val2 ;
29242 int ecode2 = 0 ;
29243 int val3 ;
29244 int ecode3 = 0 ;
29245 int val4 ;
29246 int ecode4 = 0 ;
29247 int val5 ;
29248 int ecode5 = 0 ;
29249 int val6 ;
29250 int ecode6 = 0 ;
29251 int val7 ;
29252 int ecode7 = 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 PyObject * obj2 = 0 ;
29256 PyObject * obj3 = 0 ;
29257 PyObject * obj4 = 0 ;
29258 PyObject * obj5 = 0 ;
29259 PyObject * obj6 = 0 ;
29260 char * kwnames[] = {
29261 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
29262 };
29263
29264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29266 if (!SWIG_IsOK(res1)) {
29267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29268 }
29269 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29270 ecode2 = SWIG_AsVal_int(obj1, &val2);
29271 if (!SWIG_IsOK(ecode2)) {
29272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawArc" "', expected argument " "2"" of type '" "int""'");
29273 }
29274 arg2 = static_cast< int >(val2);
29275 ecode3 = SWIG_AsVal_int(obj2, &val3);
29276 if (!SWIG_IsOK(ecode3)) {
29277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawArc" "', expected argument " "3"" of type '" "int""'");
29278 }
29279 arg3 = static_cast< int >(val3);
29280 ecode4 = SWIG_AsVal_int(obj3, &val4);
29281 if (!SWIG_IsOK(ecode4)) {
29282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawArc" "', expected argument " "4"" of type '" "int""'");
29283 }
29284 arg4 = static_cast< int >(val4);
29285 ecode5 = SWIG_AsVal_int(obj4, &val5);
29286 if (!SWIG_IsOK(ecode5)) {
29287 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawArc" "', expected argument " "5"" of type '" "int""'");
29288 }
29289 arg5 = static_cast< int >(val5);
29290 ecode6 = SWIG_AsVal_int(obj5, &val6);
29291 if (!SWIG_IsOK(ecode6)) {
29292 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawArc" "', expected argument " "6"" of type '" "int""'");
29293 }
29294 arg6 = static_cast< int >(val6);
29295 ecode7 = SWIG_AsVal_int(obj6, &val7);
29296 if (!SWIG_IsOK(ecode7)) {
29297 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawArc" "', expected argument " "7"" of type '" "int""'");
29298 }
29299 arg7 = static_cast< int >(val7);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_Py_Void();
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *_wrap_PseudoDC_DrawArcPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj = 0;
29315 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29316 wxPoint *arg2 = 0 ;
29317 wxPoint *arg3 = 0 ;
29318 wxPoint *arg4 = 0 ;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 wxPoint temp2 ;
29322 wxPoint temp3 ;
29323 wxPoint temp4 ;
29324 PyObject * obj0 = 0 ;
29325 PyObject * obj1 = 0 ;
29326 PyObject * obj2 = 0 ;
29327 PyObject * obj3 = 0 ;
29328 char * kwnames[] = {
29329 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
29330 };
29331
29332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawArcPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29336 }
29337 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29338 {
29339 arg2 = &temp2;
29340 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29341 }
29342 {
29343 arg3 = &temp3;
29344 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29345 }
29346 {
29347 arg4 = &temp4;
29348 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29349 }
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29366 int arg2 ;
29367 int arg3 ;
29368 int arg4 ;
29369 int arg5 ;
29370 void *argp1 = 0 ;
29371 int res1 = 0 ;
29372 int val2 ;
29373 int ecode2 = 0 ;
29374 int val3 ;
29375 int ecode3 = 0 ;
29376 int val4 ;
29377 int ecode4 = 0 ;
29378 int val5 ;
29379 int ecode5 = 0 ;
29380 PyObject * obj0 = 0 ;
29381 PyObject * obj1 = 0 ;
29382 PyObject * obj2 = 0 ;
29383 PyObject * obj3 = 0 ;
29384 PyObject * obj4 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29391 if (!SWIG_IsOK(res1)) {
29392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29393 }
29394 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29395 ecode2 = SWIG_AsVal_int(obj1, &val2);
29396 if (!SWIG_IsOK(ecode2)) {
29397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "2"" of type '" "int""'");
29398 }
29399 arg2 = static_cast< int >(val2);
29400 ecode3 = SWIG_AsVal_int(obj2, &val3);
29401 if (!SWIG_IsOK(ecode3)) {
29402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "3"" of type '" "int""'");
29403 }
29404 arg3 = static_cast< int >(val3);
29405 ecode4 = SWIG_AsVal_int(obj3, &val4);
29406 if (!SWIG_IsOK(ecode4)) {
29407 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "4"" of type '" "int""'");
29408 }
29409 arg4 = static_cast< int >(val4);
29410 ecode5 = SWIG_AsVal_int(obj4, &val5);
29411 if (!SWIG_IsOK(ecode5)) {
29412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawCheckMark" "', expected argument " "5"" of type '" "int""'");
29413 }
29414 arg5 = static_cast< int >(val5);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_Py_Void();
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCheckMarkRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29429 PyObject *resultobj = 0;
29430 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29431 wxRect *arg2 = 0 ;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 wxRect temp2 ;
29435 PyObject * obj0 = 0 ;
29436 PyObject * obj1 = 0 ;
29437 char * kwnames[] = {
29438 (char *) "self",(char *) "rect", NULL
29439 };
29440
29441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) SWIG_fail;
29442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCheckMarkRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29445 }
29446 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29447 {
29448 arg2 = &temp2;
29449 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 (arg1)->DrawCheckMark((wxRect const &)*arg2);
29454 wxPyEndAllowThreads(__tstate);
29455 if (PyErr_Occurred()) SWIG_fail;
29456 }
29457 resultobj = SWIG_Py_Void();
29458 return resultobj;
29459 fail:
29460 return NULL;
29461 }
29462
29463
29464 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29465 PyObject *resultobj = 0;
29466 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29467 int arg2 ;
29468 int arg3 ;
29469 int arg4 ;
29470 int arg5 ;
29471 double arg6 ;
29472 double arg7 ;
29473 void *argp1 = 0 ;
29474 int res1 = 0 ;
29475 int val2 ;
29476 int ecode2 = 0 ;
29477 int val3 ;
29478 int ecode3 = 0 ;
29479 int val4 ;
29480 int ecode4 = 0 ;
29481 int val5 ;
29482 int ecode5 = 0 ;
29483 double val6 ;
29484 int ecode6 = 0 ;
29485 double val7 ;
29486 int ecode7 = 0 ;
29487 PyObject * obj0 = 0 ;
29488 PyObject * obj1 = 0 ;
29489 PyObject * obj2 = 0 ;
29490 PyObject * obj3 = 0 ;
29491 PyObject * obj4 = 0 ;
29492 PyObject * obj5 = 0 ;
29493 PyObject * obj6 = 0 ;
29494 char * kwnames[] = {
29495 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
29496 };
29497
29498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:PseudoDC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29502 }
29503 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29504 ecode2 = SWIG_AsVal_int(obj1, &val2);
29505 if (!SWIG_IsOK(ecode2)) {
29506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "2"" of type '" "int""'");
29507 }
29508 arg2 = static_cast< int >(val2);
29509 ecode3 = SWIG_AsVal_int(obj2, &val3);
29510 if (!SWIG_IsOK(ecode3)) {
29511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "3"" of type '" "int""'");
29512 }
29513 arg3 = static_cast< int >(val3);
29514 ecode4 = SWIG_AsVal_int(obj3, &val4);
29515 if (!SWIG_IsOK(ecode4)) {
29516 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "4"" of type '" "int""'");
29517 }
29518 arg4 = static_cast< int >(val4);
29519 ecode5 = SWIG_AsVal_int(obj4, &val5);
29520 if (!SWIG_IsOK(ecode5)) {
29521 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "5"" of type '" "int""'");
29522 }
29523 arg5 = static_cast< int >(val5);
29524 ecode6 = SWIG_AsVal_double(obj5, &val6);
29525 if (!SWIG_IsOK(ecode6)) {
29526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "6"" of type '" "double""'");
29527 }
29528 arg6 = static_cast< double >(val6);
29529 ecode7 = SWIG_AsVal_double(obj6, &val7);
29530 if (!SWIG_IsOK(ecode7)) {
29531 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PseudoDC_DrawEllipticArc" "', expected argument " "7"" of type '" "double""'");
29532 }
29533 arg7 = static_cast< double >(val7);
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_Py_Void();
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipticArcPointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = 0;
29549 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29550 wxPoint *arg2 = 0 ;
29551 wxSize *arg3 = 0 ;
29552 double arg4 ;
29553 double arg5 ;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 wxPoint temp2 ;
29557 wxSize temp3 ;
29558 double val4 ;
29559 int ecode4 = 0 ;
29560 double val5 ;
29561 int ecode5 = 0 ;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 PyObject * obj2 = 0 ;
29565 PyObject * obj3 = 0 ;
29566 PyObject * obj4 = 0 ;
29567 char * kwnames[] = {
29568 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
29569 };
29570
29571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29573 if (!SWIG_IsOK(res1)) {
29574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29575 }
29576 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29577 {
29578 arg2 = &temp2;
29579 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29580 }
29581 {
29582 arg3 = &temp3;
29583 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29584 }
29585 ecode4 = SWIG_AsVal_double(obj3, &val4);
29586 if (!SWIG_IsOK(ecode4)) {
29587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "4"" of type '" "double""'");
29588 }
29589 arg4 = static_cast< double >(val4);
29590 ecode5 = SWIG_AsVal_double(obj4, &val5);
29591 if (!SWIG_IsOK(ecode5)) {
29592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipticArcPointSize" "', expected argument " "5"" of type '" "double""'");
29593 }
29594 arg5 = static_cast< double >(val5);
29595 {
29596 PyThreadState* __tstate = wxPyBeginAllowThreads();
29597 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
29598 wxPyEndAllowThreads(__tstate);
29599 if (PyErr_Occurred()) SWIG_fail;
29600 }
29601 resultobj = SWIG_Py_Void();
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj = 0;
29610 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29611 int arg2 ;
29612 int arg3 ;
29613 void *argp1 = 0 ;
29614 int res1 = 0 ;
29615 int val2 ;
29616 int ecode2 = 0 ;
29617 int val3 ;
29618 int ecode3 = 0 ;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 char * kwnames[] = {
29623 (char *) "self",(char *) "x",(char *) "y", NULL
29624 };
29625
29626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29628 if (!SWIG_IsOK(res1)) {
29629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29630 }
29631 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29632 ecode2 = SWIG_AsVal_int(obj1, &val2);
29633 if (!SWIG_IsOK(ecode2)) {
29634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawPoint" "', expected argument " "2"" of type '" "int""'");
29635 }
29636 arg2 = static_cast< int >(val2);
29637 ecode3 = SWIG_AsVal_int(obj2, &val3);
29638 if (!SWIG_IsOK(ecode3)) {
29639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawPoint" "', expected argument " "3"" of type '" "int""'");
29640 }
29641 arg3 = static_cast< int >(val3);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 (arg1)->DrawPoint(arg2,arg3);
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 resultobj = SWIG_Py_Void();
29649 return resultobj;
29650 fail:
29651 return NULL;
29652 }
29653
29654
29655 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPointPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29656 PyObject *resultobj = 0;
29657 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29658 wxPoint *arg2 = 0 ;
29659 void *argp1 = 0 ;
29660 int res1 = 0 ;
29661 wxPoint temp2 ;
29662 PyObject * obj0 = 0 ;
29663 PyObject * obj1 = 0 ;
29664 char * kwnames[] = {
29665 (char *) "self",(char *) "pt", NULL
29666 };
29667
29668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawPointPoint",kwnames,&obj0,&obj1)) SWIG_fail;
29669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29670 if (!SWIG_IsOK(res1)) {
29671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPointPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29672 }
29673 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29674 {
29675 arg2 = &temp2;
29676 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 (arg1)->DrawPoint((wxPoint const &)*arg2);
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 resultobj = SWIG_Py_Void();
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29692 PyObject *resultobj = 0;
29693 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29694 int arg2 ;
29695 int arg3 ;
29696 int arg4 ;
29697 int arg5 ;
29698 void *argp1 = 0 ;
29699 int res1 = 0 ;
29700 int val2 ;
29701 int ecode2 = 0 ;
29702 int val3 ;
29703 int ecode3 = 0 ;
29704 int val4 ;
29705 int ecode4 = 0 ;
29706 int val5 ;
29707 int ecode5 = 0 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 PyObject * obj2 = 0 ;
29711 PyObject * obj3 = 0 ;
29712 PyObject * obj4 = 0 ;
29713 char * kwnames[] = {
29714 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
29715 };
29716
29717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29719 if (!SWIG_IsOK(res1)) {
29720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29721 }
29722 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29723 ecode2 = SWIG_AsVal_int(obj1, &val2);
29724 if (!SWIG_IsOK(ecode2)) {
29725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "2"" of type '" "int""'");
29726 }
29727 arg2 = static_cast< int >(val2);
29728 ecode3 = SWIG_AsVal_int(obj2, &val3);
29729 if (!SWIG_IsOK(ecode3)) {
29730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "3"" of type '" "int""'");
29731 }
29732 arg3 = static_cast< int >(val3);
29733 ecode4 = SWIG_AsVal_int(obj3, &val4);
29734 if (!SWIG_IsOK(ecode4)) {
29735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "4"" of type '" "int""'");
29736 }
29737 arg4 = static_cast< int >(val4);
29738 ecode5 = SWIG_AsVal_int(obj4, &val5);
29739 if (!SWIG_IsOK(ecode5)) {
29740 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRectangle" "', expected argument " "5"" of type '" "int""'");
29741 }
29742 arg5 = static_cast< int >(val5);
29743 {
29744 PyThreadState* __tstate = wxPyBeginAllowThreads();
29745 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 resultobj = SWIG_Py_Void();
29750 return resultobj;
29751 fail:
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29757 PyObject *resultobj = 0;
29758 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29759 wxRect *arg2 = 0 ;
29760 void *argp1 = 0 ;
29761 int res1 = 0 ;
29762 wxRect temp2 ;
29763 PyObject * obj0 = 0 ;
29764 PyObject * obj1 = 0 ;
29765 char * kwnames[] = {
29766 (char *) "self",(char *) "rect", NULL
29767 };
29768
29769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawRectangleRect",kwnames,&obj0,&obj1)) SWIG_fail;
29770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29773 }
29774 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29775 {
29776 arg2 = &temp2;
29777 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29778 }
29779 {
29780 PyThreadState* __tstate = wxPyBeginAllowThreads();
29781 (arg1)->DrawRectangle((wxRect const &)*arg2);
29782 wxPyEndAllowThreads(__tstate);
29783 if (PyErr_Occurred()) SWIG_fail;
29784 }
29785 resultobj = SWIG_Py_Void();
29786 return resultobj;
29787 fail:
29788 return NULL;
29789 }
29790
29791
29792 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29793 PyObject *resultobj = 0;
29794 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29795 wxPoint *arg2 = 0 ;
29796 wxSize *arg3 = 0 ;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 wxPoint temp2 ;
29800 wxSize temp3 ;
29801 PyObject * obj0 = 0 ;
29802 PyObject * obj1 = 0 ;
29803 PyObject * obj2 = 0 ;
29804 char * kwnames[] = {
29805 (char *) "self",(char *) "pt",(char *) "sz", NULL
29806 };
29807
29808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29810 if (!SWIG_IsOK(res1)) {
29811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29812 }
29813 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29814 {
29815 arg2 = &temp2;
29816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29817 }
29818 {
29819 arg3 = &temp3;
29820 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29821 }
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_Py_Void();
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj = 0;
29837 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29838 int arg2 ;
29839 int arg3 ;
29840 int arg4 ;
29841 int arg5 ;
29842 double arg6 ;
29843 void *argp1 = 0 ;
29844 int res1 = 0 ;
29845 int val2 ;
29846 int ecode2 = 0 ;
29847 int val3 ;
29848 int ecode3 = 0 ;
29849 int val4 ;
29850 int ecode4 = 0 ;
29851 int val5 ;
29852 int ecode5 = 0 ;
29853 double val6 ;
29854 int ecode6 = 0 ;
29855 PyObject * obj0 = 0 ;
29856 PyObject * obj1 = 0 ;
29857 PyObject * obj2 = 0 ;
29858 PyObject * obj3 = 0 ;
29859 PyObject * obj4 = 0 ;
29860 PyObject * obj5 = 0 ;
29861 char * kwnames[] = {
29862 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
29863 };
29864
29865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:PseudoDC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29867 if (!SWIG_IsOK(res1)) {
29868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29869 }
29870 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29871 ecode2 = SWIG_AsVal_int(obj1, &val2);
29872 if (!SWIG_IsOK(ecode2)) {
29873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "2"" of type '" "int""'");
29874 }
29875 arg2 = static_cast< int >(val2);
29876 ecode3 = SWIG_AsVal_int(obj2, &val3);
29877 if (!SWIG_IsOK(ecode3)) {
29878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "3"" of type '" "int""'");
29879 }
29880 arg3 = static_cast< int >(val3);
29881 ecode4 = SWIG_AsVal_int(obj3, &val4);
29882 if (!SWIG_IsOK(ecode4)) {
29883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "4"" of type '" "int""'");
29884 }
29885 arg4 = static_cast< int >(val4);
29886 ecode5 = SWIG_AsVal_int(obj4, &val5);
29887 if (!SWIG_IsOK(ecode5)) {
29888 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "5"" of type '" "int""'");
29889 }
29890 arg5 = static_cast< int >(val5);
29891 ecode6 = SWIG_AsVal_double(obj5, &val6);
29892 if (!SWIG_IsOK(ecode6)) {
29893 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawRoundedRectangle" "', expected argument " "6"" of type '" "double""'");
29894 }
29895 arg6 = static_cast< double >(val6);
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_Py_Void();
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectangleRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj = 0;
29911 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29912 wxRect *arg2 = 0 ;
29913 double arg3 ;
29914 void *argp1 = 0 ;
29915 int res1 = 0 ;
29916 wxRect temp2 ;
29917 double val3 ;
29918 int ecode3 = 0 ;
29919 PyObject * obj0 = 0 ;
29920 PyObject * obj1 = 0 ;
29921 PyObject * obj2 = 0 ;
29922 char * kwnames[] = {
29923 (char *) "self",(char *) "r",(char *) "radius", NULL
29924 };
29925
29926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29928 if (!SWIG_IsOK(res1)) {
29929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29930 }
29931 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29932 {
29933 arg2 = &temp2;
29934 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29935 }
29936 ecode3 = SWIG_AsVal_double(obj2, &val3);
29937 if (!SWIG_IsOK(ecode3)) {
29938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRoundedRectangleRect" "', expected argument " "3"" of type '" "double""'");
29939 }
29940 arg3 = static_cast< double >(val3);
29941 {
29942 PyThreadState* __tstate = wxPyBeginAllowThreads();
29943 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_Py_Void();
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRoundedRectanglePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
29957 wxPoint *arg2 = 0 ;
29958 wxSize *arg3 = 0 ;
29959 double arg4 ;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 wxPoint temp2 ;
29963 wxSize temp3 ;
29964 double val4 ;
29965 int ecode4 = 0 ;
29966 PyObject * obj0 = 0 ;
29967 PyObject * obj1 = 0 ;
29968 PyObject * obj2 = 0 ;
29969 PyObject * obj3 = 0 ;
29970 char * kwnames[] = {
29971 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
29972 };
29973
29974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
29976 if (!SWIG_IsOK(res1)) {
29977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
29978 }
29979 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
29980 {
29981 arg2 = &temp2;
29982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29983 }
29984 {
29985 arg3 = &temp3;
29986 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
29987 }
29988 ecode4 = SWIG_AsVal_double(obj3, &val4);
29989 if (!SWIG_IsOK(ecode4)) {
29990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRoundedRectanglePointSize" "', expected argument " "4"" of type '" "double""'");
29991 }
29992 arg4 = static_cast< double >(val4);
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 resultobj = SWIG_Py_Void();
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30009 int arg2 ;
30010 int arg3 ;
30011 int arg4 ;
30012 void *argp1 = 0 ;
30013 int res1 = 0 ;
30014 int val2 ;
30015 int ecode2 = 0 ;
30016 int val3 ;
30017 int ecode3 = 0 ;
30018 int val4 ;
30019 int ecode4 = 0 ;
30020 PyObject * obj0 = 0 ;
30021 PyObject * obj1 = 0 ;
30022 PyObject * obj2 = 0 ;
30023 PyObject * obj3 = 0 ;
30024 char * kwnames[] = {
30025 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
30026 };
30027
30028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30030 if (!SWIG_IsOK(res1)) {
30031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCircle" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30032 }
30033 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30034 ecode2 = SWIG_AsVal_int(obj1, &val2);
30035 if (!SWIG_IsOK(ecode2)) {
30036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawCircle" "', expected argument " "2"" of type '" "int""'");
30037 }
30038 arg2 = static_cast< int >(val2);
30039 ecode3 = SWIG_AsVal_int(obj2, &val3);
30040 if (!SWIG_IsOK(ecode3)) {
30041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCircle" "', expected argument " "3"" of type '" "int""'");
30042 }
30043 arg3 = static_cast< int >(val3);
30044 ecode4 = SWIG_AsVal_int(obj3, &val4);
30045 if (!SWIG_IsOK(ecode4)) {
30046 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawCircle" "', expected argument " "4"" of type '" "int""'");
30047 }
30048 arg4 = static_cast< int >(val4);
30049 {
30050 PyThreadState* __tstate = wxPyBeginAllowThreads();
30051 (arg1)->DrawCircle(arg2,arg3,arg4);
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 resultobj = SWIG_Py_Void();
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_PseudoDC_DrawCirclePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj = 0;
30064 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30065 wxPoint *arg2 = 0 ;
30066 int arg3 ;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 wxPoint temp2 ;
30070 int val3 ;
30071 int ecode3 = 0 ;
30072 PyObject * obj0 = 0 ;
30073 PyObject * obj1 = 0 ;
30074 PyObject * obj2 = 0 ;
30075 char * kwnames[] = {
30076 (char *) "self",(char *) "pt",(char *) "radius", NULL
30077 };
30078
30079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30083 }
30084 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30085 {
30086 arg2 = &temp2;
30087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30088 }
30089 ecode3 = SWIG_AsVal_int(obj2, &val3);
30090 if (!SWIG_IsOK(ecode3)) {
30091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawCirclePoint" "', expected argument " "3"" of type '" "int""'");
30092 }
30093 arg3 = static_cast< int >(val3);
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 resultobj = SWIG_Py_Void();
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30108 PyObject *resultobj = 0;
30109 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30110 int arg2 ;
30111 int arg3 ;
30112 int arg4 ;
30113 int arg5 ;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 int val2 ;
30117 int ecode2 = 0 ;
30118 int val3 ;
30119 int ecode3 = 0 ;
30120 int val4 ;
30121 int ecode4 = 0 ;
30122 int val5 ;
30123 int ecode5 = 0 ;
30124 PyObject * obj0 = 0 ;
30125 PyObject * obj1 = 0 ;
30126 PyObject * obj2 = 0 ;
30127 PyObject * obj3 = 0 ;
30128 PyObject * obj4 = 0 ;
30129 char * kwnames[] = {
30130 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
30131 };
30132
30133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30135 if (!SWIG_IsOK(res1)) {
30136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30137 }
30138 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30139 ecode2 = SWIG_AsVal_int(obj1, &val2);
30140 if (!SWIG_IsOK(ecode2)) {
30141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "2"" of type '" "int""'");
30142 }
30143 arg2 = static_cast< int >(val2);
30144 ecode3 = SWIG_AsVal_int(obj2, &val3);
30145 if (!SWIG_IsOK(ecode3)) {
30146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "3"" of type '" "int""'");
30147 }
30148 arg3 = static_cast< int >(val3);
30149 ecode4 = SWIG_AsVal_int(obj3, &val4);
30150 if (!SWIG_IsOK(ecode4)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "4"" of type '" "int""'");
30152 }
30153 arg4 = static_cast< int >(val4);
30154 ecode5 = SWIG_AsVal_int(obj4, &val5);
30155 if (!SWIG_IsOK(ecode5)) {
30156 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawEllipse" "', expected argument " "5"" of type '" "int""'");
30157 }
30158 arg5 = static_cast< int >(val5);
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 resultobj = SWIG_Py_Void();
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipseRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30173 PyObject *resultobj = 0;
30174 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30175 wxRect *arg2 = 0 ;
30176 void *argp1 = 0 ;
30177 int res1 = 0 ;
30178 wxRect temp2 ;
30179 PyObject * obj0 = 0 ;
30180 PyObject * obj1 = 0 ;
30181 char * kwnames[] = {
30182 (char *) "self",(char *) "rect", NULL
30183 };
30184
30185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawEllipseRect",kwnames,&obj0,&obj1)) SWIG_fail;
30186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30187 if (!SWIG_IsOK(res1)) {
30188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipseRect" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30189 }
30190 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30191 {
30192 arg2 = &temp2;
30193 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30194 }
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 (arg1)->DrawEllipse((wxRect const &)*arg2);
30198 wxPyEndAllowThreads(__tstate);
30199 if (PyErr_Occurred()) SWIG_fail;
30200 }
30201 resultobj = SWIG_Py_Void();
30202 return resultobj;
30203 fail:
30204 return NULL;
30205 }
30206
30207
30208 SWIGINTERN PyObject *_wrap_PseudoDC_DrawEllipsePointSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj = 0;
30210 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30211 wxPoint *arg2 = 0 ;
30212 wxSize *arg3 = 0 ;
30213 void *argp1 = 0 ;
30214 int res1 = 0 ;
30215 wxPoint temp2 ;
30216 wxSize temp3 ;
30217 PyObject * obj0 = 0 ;
30218 PyObject * obj1 = 0 ;
30219 PyObject * obj2 = 0 ;
30220 char * kwnames[] = {
30221 (char *) "self",(char *) "pt",(char *) "sz", NULL
30222 };
30223
30224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30226 if (!SWIG_IsOK(res1)) {
30227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawEllipsePointSize" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30228 }
30229 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30230 {
30231 arg2 = &temp2;
30232 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30233 }
30234 {
30235 arg3 = &temp3;
30236 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
30237 }
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
30241 wxPyEndAllowThreads(__tstate);
30242 if (PyErr_Occurred()) SWIG_fail;
30243 }
30244 resultobj = SWIG_Py_Void();
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj = 0;
30253 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30254 wxIcon *arg2 = 0 ;
30255 int arg3 ;
30256 int arg4 ;
30257 void *argp1 = 0 ;
30258 int res1 = 0 ;
30259 void *argp2 = 0 ;
30260 int res2 = 0 ;
30261 int val3 ;
30262 int ecode3 = 0 ;
30263 int val4 ;
30264 int ecode4 = 0 ;
30265 PyObject * obj0 = 0 ;
30266 PyObject * obj1 = 0 ;
30267 PyObject * obj2 = 0 ;
30268 PyObject * obj3 = 0 ;
30269 char * kwnames[] = {
30270 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
30271 };
30272
30273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIcon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30277 }
30278 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
30280 if (!SWIG_IsOK(res2)) {
30281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
30282 }
30283 if (!argp2) {
30284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
30285 }
30286 arg2 = reinterpret_cast< wxIcon * >(argp2);
30287 ecode3 = SWIG_AsVal_int(obj2, &val3);
30288 if (!SWIG_IsOK(ecode3)) {
30289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawIcon" "', expected argument " "3"" of type '" "int""'");
30290 }
30291 arg3 = static_cast< int >(val3);
30292 ecode4 = SWIG_AsVal_int(obj3, &val4);
30293 if (!SWIG_IsOK(ecode4)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawIcon" "', expected argument " "4"" of type '" "int""'");
30295 }
30296 arg4 = static_cast< int >(val4);
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 resultobj = SWIG_Py_Void();
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 SWIGINTERN PyObject *_wrap_PseudoDC_DrawIconPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30311 PyObject *resultobj = 0;
30312 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30313 wxIcon *arg2 = 0 ;
30314 wxPoint *arg3 = 0 ;
30315 void *argp1 = 0 ;
30316 int res1 = 0 ;
30317 void *argp2 = 0 ;
30318 int res2 = 0 ;
30319 wxPoint temp3 ;
30320 PyObject * obj0 = 0 ;
30321 PyObject * obj1 = 0 ;
30322 PyObject * obj2 = 0 ;
30323 char * kwnames[] = {
30324 (char *) "self",(char *) "icon",(char *) "pt", NULL
30325 };
30326
30327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30329 if (!SWIG_IsOK(res1)) {
30330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30331 }
30332 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30333 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
30334 if (!SWIG_IsOK(res2)) {
30335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
30336 }
30337 if (!argp2) {
30338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawIconPoint" "', expected argument " "2"" of type '" "wxIcon const &""'");
30339 }
30340 arg2 = reinterpret_cast< wxIcon * >(argp2);
30341 {
30342 arg3 = &temp3;
30343 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30344 }
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
30348 wxPyEndAllowThreads(__tstate);
30349 if (PyErr_Occurred()) SWIG_fail;
30350 }
30351 resultobj = SWIG_Py_Void();
30352 return resultobj;
30353 fail:
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30359 PyObject *resultobj = 0;
30360 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30361 wxBitmap *arg2 = 0 ;
30362 int arg3 ;
30363 int arg4 ;
30364 bool arg5 = (bool) false ;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 void *argp2 = 0 ;
30368 int res2 = 0 ;
30369 int val3 ;
30370 int ecode3 = 0 ;
30371 int val4 ;
30372 int ecode4 = 0 ;
30373 bool val5 ;
30374 int ecode5 = 0 ;
30375 PyObject * obj0 = 0 ;
30376 PyObject * obj1 = 0 ;
30377 PyObject * obj2 = 0 ;
30378 PyObject * obj3 = 0 ;
30379 PyObject * obj4 = 0 ;
30380 char * kwnames[] = {
30381 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
30382 };
30383
30384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:PseudoDC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30388 }
30389 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30390 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
30391 if (!SWIG_IsOK(res2)) {
30392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
30393 }
30394 if (!argp2) {
30395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
30396 }
30397 arg2 = reinterpret_cast< wxBitmap * >(argp2);
30398 ecode3 = SWIG_AsVal_int(obj2, &val3);
30399 if (!SWIG_IsOK(ecode3)) {
30400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "3"" of type '" "int""'");
30401 }
30402 arg3 = static_cast< int >(val3);
30403 ecode4 = SWIG_AsVal_int(obj3, &val4);
30404 if (!SWIG_IsOK(ecode4)) {
30405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "4"" of type '" "int""'");
30406 }
30407 arg4 = static_cast< int >(val4);
30408 if (obj4) {
30409 ecode5 = SWIG_AsVal_bool(obj4, &val5);
30410 if (!SWIG_IsOK(ecode5)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawBitmap" "', expected argument " "5"" of type '" "bool""'");
30412 }
30413 arg5 = static_cast< bool >(val5);
30414 }
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 resultobj = SWIG_Py_Void();
30422 return resultobj;
30423 fail:
30424 return NULL;
30425 }
30426
30427
30428 SWIGINTERN PyObject *_wrap_PseudoDC_DrawBitmapPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30429 PyObject *resultobj = 0;
30430 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30431 wxBitmap *arg2 = 0 ;
30432 wxPoint *arg3 = 0 ;
30433 bool arg4 = (bool) false ;
30434 void *argp1 = 0 ;
30435 int res1 = 0 ;
30436 void *argp2 = 0 ;
30437 int res2 = 0 ;
30438 wxPoint temp3 ;
30439 bool val4 ;
30440 int ecode4 = 0 ;
30441 PyObject * obj0 = 0 ;
30442 PyObject * obj1 = 0 ;
30443 PyObject * obj2 = 0 ;
30444 PyObject * obj3 = 0 ;
30445 char * kwnames[] = {
30446 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
30447 };
30448
30449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PseudoDC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30451 if (!SWIG_IsOK(res1)) {
30452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30453 }
30454 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
30456 if (!SWIG_IsOK(res2)) {
30457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
30458 }
30459 if (!argp2) {
30460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "2"" of type '" "wxBitmap const &""'");
30461 }
30462 arg2 = reinterpret_cast< wxBitmap * >(argp2);
30463 {
30464 arg3 = &temp3;
30465 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30466 }
30467 if (obj3) {
30468 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30469 if (!SWIG_IsOK(ecode4)) {
30470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawBitmapPoint" "', expected argument " "4"" of type '" "bool""'");
30471 }
30472 arg4 = static_cast< bool >(val4);
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
30477 wxPyEndAllowThreads(__tstate);
30478 if (PyErr_Occurred()) SWIG_fail;
30479 }
30480 resultobj = SWIG_Py_Void();
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_PseudoDC_DrawText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30490 wxString *arg2 = 0 ;
30491 int arg3 ;
30492 int arg4 ;
30493 void *argp1 = 0 ;
30494 int res1 = 0 ;
30495 bool temp2 = false ;
30496 int val3 ;
30497 int ecode3 = 0 ;
30498 int val4 ;
30499 int ecode4 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 PyObject * obj2 = 0 ;
30503 PyObject * obj3 = 0 ;
30504 char * kwnames[] = {
30505 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
30506 };
30507
30508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30510 if (!SWIG_IsOK(res1)) {
30511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30512 }
30513 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30514 {
30515 arg2 = wxString_in_helper(obj1);
30516 if (arg2 == NULL) SWIG_fail;
30517 temp2 = true;
30518 }
30519 ecode3 = SWIG_AsVal_int(obj2, &val3);
30520 if (!SWIG_IsOK(ecode3)) {
30521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawText" "', expected argument " "3"" of type '" "int""'");
30522 }
30523 arg3 = static_cast< int >(val3);
30524 ecode4 = SWIG_AsVal_int(obj3, &val4);
30525 if (!SWIG_IsOK(ecode4)) {
30526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawText" "', expected argument " "4"" of type '" "int""'");
30527 }
30528 arg4 = static_cast< int >(val4);
30529 {
30530 PyThreadState* __tstate = wxPyBeginAllowThreads();
30531 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
30532 wxPyEndAllowThreads(__tstate);
30533 if (PyErr_Occurred()) SWIG_fail;
30534 }
30535 resultobj = SWIG_Py_Void();
30536 {
30537 if (temp2)
30538 delete arg2;
30539 }
30540 return resultobj;
30541 fail:
30542 {
30543 if (temp2)
30544 delete arg2;
30545 }
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_PseudoDC_DrawTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj = 0;
30552 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30553 wxString *arg2 = 0 ;
30554 wxPoint *arg3 = 0 ;
30555 void *argp1 = 0 ;
30556 int res1 = 0 ;
30557 bool temp2 = false ;
30558 wxPoint temp3 ;
30559 PyObject * obj0 = 0 ;
30560 PyObject * obj1 = 0 ;
30561 PyObject * obj2 = 0 ;
30562 char * kwnames[] = {
30563 (char *) "self",(char *) "text",(char *) "pt", NULL
30564 };
30565
30566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PseudoDC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30568 if (!SWIG_IsOK(res1)) {
30569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30570 }
30571 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30572 {
30573 arg2 = wxString_in_helper(obj1);
30574 if (arg2 == NULL) SWIG_fail;
30575 temp2 = true;
30576 }
30577 {
30578 arg3 = &temp3;
30579 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 resultobj = SWIG_Py_Void();
30588 {
30589 if (temp2)
30590 delete arg2;
30591 }
30592 return resultobj;
30593 fail:
30594 {
30595 if (temp2)
30596 delete arg2;
30597 }
30598 return NULL;
30599 }
30600
30601
30602 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj = 0;
30604 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30605 wxString *arg2 = 0 ;
30606 int arg3 ;
30607 int arg4 ;
30608 double arg5 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 bool temp2 = false ;
30612 int val3 ;
30613 int ecode3 = 0 ;
30614 int val4 ;
30615 int ecode4 = 0 ;
30616 double val5 ;
30617 int ecode5 = 0 ;
30618 PyObject * obj0 = 0 ;
30619 PyObject * obj1 = 0 ;
30620 PyObject * obj2 = 0 ;
30621 PyObject * obj3 = 0 ;
30622 PyObject * obj4 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:PseudoDC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30631 }
30632 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30633 {
30634 arg2 = wxString_in_helper(obj1);
30635 if (arg2 == NULL) SWIG_fail;
30636 temp2 = true;
30637 }
30638 ecode3 = SWIG_AsVal_int(obj2, &val3);
30639 if (!SWIG_IsOK(ecode3)) {
30640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "3"" of type '" "int""'");
30641 }
30642 arg3 = static_cast< int >(val3);
30643 ecode4 = SWIG_AsVal_int(obj3, &val4);
30644 if (!SWIG_IsOK(ecode4)) {
30645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "4"" of type '" "int""'");
30646 }
30647 arg4 = static_cast< int >(val4);
30648 ecode5 = SWIG_AsVal_double(obj4, &val5);
30649 if (!SWIG_IsOK(ecode5)) {
30650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawRotatedText" "', expected argument " "5"" of type '" "double""'");
30651 }
30652 arg5 = static_cast< double >(val5);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 resultobj = SWIG_Py_Void();
30660 {
30661 if (temp2)
30662 delete arg2;
30663 }
30664 return resultobj;
30665 fail:
30666 {
30667 if (temp2)
30668 delete arg2;
30669 }
30670 return NULL;
30671 }
30672
30673
30674 SWIGINTERN PyObject *_wrap_PseudoDC_DrawRotatedTextPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj = 0;
30676 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30677 wxString *arg2 = 0 ;
30678 wxPoint *arg3 = 0 ;
30679 double arg4 ;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 bool temp2 = false ;
30683 wxPoint temp3 ;
30684 double val4 ;
30685 int ecode4 = 0 ;
30686 PyObject * obj0 = 0 ;
30687 PyObject * obj1 = 0 ;
30688 PyObject * obj2 = 0 ;
30689 PyObject * obj3 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PseudoDC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30698 }
30699 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30700 {
30701 arg2 = wxString_in_helper(obj1);
30702 if (arg2 == NULL) SWIG_fail;
30703 temp2 = true;
30704 }
30705 {
30706 arg3 = &temp3;
30707 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30708 }
30709 ecode4 = SWIG_AsVal_double(obj3, &val4);
30710 if (!SWIG_IsOK(ecode4)) {
30711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawRotatedTextPoint" "', expected argument " "4"" of type '" "double""'");
30712 }
30713 arg4 = static_cast< double >(val4);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_Py_Void();
30721 {
30722 if (temp2)
30723 delete arg2;
30724 }
30725 return resultobj;
30726 fail:
30727 {
30728 if (temp2)
30729 delete arg2;
30730 }
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30736 PyObject *resultobj = 0;
30737 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30738 int arg2 ;
30739 wxPoint *arg3 = (wxPoint *) 0 ;
30740 int arg4 = (int) 0 ;
30741 int arg5 = (int) 0 ;
30742 void *argp1 = 0 ;
30743 int res1 = 0 ;
30744 int val4 ;
30745 int ecode4 = 0 ;
30746 int val5 ;
30747 int ecode5 = 0 ;
30748 PyObject * obj0 = 0 ;
30749 PyObject * obj1 = 0 ;
30750 PyObject * obj2 = 0 ;
30751 PyObject * obj3 = 0 ;
30752 char * kwnames[] = {
30753 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
30754 };
30755
30756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:PseudoDC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30758 if (!SWIG_IsOK(res1)) {
30759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLines" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30760 }
30761 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30762 {
30763 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30764 if (arg3 == NULL) SWIG_fail;
30765 }
30766 if (obj2) {
30767 ecode4 = SWIG_AsVal_int(obj2, &val4);
30768 if (!SWIG_IsOK(ecode4)) {
30769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLines" "', expected argument " "4"" of type '" "int""'");
30770 }
30771 arg4 = static_cast< int >(val4);
30772 }
30773 if (obj3) {
30774 ecode5 = SWIG_AsVal_int(obj3, &val5);
30775 if (!SWIG_IsOK(ecode5)) {
30776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLines" "', expected argument " "5"" of type '" "int""'");
30777 }
30778 arg5 = static_cast< int >(val5);
30779 }
30780 {
30781 PyThreadState* __tstate = wxPyBeginAllowThreads();
30782 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
30783 wxPyEndAllowThreads(__tstate);
30784 if (PyErr_Occurred()) SWIG_fail;
30785 }
30786 resultobj = SWIG_Py_Void();
30787 {
30788 if (arg3) delete [] arg3;
30789 }
30790 return resultobj;
30791 fail:
30792 {
30793 if (arg3) delete [] arg3;
30794 }
30795 return NULL;
30796 }
30797
30798
30799 SWIGINTERN PyObject *_wrap_PseudoDC_DrawPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj = 0;
30801 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30802 int arg2 ;
30803 wxPoint *arg3 = (wxPoint *) 0 ;
30804 int arg4 = (int) 0 ;
30805 int arg5 = (int) 0 ;
30806 int arg6 = (int) wxODDEVEN_RULE ;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 int val4 ;
30810 int ecode4 = 0 ;
30811 int val5 ;
30812 int ecode5 = 0 ;
30813 int val6 ;
30814 int ecode6 = 0 ;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 PyObject * obj2 = 0 ;
30818 PyObject * obj3 = 0 ;
30819 PyObject * obj4 = 0 ;
30820 char * kwnames[] = {
30821 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
30822 };
30823
30824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:PseudoDC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30828 }
30829 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30830 {
30831 arg3 = wxPoint_LIST_helper(obj1, &arg2);
30832 if (arg3 == NULL) SWIG_fail;
30833 }
30834 if (obj2) {
30835 ecode4 = SWIG_AsVal_int(obj2, &val4);
30836 if (!SWIG_IsOK(ecode4)) {
30837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "4"" of type '" "int""'");
30838 }
30839 arg4 = static_cast< int >(val4);
30840 }
30841 if (obj3) {
30842 ecode5 = SWIG_AsVal_int(obj3, &val5);
30843 if (!SWIG_IsOK(ecode5)) {
30844 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "5"" of type '" "int""'");
30845 }
30846 arg5 = static_cast< int >(val5);
30847 }
30848 if (obj4) {
30849 ecode6 = SWIG_AsVal_int(obj4, &val6);
30850 if (!SWIG_IsOK(ecode6)) {
30851 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawPolygon" "', expected argument " "6"" of type '" "int""'");
30852 }
30853 arg6 = static_cast< int >(val6);
30854 }
30855 {
30856 PyThreadState* __tstate = wxPyBeginAllowThreads();
30857 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 resultobj = SWIG_Py_Void();
30862 {
30863 if (arg3) delete [] arg3;
30864 }
30865 return resultobj;
30866 fail:
30867 {
30868 if (arg3) delete [] arg3;
30869 }
30870 return NULL;
30871 }
30872
30873
30874 SWIGINTERN PyObject *_wrap_PseudoDC_DrawLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj = 0;
30876 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30877 wxString *arg2 = 0 ;
30878 wxRect *arg3 = 0 ;
30879 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
30880 int arg5 = (int) -1 ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 bool temp2 = false ;
30884 wxRect temp3 ;
30885 int val4 ;
30886 int ecode4 = 0 ;
30887 int val5 ;
30888 int ecode5 = 0 ;
30889 PyObject * obj0 = 0 ;
30890 PyObject * obj1 = 0 ;
30891 PyObject * obj2 = 0 ;
30892 PyObject * obj3 = 0 ;
30893 PyObject * obj4 = 0 ;
30894 char * kwnames[] = {
30895 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
30896 };
30897
30898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:PseudoDC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30900 if (!SWIG_IsOK(res1)) {
30901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30902 }
30903 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30904 {
30905 arg2 = wxString_in_helper(obj1);
30906 if (arg2 == NULL) SWIG_fail;
30907 temp2 = true;
30908 }
30909 {
30910 arg3 = &temp3;
30911 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
30912 }
30913 if (obj3) {
30914 ecode4 = SWIG_AsVal_int(obj3, &val4);
30915 if (!SWIG_IsOK(ecode4)) {
30916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PseudoDC_DrawLabel" "', expected argument " "4"" of type '" "int""'");
30917 }
30918 arg4 = static_cast< int >(val4);
30919 }
30920 if (obj4) {
30921 ecode5 = SWIG_AsVal_int(obj4, &val5);
30922 if (!SWIG_IsOK(ecode5)) {
30923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawLabel" "', expected argument " "5"" of type '" "int""'");
30924 }
30925 arg5 = static_cast< int >(val5);
30926 }
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 {
30935 if (temp2)
30936 delete arg2;
30937 }
30938 return resultobj;
30939 fail:
30940 {
30941 if (temp2)
30942 delete arg2;
30943 }
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_PseudoDC_DrawImageLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
30951 wxString *arg2 = 0 ;
30952 wxBitmap *arg3 = 0 ;
30953 wxRect *arg4 = 0 ;
30954 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
30955 int arg6 = (int) -1 ;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 bool temp2 = false ;
30959 void *argp3 = 0 ;
30960 int res3 = 0 ;
30961 wxRect temp4 ;
30962 int val5 ;
30963 int ecode5 = 0 ;
30964 int val6 ;
30965 int ecode6 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 PyObject * obj2 = 0 ;
30969 PyObject * obj3 = 0 ;
30970 PyObject * obj4 = 0 ;
30971 PyObject * obj5 = 0 ;
30972 char * kwnames[] = {
30973 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
30974 };
30975
30976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:PseudoDC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
30978 if (!SWIG_IsOK(res1)) {
30979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
30980 }
30981 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
30982 {
30983 arg2 = wxString_in_helper(obj1);
30984 if (arg2 == NULL) SWIG_fail;
30985 temp2 = true;
30986 }
30987 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
30988 if (!SWIG_IsOK(res3)) {
30989 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30990 }
30991 if (!argp3) {
30992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "3"" of type '" "wxBitmap const &""'");
30993 }
30994 arg3 = reinterpret_cast< wxBitmap * >(argp3);
30995 {
30996 arg4 = &temp4;
30997 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
30998 }
30999 if (obj4) {
31000 ecode5 = SWIG_AsVal_int(obj4, &val5);
31001 if (!SWIG_IsOK(ecode5)) {
31002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "5"" of type '" "int""'");
31003 }
31004 arg5 = static_cast< int >(val5);
31005 }
31006 if (obj5) {
31007 ecode6 = SWIG_AsVal_int(obj5, &val6);
31008 if (!SWIG_IsOK(ecode6)) {
31009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PseudoDC_DrawImageLabel" "', expected argument " "6"" of type '" "int""'");
31010 }
31011 arg6 = static_cast< int >(val6);
31012 }
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 (arg1)->DrawLabel((wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_Py_Void();
31020 {
31021 if (temp2)
31022 delete arg2;
31023 }
31024 return resultobj;
31025 fail:
31026 {
31027 if (temp2)
31028 delete arg2;
31029 }
31030 return NULL;
31031 }
31032
31033
31034 SWIGINTERN PyObject *_wrap_PseudoDC_DrawSpline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj = 0;
31036 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31037 int arg2 ;
31038 wxPoint *arg3 = (wxPoint *) 0 ;
31039 void *argp1 = 0 ;
31040 int res1 = 0 ;
31041 PyObject * obj0 = 0 ;
31042 PyObject * obj1 = 0 ;
31043 char * kwnames[] = {
31044 (char *) "self",(char *) "points", NULL
31045 };
31046
31047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_DrawSpline",kwnames,&obj0,&obj1)) SWIG_fail;
31048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31049 if (!SWIG_IsOK(res1)) {
31050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_DrawSpline" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31051 }
31052 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31053 {
31054 arg3 = wxPoint_LIST_helper(obj1, &arg2);
31055 if (arg3 == NULL) SWIG_fail;
31056 }
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 (arg1)->DrawSpline(arg2,arg3);
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_Py_Void();
31064 {
31065 if (arg3) delete [] arg3;
31066 }
31067 return resultobj;
31068 fail:
31069 {
31070 if (arg3) delete [] arg3;
31071 }
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_PseudoDC_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_Clear" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31088 }
31089 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 (arg1)->Clear();
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_PseudoDC_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj = 0;
31105 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31106 wxFont *arg2 = 0 ;
31107 void *argp1 = 0 ;
31108 int res1 = 0 ;
31109 void *argp2 = 0 ;
31110 int res2 = 0 ;
31111 PyObject * obj0 = 0 ;
31112 PyObject * obj1 = 0 ;
31113 char * kwnames[] = {
31114 (char *) "self",(char *) "font", NULL
31115 };
31116
31117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
31118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31119 if (!SWIG_IsOK(res1)) {
31120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetFont" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31121 }
31122 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
31124 if (!SWIG_IsOK(res2)) {
31125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
31126 }
31127 if (!argp2) {
31128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
31129 }
31130 arg2 = reinterpret_cast< wxFont * >(argp2);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 (arg1)->SetFont((wxFont const &)*arg2);
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_Py_Void();
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_PseudoDC_SetPen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31145 PyObject *resultobj = 0;
31146 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31147 wxPen *arg2 = 0 ;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 void *argp2 = 0 ;
31151 int res2 = 0 ;
31152 PyObject * obj0 = 0 ;
31153 PyObject * obj1 = 0 ;
31154 char * kwnames[] = {
31155 (char *) "self",(char *) "pen", NULL
31156 };
31157
31158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPen",kwnames,&obj0,&obj1)) SWIG_fail;
31159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31160 if (!SWIG_IsOK(res1)) {
31161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPen" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31162 }
31163 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31164 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPen, 0 | 0);
31165 if (!SWIG_IsOK(res2)) {
31166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
31167 }
31168 if (!argp2) {
31169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPen" "', expected argument " "2"" of type '" "wxPen const &""'");
31170 }
31171 arg2 = reinterpret_cast< wxPen * >(argp2);
31172 {
31173 PyThreadState* __tstate = wxPyBeginAllowThreads();
31174 (arg1)->SetPen((wxPen const &)*arg2);
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 resultobj = SWIG_Py_Void();
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 SWIGINTERN PyObject *_wrap_PseudoDC_SetBrush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj = 0;
31187 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31188 wxBrush *arg2 = 0 ;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 void *argp2 = 0 ;
31192 int res2 = 0 ;
31193 PyObject * obj0 = 0 ;
31194 PyObject * obj1 = 0 ;
31195 char * kwnames[] = {
31196 (char *) "self",(char *) "brush", NULL
31197 };
31198
31199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBrush",kwnames,&obj0,&obj1)) SWIG_fail;
31200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31201 if (!SWIG_IsOK(res1)) {
31202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBrush" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31203 }
31204 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
31206 if (!SWIG_IsOK(res2)) {
31207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
31208 }
31209 if (!argp2) {
31210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBrush" "', expected argument " "2"" of type '" "wxBrush const &""'");
31211 }
31212 arg2 = reinterpret_cast< wxBrush * >(argp2);
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 (arg1)->SetBrush((wxBrush const &)*arg2);
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 resultobj = SWIG_Py_Void();
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31227 PyObject *resultobj = 0;
31228 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31229 wxBrush *arg2 = 0 ;
31230 void *argp1 = 0 ;
31231 int res1 = 0 ;
31232 void *argp2 = 0 ;
31233 int res2 = 0 ;
31234 PyObject * obj0 = 0 ;
31235 PyObject * obj1 = 0 ;
31236 char * kwnames[] = {
31237 (char *) "self",(char *) "brush", NULL
31238 };
31239
31240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackground",kwnames,&obj0,&obj1)) SWIG_fail;
31241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31242 if (!SWIG_IsOK(res1)) {
31243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31244 }
31245 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBrush, 0 | 0);
31247 if (!SWIG_IsOK(res2)) {
31248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
31249 }
31250 if (!argp2) {
31251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetBackground" "', expected argument " "2"" of type '" "wxBrush const &""'");
31252 }
31253 arg2 = reinterpret_cast< wxBrush * >(argp2);
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 (arg1)->SetBackground((wxBrush const &)*arg2);
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_Py_Void();
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_PseudoDC_SetBackgroundMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31268 PyObject *resultobj = 0;
31269 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31270 int arg2 ;
31271 void *argp1 = 0 ;
31272 int res1 = 0 ;
31273 int val2 ;
31274 int ecode2 = 0 ;
31275 PyObject * obj0 = 0 ;
31276 PyObject * obj1 = 0 ;
31277 char * kwnames[] = {
31278 (char *) "self",(char *) "mode", NULL
31279 };
31280
31281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetBackgroundMode",kwnames,&obj0,&obj1)) SWIG_fail;
31282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31283 if (!SWIG_IsOK(res1)) {
31284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31285 }
31286 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31287 ecode2 = SWIG_AsVal_int(obj1, &val2);
31288 if (!SWIG_IsOK(ecode2)) {
31289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetBackgroundMode" "', expected argument " "2"" of type '" "int""'");
31290 }
31291 arg2 = static_cast< int >(val2);
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 (arg1)->SetBackgroundMode(arg2);
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_Py_Void();
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_PseudoDC_SetPalette(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj = 0;
31307 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31308 wxPalette *arg2 = 0 ;
31309 void *argp1 = 0 ;
31310 int res1 = 0 ;
31311 void *argp2 = 0 ;
31312 int res2 = 0 ;
31313 PyObject * obj0 = 0 ;
31314 PyObject * obj1 = 0 ;
31315 char * kwnames[] = {
31316 (char *) "self",(char *) "palette", NULL
31317 };
31318
31319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetPalette",kwnames,&obj0,&obj1)) SWIG_fail;
31320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31321 if (!SWIG_IsOK(res1)) {
31322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetPalette" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31323 }
31324 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPalette, 0 | 0);
31326 if (!SWIG_IsOK(res2)) {
31327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
31328 }
31329 if (!argp2) {
31330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PseudoDC_SetPalette" "', expected argument " "2"" of type '" "wxPalette const &""'");
31331 }
31332 arg2 = reinterpret_cast< wxPalette * >(argp2);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 (arg1)->SetPalette((wxPalette const &)*arg2);
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_Py_Void();
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31349 wxColour *arg2 = 0 ;
31350 void *argp1 = 0 ;
31351 int res1 = 0 ;
31352 wxColour temp2 ;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "colour", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextForeground",kwnames,&obj0,&obj1)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextForeground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31363 }
31364 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31365 {
31366 arg2 = &temp2;
31367 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
31368 }
31369 {
31370 PyThreadState* __tstate = wxPyBeginAllowThreads();
31371 (arg1)->SetTextForeground((wxColour const &)*arg2);
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 resultobj = SWIG_Py_Void();
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 SWIGINTERN PyObject *_wrap_PseudoDC_SetTextBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj = 0;
31384 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31385 wxColour *arg2 = 0 ;
31386 void *argp1 = 0 ;
31387 int res1 = 0 ;
31388 wxColour temp2 ;
31389 PyObject * obj0 = 0 ;
31390 PyObject * obj1 = 0 ;
31391 char * kwnames[] = {
31392 (char *) "self",(char *) "colour", NULL
31393 };
31394
31395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetTextBackground",kwnames,&obj0,&obj1)) SWIG_fail;
31396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31397 if (!SWIG_IsOK(res1)) {
31398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetTextBackground" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31399 }
31400 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31401 {
31402 arg2 = &temp2;
31403 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
31404 }
31405 {
31406 PyThreadState* __tstate = wxPyBeginAllowThreads();
31407 (arg1)->SetTextBackground((wxColour const &)*arg2);
31408 wxPyEndAllowThreads(__tstate);
31409 if (PyErr_Occurred()) SWIG_fail;
31410 }
31411 resultobj = SWIG_Py_Void();
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 SWIGINTERN PyObject *_wrap_PseudoDC_SetLogicalFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj = 0;
31420 wxPseudoDC *arg1 = (wxPseudoDC *) 0 ;
31421 int arg2 ;
31422 void *argp1 = 0 ;
31423 int res1 = 0 ;
31424 int val2 ;
31425 int ecode2 = 0 ;
31426 PyObject * obj0 = 0 ;
31427 PyObject * obj1 = 0 ;
31428 char * kwnames[] = {
31429 (char *) "self",(char *) "function", NULL
31430 };
31431
31432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PseudoDC_SetLogicalFunction",kwnames,&obj0,&obj1)) SWIG_fail;
31433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPseudoDC, 0 | 0 );
31434 if (!SWIG_IsOK(res1)) {
31435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "1"" of type '" "wxPseudoDC *""'");
31436 }
31437 arg1 = reinterpret_cast< wxPseudoDC * >(argp1);
31438 ecode2 = SWIG_AsVal_int(obj1, &val2);
31439 if (!SWIG_IsOK(ecode2)) {
31440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PseudoDC_SetLogicalFunction" "', expected argument " "2"" of type '" "int""'");
31441 }
31442 arg2 = static_cast< int >(val2);
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 (arg1)->SetLogicalFunction(arg2);
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_Py_Void();
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *PseudoDC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31457 PyObject *obj;
31458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31459 SWIG_TypeNewClientData(SWIGTYPE_p_wxPseudoDC, SWIG_NewClientData(obj));
31460 return SWIG_Py_Void();
31461 }
31462
31463 SWIGINTERN PyObject *PseudoDC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 return SWIG_Python_InitShadowInstance(args);
31465 }
31466
31467 static PyMethodDef SwigMethods[] = {
31468 { (char *)"new_GDIObject", (PyCFunction)_wrap_new_GDIObject, METH_NOARGS, NULL},
31469 { (char *)"delete_GDIObject", (PyCFunction)_wrap_delete_GDIObject, METH_O, NULL},
31470 { (char *)"GDIObject_IsNull", (PyCFunction)_wrap_GDIObject_IsNull, METH_O, NULL},
31471 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
31472 { (char *)"GDIObject_swiginit", GDIObject_swiginit, METH_VARARGS, NULL},
31473 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"delete_Colour", (PyCFunction)_wrap_delete_Colour, METH_O, NULL},
31477 { (char *)"Colour_Red", (PyCFunction)_wrap_Colour_Red, METH_O, NULL},
31478 { (char *)"Colour_Green", (PyCFunction)_wrap_Colour_Green, METH_O, NULL},
31479 { (char *)"Colour_Blue", (PyCFunction)_wrap_Colour_Blue, METH_O, NULL},
31480 { (char *)"Colour_Alpha", (PyCFunction)_wrap_Colour_Alpha, METH_O, NULL},
31481 { (char *)"Colour_Ok", (PyCFunction)_wrap_Colour_Ok, METH_O, NULL},
31482 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Colour_GetAsString", (PyCFunction) _wrap_Colour_GetAsString, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Colour_GetPixel", (PyCFunction)_wrap_Colour_GetPixel, METH_O, NULL},
31487 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Colour_GetRGB", (PyCFunction)_wrap_Colour_GetRGB, METH_O, NULL},
31491 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
31492 { (char *)"Colour_swiginit", Colour_swiginit, METH_VARARGS, NULL},
31493 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"delete_Palette", (PyCFunction)_wrap_delete_Palette, METH_O, NULL},
31495 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"Palette_GetColoursCount", (PyCFunction)_wrap_Palette_GetColoursCount, METH_O, NULL},
31498 { (char *)"Palette_Ok", (PyCFunction)_wrap_Palette_Ok, METH_O, NULL},
31499 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
31500 { (char *)"Palette_swiginit", Palette_swiginit, METH_VARARGS, NULL},
31501 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"delete_Pen", (PyCFunction)_wrap_delete_Pen, METH_O, NULL},
31503 { (char *)"Pen_GetCap", (PyCFunction)_wrap_Pen_GetCap, METH_O, NULL},
31504 { (char *)"Pen_GetColour", (PyCFunction)_wrap_Pen_GetColour, METH_O, NULL},
31505 { (char *)"Pen_GetJoin", (PyCFunction)_wrap_Pen_GetJoin, METH_O, NULL},
31506 { (char *)"Pen_GetStyle", (PyCFunction)_wrap_Pen_GetStyle, METH_O, NULL},
31507 { (char *)"Pen_GetWidth", (PyCFunction)_wrap_Pen_GetWidth, METH_O, NULL},
31508 { (char *)"Pen_Ok", (PyCFunction)_wrap_Pen_Ok, METH_O, NULL},
31509 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Pen_GetDashes", (PyCFunction)_wrap_Pen_GetDashes, METH_O, NULL},
31516 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Pen_GetDashCount", (PyCFunction)_wrap_Pen_GetDashCount, METH_O, NULL},
31518 { (char *)"Pen_GetStipple", (PyCFunction)_wrap_Pen_GetStipple, METH_O, NULL},
31519 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
31523 { (char *)"Pen_swiginit", Pen_swiginit, METH_VARARGS, NULL},
31524 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"delete_Brush", (PyCFunction)_wrap_delete_Brush, METH_O, NULL},
31527 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Brush_GetColour", (PyCFunction)_wrap_Brush_GetColour, METH_O, NULL},
31531 { (char *)"Brush_GetStyle", (PyCFunction)_wrap_Brush_GetStyle, METH_O, NULL},
31532 { (char *)"Brush_GetStipple", (PyCFunction)_wrap_Brush_GetStipple, METH_O, NULL},
31533 { (char *)"Brush_IsHatch", (PyCFunction)_wrap_Brush_IsHatch, METH_O, NULL},
31534 { (char *)"Brush_Ok", (PyCFunction)_wrap_Brush_Ok, METH_O, NULL},
31535 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
31536 { (char *)"Brush_swiginit", Brush_swiginit, METH_VARARGS, NULL},
31537 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"delete_Bitmap", (PyCFunction)_wrap_delete_Bitmap, METH_O, NULL},
31539 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Bitmap_GetHandle", (PyCFunction)_wrap_Bitmap_GetHandle, METH_O, NULL},
31545 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Bitmap_Ok", (PyCFunction)_wrap_Bitmap_Ok, METH_O, NULL},
31547 { (char *)"Bitmap_GetWidth", (PyCFunction)_wrap_Bitmap_GetWidth, METH_O, NULL},
31548 { (char *)"Bitmap_GetHeight", (PyCFunction)_wrap_Bitmap_GetHeight, METH_O, NULL},
31549 { (char *)"Bitmap_GetDepth", (PyCFunction)_wrap_Bitmap_GetDepth, METH_O, NULL},
31550 { (char *)"Bitmap_GetSize", (PyCFunction)_wrap_Bitmap_GetSize, METH_O, NULL},
31551 { (char *)"Bitmap_ConvertToImage", (PyCFunction)_wrap_Bitmap_ConvertToImage, METH_O, NULL},
31552 { (char *)"Bitmap_GetMask", (PyCFunction)_wrap_Bitmap_GetMask, METH_O, NULL},
31553 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Bitmap_GetPalette", (PyCFunction)_wrap_Bitmap_GetPalette, METH_O, NULL},
31559 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
31569 { (char *)"Bitmap_swiginit", Bitmap_swiginit, METH_VARARGS, NULL},
31570 { (char *)"_BitmapFromBufferAlpha", (PyCFunction) _wrap__BitmapFromBufferAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"_BitmapFromBuffer", (PyCFunction) _wrap__BitmapFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"_BitmapFromBufferRGBA", (PyCFunction) _wrap__BitmapFromBufferRGBA, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"PixelDataBase_GetOrigin", (PyCFunction)_wrap_PixelDataBase_GetOrigin, METH_O, NULL},
31574 { (char *)"PixelDataBase_GetWidth", (PyCFunction)_wrap_PixelDataBase_GetWidth, METH_O, NULL},
31575 { (char *)"PixelDataBase_GetHeight", (PyCFunction)_wrap_PixelDataBase_GetHeight, METH_O, NULL},
31576 { (char *)"PixelDataBase_GetSize", (PyCFunction)_wrap_PixelDataBase_GetSize, METH_O, NULL},
31577 { (char *)"PixelDataBase_GetRowStride", (PyCFunction)_wrap_PixelDataBase_GetRowStride, METH_O, NULL},
31578 { (char *)"PixelDataBase_swigregister", PixelDataBase_swigregister, METH_VARARGS, NULL},
31579 { (char *)"new_NativePixelData", _wrap_new_NativePixelData, METH_VARARGS, NULL},
31580 { (char *)"delete_NativePixelData", (PyCFunction)_wrap_delete_NativePixelData, METH_O, NULL},
31581 { (char *)"NativePixelData_GetPixels", (PyCFunction)_wrap_NativePixelData_GetPixels, METH_O, NULL},
31582 { (char *)"NativePixelData_UseAlpha", (PyCFunction)_wrap_NativePixelData_UseAlpha, METH_O, NULL},
31583 { (char *)"NativePixelData___nonzero__", (PyCFunction)_wrap_NativePixelData___nonzero__, METH_O, NULL},
31584 { (char *)"NativePixelData_swigregister", NativePixelData_swigregister, METH_VARARGS, NULL},
31585 { (char *)"NativePixelData_swiginit", NativePixelData_swiginit, METH_VARARGS, NULL},
31586 { (char *)"new_NativePixelData_Accessor", _wrap_new_NativePixelData_Accessor, METH_VARARGS, NULL},
31587 { (char *)"delete_NativePixelData_Accessor", (PyCFunction)_wrap_delete_NativePixelData_Accessor, METH_O, NULL},
31588 { (char *)"NativePixelData_Accessor_Reset", (PyCFunction) _wrap_NativePixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"NativePixelData_Accessor_IsOk", (PyCFunction)_wrap_NativePixelData_Accessor_IsOk, METH_O, NULL},
31590 { (char *)"NativePixelData_Accessor_nextPixel", (PyCFunction)_wrap_NativePixelData_Accessor_nextPixel, METH_O, NULL},
31591 { (char *)"NativePixelData_Accessor_Offset", (PyCFunction) _wrap_NativePixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"NativePixelData_Accessor_OffsetX", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"NativePixelData_Accessor_OffsetY", (PyCFunction) _wrap_NativePixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"NativePixelData_Accessor_MoveTo", (PyCFunction) _wrap_NativePixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"NativePixelData_Accessor_Set", (PyCFunction) _wrap_NativePixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"NativePixelData_Accessor_Get", (PyCFunction)_wrap_NativePixelData_Accessor_Get, METH_O, NULL},
31597 { (char *)"NativePixelData_Accessor_swigregister", NativePixelData_Accessor_swigregister, METH_VARARGS, NULL},
31598 { (char *)"NativePixelData_Accessor_swiginit", NativePixelData_Accessor_swiginit, METH_VARARGS, NULL},
31599 { (char *)"new_AlphaPixelData", _wrap_new_AlphaPixelData, METH_VARARGS, NULL},
31600 { (char *)"delete_AlphaPixelData", (PyCFunction)_wrap_delete_AlphaPixelData, METH_O, NULL},
31601 { (char *)"AlphaPixelData_GetPixels", (PyCFunction)_wrap_AlphaPixelData_GetPixels, METH_O, NULL},
31602 { (char *)"AlphaPixelData_UseAlpha", (PyCFunction)_wrap_AlphaPixelData_UseAlpha, METH_O, NULL},
31603 { (char *)"AlphaPixelData___nonzero__", (PyCFunction)_wrap_AlphaPixelData___nonzero__, METH_O, NULL},
31604 { (char *)"AlphaPixelData_swigregister", AlphaPixelData_swigregister, METH_VARARGS, NULL},
31605 { (char *)"AlphaPixelData_swiginit", AlphaPixelData_swiginit, METH_VARARGS, NULL},
31606 { (char *)"new_AlphaPixelData_Accessor", _wrap_new_AlphaPixelData_Accessor, METH_VARARGS, NULL},
31607 { (char *)"delete_AlphaPixelData_Accessor", (PyCFunction)_wrap_delete_AlphaPixelData_Accessor, METH_O, NULL},
31608 { (char *)"AlphaPixelData_Accessor_Reset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"AlphaPixelData_Accessor_IsOk", (PyCFunction)_wrap_AlphaPixelData_Accessor_IsOk, METH_O, NULL},
31610 { (char *)"AlphaPixelData_Accessor_nextPixel", (PyCFunction)_wrap_AlphaPixelData_Accessor_nextPixel, METH_O, NULL},
31611 { (char *)"AlphaPixelData_Accessor_Offset", (PyCFunction) _wrap_AlphaPixelData_Accessor_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"AlphaPixelData_Accessor_OffsetX", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetX, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"AlphaPixelData_Accessor_OffsetY", (PyCFunction) _wrap_AlphaPixelData_Accessor_OffsetY, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"AlphaPixelData_Accessor_MoveTo", (PyCFunction) _wrap_AlphaPixelData_Accessor_MoveTo, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"AlphaPixelData_Accessor_Set", (PyCFunction) _wrap_AlphaPixelData_Accessor_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"AlphaPixelData_Accessor_Get", (PyCFunction)_wrap_AlphaPixelData_Accessor_Get, METH_O, NULL},
31617 { (char *)"AlphaPixelData_Accessor_swigregister", AlphaPixelData_Accessor_swigregister, METH_VARARGS, NULL},
31618 { (char *)"AlphaPixelData_Accessor_swiginit", AlphaPixelData_Accessor_swiginit, METH_VARARGS, NULL},
31619 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"delete_Mask", (PyCFunction)_wrap_delete_Mask, METH_O, NULL},
31621 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
31622 { (char *)"Mask_swiginit", Mask_swiginit, METH_VARARGS, NULL},
31623 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"delete_Icon", (PyCFunction)_wrap_delete_Icon, METH_O, NULL},
31625 { (char *)"new_EmptyIcon", (PyCFunction)_wrap_new_EmptyIcon, METH_NOARGS, NULL},
31626 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Icon_GetHandle", (PyCFunction)_wrap_Icon_GetHandle, METH_O, NULL},
31631 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Icon_Ok", (PyCFunction)_wrap_Icon_Ok, METH_O, NULL},
31633 { (char *)"Icon_GetWidth", (PyCFunction)_wrap_Icon_GetWidth, METH_O, NULL},
31634 { (char *)"Icon_GetHeight", (PyCFunction)_wrap_Icon_GetHeight, METH_O, NULL},
31635 { (char *)"Icon_GetDepth", (PyCFunction)_wrap_Icon_GetDepth, METH_O, NULL},
31636 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
31642 { (char *)"Icon_swiginit", Icon_swiginit, METH_VARARGS, NULL},
31643 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"delete_IconLocation", (PyCFunction)_wrap_delete_IconLocation, METH_O, NULL},
31645 { (char *)"IconLocation_IsOk", (PyCFunction)_wrap_IconLocation_IsOk, METH_O, NULL},
31646 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"IconLocation_GetFileName", (PyCFunction)_wrap_IconLocation_GetFileName, METH_O, NULL},
31648 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"IconLocation_GetIndex", (PyCFunction)_wrap_IconLocation_GetIndex, METH_O, NULL},
31650 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
31651 { (char *)"IconLocation_swiginit", IconLocation_swiginit, METH_VARARGS, NULL},
31652 { (char *)"new_IconBundle", (PyCFunction)_wrap_new_IconBundle, METH_NOARGS, NULL},
31653 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"delete_IconBundle", (PyCFunction)_wrap_delete_IconBundle, METH_O, NULL},
31656 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
31660 { (char *)"IconBundle_swiginit", IconBundle_swiginit, METH_VARARGS, NULL},
31661 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"delete_Cursor", (PyCFunction)_wrap_delete_Cursor, METH_O, NULL},
31663 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Cursor_GetHandle", (PyCFunction)_wrap_Cursor_GetHandle, METH_O, NULL},
31666 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Cursor_Ok", (PyCFunction)_wrap_Cursor_Ok, METH_O, NULL},
31668 { (char *)"Cursor_GetWidth", (PyCFunction)_wrap_Cursor_GetWidth, METH_O, NULL},
31669 { (char *)"Cursor_GetHeight", (PyCFunction)_wrap_Cursor_GetHeight, METH_O, NULL},
31670 { (char *)"Cursor_GetDepth", (PyCFunction)_wrap_Cursor_GetDepth, METH_O, NULL},
31671 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
31676 { (char *)"Cursor_swiginit", Cursor_swiginit, METH_VARARGS, NULL},
31677 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"delete_Region", (PyCFunction)_wrap_delete_Region, METH_O, NULL},
31682 { (char *)"Region_Clear", (PyCFunction)_wrap_Region_Clear, METH_O, NULL},
31683 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Region_GetBox", (PyCFunction)_wrap_Region_GetBox, METH_O, NULL},
31689 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Region_IsEmpty", (PyCFunction)_wrap_Region_IsEmpty, METH_O, NULL},
31693 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Region_ConvertToBitmap", (PyCFunction)_wrap_Region_ConvertToBitmap, METH_O, NULL},
31703 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
31706 { (char *)"Region_swiginit", Region_swiginit, METH_VARARGS, NULL},
31707 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"delete_RegionIterator", (PyCFunction)_wrap_delete_RegionIterator, METH_O, NULL},
31709 { (char *)"RegionIterator_GetX", (PyCFunction)_wrap_RegionIterator_GetX, METH_O, NULL},
31710 { (char *)"RegionIterator_GetY", (PyCFunction)_wrap_RegionIterator_GetY, METH_O, NULL},
31711 { (char *)"RegionIterator_GetW", (PyCFunction)_wrap_RegionIterator_GetW, METH_O, NULL},
31712 { (char *)"RegionIterator_GetWidth", (PyCFunction)_wrap_RegionIterator_GetWidth, METH_O, NULL},
31713 { (char *)"RegionIterator_GetH", (PyCFunction)_wrap_RegionIterator_GetH, METH_O, NULL},
31714 { (char *)"RegionIterator_GetHeight", (PyCFunction)_wrap_RegionIterator_GetHeight, METH_O, NULL},
31715 { (char *)"RegionIterator_GetRect", (PyCFunction)_wrap_RegionIterator_GetRect, METH_O, NULL},
31716 { (char *)"RegionIterator_HaveRects", (PyCFunction)_wrap_RegionIterator_HaveRects, METH_O, NULL},
31717 { (char *)"RegionIterator_Reset", (PyCFunction)_wrap_RegionIterator_Reset, METH_O, NULL},
31718 { (char *)"RegionIterator_Next", (PyCFunction)_wrap_RegionIterator_Next, METH_O, NULL},
31719 { (char *)"RegionIterator___nonzero__", (PyCFunction)_wrap_RegionIterator___nonzero__, METH_O, NULL},
31720 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
31721 { (char *)"RegionIterator_swiginit", RegionIterator_swiginit, METH_VARARGS, NULL},
31722 { (char *)"new_NativeFontInfo", (PyCFunction)_wrap_new_NativeFontInfo, METH_NOARGS, NULL},
31723 { (char *)"delete_NativeFontInfo", (PyCFunction)_wrap_delete_NativeFontInfo, METH_O, NULL},
31724 { (char *)"NativeFontInfo_Init", (PyCFunction)_wrap_NativeFontInfo_Init, METH_O, NULL},
31725 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction)_wrap_NativeFontInfo_GetPointSize, METH_O, NULL},
31727 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction)_wrap_NativeFontInfo_GetPixelSize, METH_O, NULL},
31728 { (char *)"NativeFontInfo_GetStyle", (PyCFunction)_wrap_NativeFontInfo_GetStyle, METH_O, NULL},
31729 { (char *)"NativeFontInfo_GetWeight", (PyCFunction)_wrap_NativeFontInfo_GetWeight, METH_O, NULL},
31730 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction)_wrap_NativeFontInfo_GetUnderlined, METH_O, NULL},
31731 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction)_wrap_NativeFontInfo_GetFaceName, METH_O, NULL},
31732 { (char *)"NativeFontInfo_GetFamily", (PyCFunction)_wrap_NativeFontInfo_GetFamily, METH_O, NULL},
31733 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction)_wrap_NativeFontInfo_GetEncoding, METH_O, NULL},
31734 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"NativeFontInfo_ToString", (PyCFunction)_wrap_NativeFontInfo_ToString, METH_O, NULL},
31744 { (char *)"NativeFontInfo___str__", (PyCFunction)_wrap_NativeFontInfo___str__, METH_O, NULL},
31745 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"NativeFontInfo_ToUserString", (PyCFunction)_wrap_NativeFontInfo_ToUserString, METH_O, NULL},
31747 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
31748 { (char *)"NativeFontInfo_swiginit", NativeFontInfo_swiginit, METH_VARARGS, NULL},
31749 { (char *)"NativeEncodingInfo_facename_set", _wrap_NativeEncodingInfo_facename_set, METH_VARARGS, NULL},
31750 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction)_wrap_NativeEncodingInfo_facename_get, METH_O, NULL},
31751 { (char *)"NativeEncodingInfo_encoding_set", _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS, NULL},
31752 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction)_wrap_NativeEncodingInfo_encoding_get, METH_O, NULL},
31753 { (char *)"new_NativeEncodingInfo", (PyCFunction)_wrap_new_NativeEncodingInfo, METH_NOARGS, NULL},
31754 { (char *)"delete_NativeEncodingInfo", (PyCFunction)_wrap_delete_NativeEncodingInfo, METH_O, NULL},
31755 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"NativeEncodingInfo_ToString", (PyCFunction)_wrap_NativeEncodingInfo_ToString, METH_O, NULL},
31757 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
31758 { (char *)"NativeEncodingInfo_swiginit", NativeEncodingInfo_swiginit, METH_VARARGS, NULL},
31759 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"new_FontMapper", (PyCFunction)_wrap_new_FontMapper, METH_NOARGS, NULL},
31762 { (char *)"delete_FontMapper", (PyCFunction)_wrap_delete_FontMapper, METH_O, NULL},
31763 { (char *)"FontMapper_Get", (PyCFunction)_wrap_FontMapper_Get, METH_NOARGS, NULL},
31764 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction)_wrap_FontMapper_GetSupportedEncodingsCount, METH_NOARGS, NULL},
31767 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction)_wrap_FontMapper_GetDefaultConfigPath, METH_NOARGS, NULL},
31773 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
31778 { (char *)"FontMapper_swiginit", FontMapper_swiginit, METH_VARARGS, NULL},
31779 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"delete_Font", (PyCFunction)_wrap_delete_Font, METH_O, NULL},
31781 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Font_Ok", (PyCFunction)_wrap_Font_Ok, METH_O, NULL},
31787 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Font_GetPointSize", (PyCFunction)_wrap_Font_GetPointSize, METH_O, NULL},
31790 { (char *)"Font_GetPixelSize", (PyCFunction)_wrap_Font_GetPixelSize, METH_O, NULL},
31791 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction)_wrap_Font_IsUsingSizeInPixels, METH_O, NULL},
31792 { (char *)"Font_GetFamily", (PyCFunction)_wrap_Font_GetFamily, METH_O, NULL},
31793 { (char *)"Font_GetStyle", (PyCFunction)_wrap_Font_GetStyle, METH_O, NULL},
31794 { (char *)"Font_GetWeight", (PyCFunction)_wrap_Font_GetWeight, METH_O, NULL},
31795 { (char *)"Font_GetUnderlined", (PyCFunction)_wrap_Font_GetUnderlined, METH_O, NULL},
31796 { (char *)"Font_GetFaceName", (PyCFunction)_wrap_Font_GetFaceName, METH_O, NULL},
31797 { (char *)"Font_GetEncoding", (PyCFunction)_wrap_Font_GetEncoding, METH_O, NULL},
31798 { (char *)"Font_GetNativeFontInfo", (PyCFunction)_wrap_Font_GetNativeFontInfo, METH_O, NULL},
31799 { (char *)"Font_IsFixedWidth", (PyCFunction)_wrap_Font_IsFixedWidth, METH_O, NULL},
31800 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoDesc, METH_O, NULL},
31801 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction)_wrap_Font_GetNativeFontInfoUserDesc, METH_O, NULL},
31802 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Font_GetFamilyString", (PyCFunction)_wrap_Font_GetFamilyString, METH_O, NULL},
31814 { (char *)"Font_GetStyleString", (PyCFunction)_wrap_Font_GetStyleString, METH_O, NULL},
31815 { (char *)"Font_GetWeightString", (PyCFunction)_wrap_Font_GetWeightString, METH_O, NULL},
31816 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"Font_GetNoAntiAliasing", (PyCFunction)_wrap_Font_GetNoAntiAliasing, METH_O, NULL},
31818 { (char *)"Font_GetDefaultEncoding", (PyCFunction)_wrap_Font_GetDefaultEncoding, METH_NOARGS, NULL},
31819 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
31821 { (char *)"Font_swiginit", Font_swiginit, METH_VARARGS, NULL},
31822 { (char *)"new_FontEnumerator", (PyCFunction)_wrap_new_FontEnumerator, METH_NOARGS, NULL},
31823 { (char *)"delete_FontEnumerator", (PyCFunction)_wrap_delete_FontEnumerator, METH_O, NULL},
31824 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FontEnumerator_GetEncodings", (PyCFunction)_wrap_FontEnumerator_GetEncodings, METH_NOARGS, NULL},
31828 { (char *)"FontEnumerator_GetFacenames", (PyCFunction)_wrap_FontEnumerator_GetFacenames, METH_NOARGS, NULL},
31829 { (char *)"FontEnumerator_IsValidFacename", (PyCFunction) _wrap_FontEnumerator_IsValidFacename, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
31831 { (char *)"FontEnumerator_swiginit", FontEnumerator_swiginit, METH_VARARGS, NULL},
31832 { (char *)"LanguageInfo_Language_set", _wrap_LanguageInfo_Language_set, METH_VARARGS, NULL},
31833 { (char *)"LanguageInfo_Language_get", (PyCFunction)_wrap_LanguageInfo_Language_get, METH_O, NULL},
31834 { (char *)"LanguageInfo_CanonicalName_set", _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS, NULL},
31835 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction)_wrap_LanguageInfo_CanonicalName_get, METH_O, NULL},
31836 { (char *)"LanguageInfo_Description_set", _wrap_LanguageInfo_Description_set, METH_VARARGS, NULL},
31837 { (char *)"LanguageInfo_Description_get", (PyCFunction)_wrap_LanguageInfo_Description_get, METH_O, NULL},
31838 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
31839 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"delete_Locale", (PyCFunction)_wrap_delete_Locale, METH_O, NULL},
31841 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Locale_GetSystemLanguage", (PyCFunction)_wrap_Locale_GetSystemLanguage, METH_NOARGS, NULL},
31844 { (char *)"Locale_GetSystemEncoding", (PyCFunction)_wrap_Locale_GetSystemEncoding, METH_NOARGS, NULL},
31845 { (char *)"Locale_GetSystemEncodingName", (PyCFunction)_wrap_Locale_GetSystemEncodingName, METH_NOARGS, NULL},
31846 { (char *)"Locale_IsOk", (PyCFunction)_wrap_Locale_IsOk, METH_O, NULL},
31847 { (char *)"Locale_GetLocale", (PyCFunction)_wrap_Locale_GetLocale, METH_O, NULL},
31848 { (char *)"Locale_GetLanguage", (PyCFunction)_wrap_Locale_GetLanguage, METH_O, NULL},
31849 { (char *)"Locale_GetSysName", (PyCFunction)_wrap_Locale_GetSysName, METH_O, NULL},
31850 { (char *)"Locale_GetCanonicalName", (PyCFunction)_wrap_Locale_GetCanonicalName, METH_O, NULL},
31851 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Locale_GetName", (PyCFunction)_wrap_Locale_GetName, METH_O, NULL},
31860 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
31861 { (char *)"Locale_swiginit", Locale_swiginit, METH_VARARGS, NULL},
31862 { (char *)"new_PyLocale", (PyCFunction) _wrap_new_PyLocale, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"delete_PyLocale", (PyCFunction)_wrap_delete_PyLocale, METH_O, NULL},
31864 { (char *)"PyLocale__setCallbackInfo", (PyCFunction) _wrap_PyLocale__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"PyLocale_GetSingularString", (PyCFunction) _wrap_PyLocale_GetSingularString, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"PyLocale_GetPluralString", (PyCFunction) _wrap_PyLocale_GetPluralString, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"PyLocale_swigregister", PyLocale_swigregister, METH_VARARGS, NULL},
31868 { (char *)"PyLocale_swiginit", PyLocale_swiginit, METH_VARARGS, NULL},
31869 { (char *)"GetLocale", (PyCFunction)_wrap_GetLocale, METH_NOARGS, NULL},
31870 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
31871 { (char *)"new_EncodingConverter", (PyCFunction)_wrap_new_EncodingConverter, METH_NOARGS, NULL},
31872 { (char *)"delete_EncodingConverter", (PyCFunction)_wrap_delete_EncodingConverter, METH_O, NULL},
31873 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
31879 { (char *)"EncodingConverter_swiginit", EncodingConverter_swiginit, METH_VARARGS, NULL},
31880 { (char *)"delete_DC", (PyCFunction)_wrap_delete_DC, METH_O, NULL},
31881 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DC_GradientFillConcentric", (PyCFunction) _wrap_DC_GradientFillConcentric, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DC_GradientFillLinear", (PyCFunction) _wrap_DC_GradientFillLinear, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DC_Clear", (PyCFunction)_wrap_DC_Clear, METH_O, NULL},
31930 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DC_EndDoc", (PyCFunction)_wrap_DC_EndDoc, METH_O, NULL},
31932 { (char *)"DC_StartPage", (PyCFunction)_wrap_DC_StartPage, METH_O, NULL},
31933 { (char *)"DC_EndPage", (PyCFunction)_wrap_DC_EndPage, METH_O, NULL},
31934 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DC_DestroyClippingRegion", (PyCFunction)_wrap_DC_DestroyClippingRegion, METH_O, NULL},
31941 { (char *)"DC_GetClippingBox", (PyCFunction)_wrap_DC_GetClippingBox, METH_O, NULL},
31942 { (char *)"DC_GetClippingRect", (PyCFunction)_wrap_DC_GetClippingRect, METH_O, NULL},
31943 { (char *)"DC_GetCharHeight", (PyCFunction)_wrap_DC_GetCharHeight, METH_O, NULL},
31944 { (char *)"DC_GetCharWidth", (PyCFunction)_wrap_DC_GetCharWidth, METH_O, NULL},
31945 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DC_GetSize", (PyCFunction)_wrap_DC_GetSize, METH_O, NULL},
31950 { (char *)"DC_GetSizeTuple", (PyCFunction)_wrap_DC_GetSizeTuple, METH_O, NULL},
31951 { (char *)"DC_GetSizeMM", (PyCFunction)_wrap_DC_GetSizeMM, METH_O, NULL},
31952 { (char *)"DC_GetSizeMMTuple", (PyCFunction)_wrap_DC_GetSizeMMTuple, METH_O, NULL},
31953 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DC_CanDrawBitmap", (PyCFunction)_wrap_DC_CanDrawBitmap, METH_O, NULL},
31962 { (char *)"DC_CanGetTextExtent", (PyCFunction)_wrap_DC_CanGetTextExtent, METH_O, NULL},
31963 { (char *)"DC_GetDepth", (PyCFunction)_wrap_DC_GetDepth, METH_O, NULL},
31964 { (char *)"DC_GetPPI", (PyCFunction)_wrap_DC_GetPPI, METH_O, NULL},
31965 { (char *)"DC_Ok", (PyCFunction)_wrap_DC_Ok, METH_O, NULL},
31966 { (char *)"DC_GetBackgroundMode", (PyCFunction)_wrap_DC_GetBackgroundMode, METH_O, NULL},
31967 { (char *)"DC_GetBackground", (PyCFunction)_wrap_DC_GetBackground, METH_O, NULL},
31968 { (char *)"DC_GetBrush", (PyCFunction)_wrap_DC_GetBrush, METH_O, NULL},
31969 { (char *)"DC_GetFont", (PyCFunction)_wrap_DC_GetFont, METH_O, NULL},
31970 { (char *)"DC_GetPen", (PyCFunction)_wrap_DC_GetPen, METH_O, NULL},
31971 { (char *)"DC_GetTextBackground", (PyCFunction)_wrap_DC_GetTextBackground, METH_O, NULL},
31972 { (char *)"DC_GetTextForeground", (PyCFunction)_wrap_DC_GetTextForeground, METH_O, NULL},
31973 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DC_GetMapMode", (PyCFunction)_wrap_DC_GetMapMode, METH_O, NULL},
31976 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DC_GetUserScale", (PyCFunction)_wrap_DC_GetUserScale, METH_O, NULL},
31978 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DC_GetLogicalScale", (PyCFunction)_wrap_DC_GetLogicalScale, METH_O, NULL},
31980 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DC_GetLogicalOrigin", (PyCFunction)_wrap_DC_GetLogicalOrigin, METH_O, NULL},
31982 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction)_wrap_DC_GetLogicalOriginTuple, METH_O, NULL},
31983 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DC_GetDeviceOrigin", (PyCFunction)_wrap_DC_GetDeviceOrigin, METH_O, NULL},
31986 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction)_wrap_DC_GetDeviceOriginTuple, METH_O, NULL},
31987 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DC_GetLogicalFunction", (PyCFunction)_wrap_DC_GetLogicalFunction, METH_O, NULL},
31991 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction)_wrap_DC_ComputeScaleAndOrigin, METH_O, NULL},
31993 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DC_ResetBoundingBox", (PyCFunction)_wrap_DC_ResetBoundingBox, METH_O, NULL},
31996 { (char *)"DC_MinX", (PyCFunction)_wrap_DC_MinX, METH_O, NULL},
31997 { (char *)"DC_MaxX", (PyCFunction)_wrap_DC_MaxX, METH_O, NULL},
31998 { (char *)"DC_MinY", (PyCFunction)_wrap_DC_MinY, METH_O, NULL},
31999 { (char *)"DC_MaxY", (PyCFunction)_wrap_DC_MaxY, METH_O, NULL},
32000 { (char *)"DC_GetBoundingBox", (PyCFunction)_wrap_DC_GetBoundingBox, METH_O, NULL},
32001 { (char *)"DC_GetHDC", (PyCFunction)_wrap_DC_GetHDC, METH_O, NULL},
32002 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
32009 { (char *)"new_MemoryDC", (PyCFunction)_wrap_new_MemoryDC, METH_NOARGS, NULL},
32010 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
32013 { (char *)"MemoryDC_swiginit", MemoryDC_swiginit, METH_VARARGS, NULL},
32014 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
32015 { (char *)"delete_BufferedDC", (PyCFunction)_wrap_delete_BufferedDC, METH_O, NULL},
32016 { (char *)"BufferedDC_UnMask", (PyCFunction)_wrap_BufferedDC_UnMask, METH_O, NULL},
32017 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
32018 { (char *)"BufferedDC_swiginit", BufferedDC_swiginit, METH_VARARGS, NULL},
32019 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
32021 { (char *)"BufferedPaintDC_swiginit", BufferedPaintDC_swiginit, METH_VARARGS, NULL},
32022 { (char *)"new_ScreenDC", (PyCFunction)_wrap_new_ScreenDC, METH_NOARGS, NULL},
32023 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction)_wrap_ScreenDC_EndDrawingOnTop, METH_O, NULL},
32026 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
32027 { (char *)"ScreenDC_swiginit", ScreenDC_swiginit, METH_VARARGS, NULL},
32028 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
32030 { (char *)"ClientDC_swiginit", ClientDC_swiginit, METH_VARARGS, NULL},
32031 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
32033 { (char *)"PaintDC_swiginit", PaintDC_swiginit, METH_VARARGS, NULL},
32034 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
32036 { (char *)"WindowDC_swiginit", WindowDC_swiginit, METH_VARARGS, NULL},
32037 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
32039 { (char *)"MirrorDC_swiginit", MirrorDC_swiginit, METH_VARARGS, NULL},
32040 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"PostScriptDC_GetPrintData", (PyCFunction)_wrap_PostScriptDC_GetPrintData, METH_O, NULL},
32042 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"PostScriptDC_GetResolution", (PyCFunction)_wrap_PostScriptDC_GetResolution, METH_NOARGS, NULL},
32045 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
32046 { (char *)"PostScriptDC_swiginit", PostScriptDC_swiginit, METH_VARARGS, NULL},
32047 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"delete_MetaFile", (PyCFunction)_wrap_delete_MetaFile, METH_O, NULL},
32049 { (char *)"MetaFile_Ok", (PyCFunction)_wrap_MetaFile_Ok, METH_O, NULL},
32050 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"MetaFile_GetSize", (PyCFunction)_wrap_MetaFile_GetSize, METH_O, NULL},
32052 { (char *)"MetaFile_GetWidth", (PyCFunction)_wrap_MetaFile_GetWidth, METH_O, NULL},
32053 { (char *)"MetaFile_GetHeight", (PyCFunction)_wrap_MetaFile_GetHeight, METH_O, NULL},
32054 { (char *)"MetaFile_GetFileName", (PyCFunction)_wrap_MetaFile_GetFileName, METH_O, NULL},
32055 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
32056 { (char *)"MetaFile_swiginit", MetaFile_swiginit, METH_VARARGS, NULL},
32057 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"MetaFileDC_Close", (PyCFunction)_wrap_MetaFileDC_Close, METH_O, NULL},
32059 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
32060 { (char *)"MetaFileDC_swiginit", MetaFileDC_swiginit, METH_VARARGS, NULL},
32061 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
32063 { (char *)"PrinterDC_swiginit", PrinterDC_swiginit, METH_VARARGS, NULL},
32064 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"delete_ImageList", (PyCFunction)_wrap_delete_ImageList, METH_O, NULL},
32066 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"ImageList_GetImageCount", (PyCFunction)_wrap_ImageList_GetImageCount, METH_O, NULL},
32074 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"ImageList_RemoveAll", (PyCFunction)_wrap_ImageList_RemoveAll, METH_O, NULL},
32076 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
32078 { (char *)"ImageList_swiginit", ImageList_swiginit, METH_VARARGS, NULL},
32079 { (char *)"new_StockGDI", (PyCFunction)_wrap_new_StockGDI, METH_NOARGS, NULL},
32080 { (char *)"delete_StockGDI", (PyCFunction)_wrap_delete_StockGDI, METH_O, NULL},
32081 { (char *)"StockGDI_DeleteAll", (PyCFunction)_wrap_StockGDI_DeleteAll, METH_NOARGS, NULL},
32082 { (char *)"StockGDI_instance", (PyCFunction)_wrap_StockGDI_instance, METH_NOARGS, NULL},
32083 { (char *)"StockGDI_GetBrush", (PyCFunction) _wrap_StockGDI_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"StockGDI_GetColour", (PyCFunction) _wrap_StockGDI_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"StockGDI_GetCursor", (PyCFunction) _wrap_StockGDI_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"StockGDI_GetPen", (PyCFunction) _wrap_StockGDI_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"StockGDI_GetFont", (PyCFunction) _wrap_StockGDI_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"StockGDI_swigregister", StockGDI_swigregister, METH_VARARGS, NULL},
32089 { (char *)"StockGDI_swiginit", StockGDI_swiginit, METH_VARARGS, NULL},
32090 { (char *)"new_GDIObjListBase", (PyCFunction)_wrap_new_GDIObjListBase, METH_NOARGS, NULL},
32091 { (char *)"delete_GDIObjListBase", (PyCFunction)_wrap_delete_GDIObjListBase, METH_O, NULL},
32092 { (char *)"GDIObjListBase_swigregister", GDIObjListBase_swigregister, METH_VARARGS, NULL},
32093 { (char *)"GDIObjListBase_swiginit", GDIObjListBase_swiginit, METH_VARARGS, NULL},
32094 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
32098 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
32102 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
32106 { (char *)"new_ColourDatabase", (PyCFunction)_wrap_new_ColourDatabase, METH_NOARGS, NULL},
32107 { (char *)"delete_ColourDatabase", (PyCFunction)_wrap_delete_ColourDatabase, METH_O, NULL},
32108 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
32113 { (char *)"ColourDatabase_swiginit", ColourDatabase_swiginit, METH_VARARGS, NULL},
32114 { (char *)"_wxPyInitTheFontList", (PyCFunction)_wrap__wxPyInitTheFontList, METH_NOARGS, NULL},
32115 { (char *)"_wxPyInitThePenList", (PyCFunction)_wrap__wxPyInitThePenList, METH_NOARGS, NULL},
32116 { (char *)"_wxPyInitTheBrushList", (PyCFunction)_wrap__wxPyInitTheBrushList, METH_NOARGS, NULL},
32117 { (char *)"_wxPyInitTheColourDatabase", (PyCFunction)_wrap__wxPyInitTheColourDatabase, METH_NOARGS, NULL},
32118 { (char *)"new_Effects", (PyCFunction)_wrap_new_Effects, METH_NOARGS, NULL},
32119 { (char *)"Effects_GetHighlightColour", (PyCFunction)_wrap_Effects_GetHighlightColour, METH_O, NULL},
32120 { (char *)"Effects_GetLightShadow", (PyCFunction)_wrap_Effects_GetLightShadow, METH_O, NULL},
32121 { (char *)"Effects_GetFaceColour", (PyCFunction)_wrap_Effects_GetFaceColour, METH_O, NULL},
32122 { (char *)"Effects_GetMediumShadow", (PyCFunction)_wrap_Effects_GetMediumShadow, METH_O, NULL},
32123 { (char *)"Effects_GetDarkShadow", (PyCFunction)_wrap_Effects_GetDarkShadow, METH_O, NULL},
32124 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
32133 { (char *)"Effects_swiginit", Effects_swiginit, METH_VARARGS, NULL},
32134 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"delete_SplitterRenderParams", (PyCFunction)_wrap_delete_SplitterRenderParams, METH_O, NULL},
32136 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction)_wrap_SplitterRenderParams_widthSash_get, METH_O, NULL},
32137 { (char *)"SplitterRenderParams_border_get", (PyCFunction)_wrap_SplitterRenderParams_border_get, METH_O, NULL},
32138 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction)_wrap_SplitterRenderParams_isHotSensitive_get, METH_O, NULL},
32139 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
32140 { (char *)"SplitterRenderParams_swiginit", SplitterRenderParams_swiginit, METH_VARARGS, NULL},
32141 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"delete_RendererVersion", (PyCFunction)_wrap_delete_RendererVersion, METH_O, NULL},
32143 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"RendererVersion_version_get", (PyCFunction)_wrap_RendererVersion_version_get, METH_O, NULL},
32145 { (char *)"RendererVersion_age_get", (PyCFunction)_wrap_RendererVersion_age_get, METH_O, NULL},
32146 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
32147 { (char *)"RendererVersion_swiginit", RendererVersion_swiginit, METH_VARARGS, NULL},
32148 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"RendererNative_DrawCheckBox", (PyCFunction) _wrap_RendererNative_DrawCheckBox, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"RendererNative_DrawPushButton", (PyCFunction) _wrap_RendererNative_DrawPushButton, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"RendererNative_DrawItemSelectionRect", (PyCFunction) _wrap_RendererNative_DrawItemSelectionRect, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"RendererNative_Get", (PyCFunction)_wrap_RendererNative_Get, METH_NOARGS, NULL},
32159 { (char *)"RendererNative_GetGeneric", (PyCFunction)_wrap_RendererNative_GetGeneric, METH_NOARGS, NULL},
32160 { (char *)"RendererNative_GetDefault", (PyCFunction)_wrap_RendererNative_GetDefault, METH_NOARGS, NULL},
32161 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"RendererNative_GetVersion", (PyCFunction)_wrap_RendererNative_GetVersion, METH_O, NULL},
32163 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
32164 { (char *)"new_PseudoDC", (PyCFunction)_wrap_new_PseudoDC, METH_NOARGS, NULL},
32165 { (char *)"PseudoDC_BeginDrawing", (PyCFunction)_wrap_PseudoDC_BeginDrawing, METH_O, NULL},
32166 { (char *)"PseudoDC_EndDrawing", (PyCFunction)_wrap_PseudoDC_EndDrawing, METH_O, NULL},
32167 { (char *)"delete_PseudoDC", (PyCFunction)_wrap_delete_PseudoDC, METH_O, NULL},
32168 { (char *)"PseudoDC_RemoveAll", (PyCFunction)_wrap_PseudoDC_RemoveAll, METH_O, NULL},
32169 { (char *)"PseudoDC_GetLen", (PyCFunction)_wrap_PseudoDC_GetLen, METH_O, NULL},
32170 { (char *)"PseudoDC_SetId", (PyCFunction) _wrap_PseudoDC_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"PseudoDC_ClearId", (PyCFunction) _wrap_PseudoDC_ClearId, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"PseudoDC_RemoveId", (PyCFunction) _wrap_PseudoDC_RemoveId, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"PseudoDC_TranslateId", (PyCFunction) _wrap_PseudoDC_TranslateId, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"PseudoDC_DrawIdToDC", (PyCFunction) _wrap_PseudoDC_DrawIdToDC, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"PseudoDC_SetIdBounds", (PyCFunction) _wrap_PseudoDC_SetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"PseudoDC_GetIdBounds", (PyCFunction) _wrap_PseudoDC_GetIdBounds, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"PseudoDC_DrawToDCClipped", (PyCFunction) _wrap_PseudoDC_DrawToDCClipped, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"PseudoDC_DrawToDCClippedRgn", (PyCFunction) _wrap_PseudoDC_DrawToDCClippedRgn, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"PseudoDC_DrawToDC", (PyCFunction) _wrap_PseudoDC_DrawToDC, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"PseudoDC_FloodFill", (PyCFunction) _wrap_PseudoDC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"PseudoDC_FloodFillPoint", (PyCFunction) _wrap_PseudoDC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"PseudoDC_DrawLine", (PyCFunction) _wrap_PseudoDC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"PseudoDC_DrawLinePoint", (PyCFunction) _wrap_PseudoDC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"PseudoDC_CrossHair", (PyCFunction) _wrap_PseudoDC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"PseudoDC_CrossHairPoint", (PyCFunction) _wrap_PseudoDC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"PseudoDC_DrawArc", (PyCFunction) _wrap_PseudoDC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"PseudoDC_DrawArcPoint", (PyCFunction) _wrap_PseudoDC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"PseudoDC_DrawCheckMark", (PyCFunction) _wrap_PseudoDC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"PseudoDC_DrawCheckMarkRect", (PyCFunction) _wrap_PseudoDC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"PseudoDC_DrawEllipticArc", (PyCFunction) _wrap_PseudoDC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"PseudoDC_DrawEllipticArcPointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"PseudoDC_DrawPoint", (PyCFunction) _wrap_PseudoDC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"PseudoDC_DrawPointPoint", (PyCFunction) _wrap_PseudoDC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"PseudoDC_DrawRectangle", (PyCFunction) _wrap_PseudoDC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"PseudoDC_DrawRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"PseudoDC_DrawRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"PseudoDC_DrawRoundedRectangle", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"PseudoDC_DrawRoundedRectangleRect", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"PseudoDC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_PseudoDC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"PseudoDC_DrawCircle", (PyCFunction) _wrap_PseudoDC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"PseudoDC_DrawCirclePoint", (PyCFunction) _wrap_PseudoDC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"PseudoDC_DrawEllipse", (PyCFunction) _wrap_PseudoDC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"PseudoDC_DrawEllipseRect", (PyCFunction) _wrap_PseudoDC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"PseudoDC_DrawEllipsePointSize", (PyCFunction) _wrap_PseudoDC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"PseudoDC_DrawIcon", (PyCFunction) _wrap_PseudoDC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"PseudoDC_DrawIconPoint", (PyCFunction) _wrap_PseudoDC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"PseudoDC_DrawBitmap", (PyCFunction) _wrap_PseudoDC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"PseudoDC_DrawBitmapPoint", (PyCFunction) _wrap_PseudoDC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"PseudoDC_DrawText", (PyCFunction) _wrap_PseudoDC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"PseudoDC_DrawTextPoint", (PyCFunction) _wrap_PseudoDC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"PseudoDC_DrawRotatedText", (PyCFunction) _wrap_PseudoDC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"PseudoDC_DrawRotatedTextPoint", (PyCFunction) _wrap_PseudoDC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"PseudoDC_DrawLines", (PyCFunction) _wrap_PseudoDC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"PseudoDC_DrawPolygon", (PyCFunction) _wrap_PseudoDC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"PseudoDC_DrawLabel", (PyCFunction) _wrap_PseudoDC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"PseudoDC_DrawImageLabel", (PyCFunction) _wrap_PseudoDC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"PseudoDC_DrawSpline", (PyCFunction) _wrap_PseudoDC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"PseudoDC_Clear", (PyCFunction)_wrap_PseudoDC_Clear, METH_O, NULL},
32219 { (char *)"PseudoDC_SetFont", (PyCFunction) _wrap_PseudoDC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"PseudoDC_SetPen", (PyCFunction) _wrap_PseudoDC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"PseudoDC_SetBrush", (PyCFunction) _wrap_PseudoDC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"PseudoDC_SetBackground", (PyCFunction) _wrap_PseudoDC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"PseudoDC_SetBackgroundMode", (PyCFunction) _wrap_PseudoDC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"PseudoDC_SetPalette", (PyCFunction) _wrap_PseudoDC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"PseudoDC_SetTextForeground", (PyCFunction) _wrap_PseudoDC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"PseudoDC_SetTextBackground", (PyCFunction) _wrap_PseudoDC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"PseudoDC_SetLogicalFunction", (PyCFunction) _wrap_PseudoDC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"PseudoDC_swigregister", PseudoDC_swigregister, METH_VARARGS, NULL},
32229 { (char *)"PseudoDC_swiginit", PseudoDC_swiginit, METH_VARARGS, NULL},
32230 { NULL, NULL, 0, NULL }
32231 };
32232
32233
32234 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32235
32236 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
32237 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
32238 }
32239 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
32240 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
32241 }
32242 static void *_p_wxPyLocaleTo_p_wxLocale(void *x) {
32243 return (void *)((wxLocale *) ((wxPyLocale *) x));
32244 }
32245 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
32246 return (void *)((wxGDIObject *) ((wxIcon *) x));
32247 }
32248 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
32249 return (void *)((wxGDIObject *) ((wxPalette *) x));
32250 }
32251 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
32252 return (void *)((wxGDIObject *) ((wxPen *) x));
32253 }
32254 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
32255 return (void *)((wxGDIObject *) ((wxFont *) x));
32256 }
32257 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
32258 return (void *)((wxGDIObject *) ((wxCursor *) x));
32259 }
32260 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
32261 return (void *)((wxGDIObject *) ((wxBitmap *) x));
32262 }
32263 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
32264 return (void *)((wxGDIObject *) ((wxRegion *) x));
32265 }
32266 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
32267 return (void *)((wxGDIObject *) ((wxBrush *) x));
32268 }
32269 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
32270 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
32271 }
32272 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
32273 return (void *)((wxDC *) ((wxScreenDC *) x));
32274 }
32275 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
32276 return (void *)((wxDC *) ((wxMirrorDC *) x));
32277 }
32278 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
32279 return (void *)((wxDC *) ((wxMemoryDC *) x));
32280 }
32281 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
32282 return (void *)((wxDC *) ((wxWindowDC *) x));
32283 }
32284 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
32285 return (void *)((wxDC *) ((wxMetaFileDC *) x));
32286 }
32287 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
32288 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
32289 }
32290 static void *_p_wxClientDCTo_p_wxDC(void *x) {
32291 return (void *)((wxDC *) ((wxClientDC *) x));
32292 }
32293 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
32294 return (void *)((wxDC *) ((wxPaintDC *) x));
32295 }
32296 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
32297 return (void *)((wxDC *) ((wxPostScriptDC *) x));
32298 }
32299 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
32300 return (void *)((wxDC *) ((wxPrinterDC *) x));
32301 }
32302 static void *_p_wxBrushListTo_p_wxGDIObjListBase(void *x) {
32303 return (void *)((wxGDIObjListBase *) ((wxBrushList *) x));
32304 }
32305 static void *_p_wxFontListTo_p_wxGDIObjListBase(void *x) {
32306 return (void *)((wxGDIObjListBase *) ((wxFontList *) x));
32307 }
32308 static void *_p_wxPenListTo_p_wxGDIObjListBase(void *x) {
32309 return (void *)((wxGDIObjListBase *) ((wxPenList *) x));
32310 }
32311 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
32312 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
32313 }
32314 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32315 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32316 }
32317 static void *_p_wxPenTo_p_wxObject(void *x) {
32318 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
32319 }
32320 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
32321 return (void *)((wxObject *) ((wxRegionIterator *) x));
32322 }
32323 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32324 return (void *)((wxObject *) ((wxSizerItem *) x));
32325 }
32326 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32327 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32328 }
32329 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32330 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32331 }
32332 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32333 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32334 }
32335 static void *_p_wxIconTo_p_wxObject(void *x) {
32336 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
32337 }
32338 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32339 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32340 }
32341 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32342 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32343 }
32344 static void *_p_wxSizerTo_p_wxObject(void *x) {
32345 return (void *)((wxObject *) ((wxSizer *) x));
32346 }
32347 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32348 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32349 }
32350 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32351 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32352 }
32353 static void *_p_wxEventTo_p_wxObject(void *x) {
32354 return (void *)((wxObject *) ((wxEvent *) x));
32355 }
32356 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32357 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32358 }
32359 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32360 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32361 }
32362 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32364 }
32365 static void *_p_wxPseudoDCTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) ((wxPseudoDC *) x));
32367 }
32368 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
32370 }
32371 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32373 }
32374 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32376 }
32377 static void *_p_wxDCTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) ((wxDC *) x));
32379 }
32380 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32382 }
32383 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32385 }
32386 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32388 }
32389 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32391 }
32392 static void *_p_wxControlTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32394 }
32395 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32396 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32397 }
32398 static void *_p_wxClientDCTo_p_wxObject(void *x) {
32399 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
32400 }
32401 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32402 return (void *)((wxObject *) ((wxFSFile *) x));
32403 }
32404 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
32405 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
32406 }
32407 static void *_p_wxRegionTo_p_wxObject(void *x) {
32408 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
32409 }
32410 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32411 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32412 }
32413 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
32415 }
32416 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) ((wxGDIObject *) x));
32418 }
32419 static void *_p_wxEffectsTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) ((wxEffects *) x));
32421 }
32422 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32424 }
32425 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32427 }
32428 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
32430 }
32431 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32433 }
32434 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) ((wxMenuItem *) x));
32436 }
32437 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32439 }
32440 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32442 }
32443 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32445 }
32446 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32448 }
32449 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32451 }
32452 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32454 }
32455 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32457 }
32458 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32460 }
32461 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32463 }
32464 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32466 }
32467 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32469 }
32470 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32472 }
32473 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32475 }
32476 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32478 }
32479 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32481 }
32482 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32484 }
32485 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32487 }
32488 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32490 }
32491 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
32493 }
32494 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) ((wxImageHandler *) x));
32496 }
32497 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32499 }
32500 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32502 }
32503 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) ((wxEvtHandler *) x));
32505 }
32506 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
32508 }
32509 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
32511 }
32512 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
32514 }
32515 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
32517 }
32518 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
32520 }
32521 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32523 }
32524 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32526 }
32527 static void *_p_wxImageTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) ((wxImage *) x));
32529 }
32530 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32532 }
32533 static void *_p_wxPaletteTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
32535 }
32536 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
32538 }
32539 static void *_p_wxImageListTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) ((wxImageList *) x));
32541 }
32542 static void *_p_wxCursorTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
32544 }
32545 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) ((wxEncodingConverter *) x));
32547 }
32548 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
32550 }
32551 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32553 }
32554 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32556 }
32557 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32559 }
32560 static void *_p_wxWindowTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32562 }
32563 static void *_p_wxMenuTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32565 }
32566 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32568 }
32569 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
32571 }
32572 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) ((wxFileSystem *) x));
32574 }
32575 static void *_p_wxBitmapTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
32577 }
32578 static void *_p_wxMaskTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) ((wxMask *) x));
32580 }
32581 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32583 }
32584 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32586 }
32587 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32589 }
32590 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32592 }
32593 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32595 }
32596 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32598 }
32599 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32601 }
32602 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32604 }
32605 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32607 }
32608 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32610 }
32611 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32613 }
32614 static void *_p_wxFontTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
32616 }
32617 static void *_p_wxBrushTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
32619 }
32620 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) ((wxMetaFile *) x));
32622 }
32623 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32625 }
32626 static void *_p_wxColourTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) ((wxColour *) x));
32628 }
32629 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32631 }
32632 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32634 }
32635 static void *_p_wxControlTo_p_wxWindow(void *x) {
32636 return (void *)((wxWindow *) ((wxControl *) x));
32637 }
32638 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32639 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32640 }
32641 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32642 return (void *)((wxWindow *) ((wxMenuBar *) x));
32643 }
32644 static void *_p_wxNativePixelDataTo_p_wxPixelDataBase(void *x) {
32645 return (void *)((wxPixelDataBase *) ((wxNativePixelData *) x));
32646 }
32647 static void *_p_wxAlphaPixelDataTo_p_wxPixelDataBase(void *x) {
32648 return (void *)((wxPixelDataBase *) ((wxAlphaPixelData *) x));
32649 }
32650 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
32651 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
32652 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
32653 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};
32654 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
32655 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
32656 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
32657 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
32658 static swig_type_info _swigt__p_wxAlphaPixelData = {"_p_wxAlphaPixelData", "wxAlphaPixelData *", 0, 0, (void*)0, 0};
32659 static swig_type_info _swigt__p_wxAlphaPixelData_Accessor = {"_p_wxAlphaPixelData_Accessor", "wxAlphaPixelData_Accessor *", 0, 0, (void*)0, 0};
32660 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
32661 static swig_type_info _swigt__p_wxBrush = {"_p_wxBrush", "wxBrush *", 0, 0, (void*)0, 0};
32662 static swig_type_info _swigt__p_wxBrushList = {"_p_wxBrushList", "wxBrushList *", 0, 0, (void*)0, 0};
32663 static swig_type_info _swigt__p_wxBufferedDC = {"_p_wxBufferedDC", "wxBufferedDC *", 0, 0, (void*)0, 0};
32664 static swig_type_info _swigt__p_wxBufferedPaintDC = {"_p_wxBufferedPaintDC", "wxBufferedPaintDC *", 0, 0, (void*)0, 0};
32665 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
32666 static swig_type_info _swigt__p_wxClientDC = {"_p_wxClientDC", "wxClientDC *", 0, 0, (void*)0, 0};
32667 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
32668 static swig_type_info _swigt__p_wxColourDatabase = {"_p_wxColourDatabase", "wxColourDatabase *", 0, 0, (void*)0, 0};
32669 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
32670 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
32671 static swig_type_info _swigt__p_wxDash = {"_p_wxDash", "wxDash *", 0, 0, (void*)0, 0};
32672 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
32673 static swig_type_info _swigt__p_wxEffects = {"_p_wxEffects", "wxEffects *", 0, 0, (void*)0, 0};
32674 static swig_type_info _swigt__p_wxEncodingConverter = {"_p_wxEncodingConverter", "wxEncodingConverter *", 0, 0, (void*)0, 0};
32675 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
32676 static swig_type_info _swigt__p_wxFontList = {"_p_wxFontList", "wxFontList *", 0, 0, (void*)0, 0};
32677 static swig_type_info _swigt__p_wxFontMapper = {"_p_wxFontMapper", "wxFontMapper *", 0, 0, (void*)0, 0};
32678 static swig_type_info _swigt__p_wxGDIObjListBase = {"_p_wxGDIObjListBase", "wxGDIObjListBase *", 0, 0, (void*)0, 0};
32679 static swig_type_info _swigt__p_wxGDIObject = {"_p_wxGDIObject", "wxGDIObject *", 0, 0, (void*)0, 0};
32680 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
32681 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
32682 static swig_type_info _swigt__p_wxIconLocation = {"_p_wxIconLocation", "wxIconLocation *", 0, 0, (void*)0, 0};
32683 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
32684 static swig_type_info _swigt__p_wxImageList = {"_p_wxImageList", "wxImageList *", 0, 0, (void*)0, 0};
32685 static swig_type_info _swigt__p_wxLanguageInfo = {"_p_wxLanguageInfo", "wxLanguageInfo *", 0, 0, (void*)0, 0};
32686 static swig_type_info _swigt__p_wxLocale = {"_p_wxLocale", "wxLocale *", 0, 0, (void*)0, 0};
32687 static swig_type_info _swigt__p_wxMask = {"_p_wxMask", "wxMask *", 0, 0, (void*)0, 0};
32688 static swig_type_info _swigt__p_wxMemoryDC = {"_p_wxMemoryDC", "wxMemoryDC *", 0, 0, (void*)0, 0};
32689 static swig_type_info _swigt__p_wxMetaFile = {"_p_wxMetaFile", "wxMetaFile *", 0, 0, (void*)0, 0};
32690 static swig_type_info _swigt__p_wxMetaFileDC = {"_p_wxMetaFileDC", "wxMetaFileDC *", 0, 0, (void*)0, 0};
32691 static swig_type_info _swigt__p_wxMirrorDC = {"_p_wxMirrorDC", "wxMirrorDC *", 0, 0, (void*)0, 0};
32692 static swig_type_info _swigt__p_wxNativeEncodingInfo = {"_p_wxNativeEncodingInfo", "wxNativeEncodingInfo *", 0, 0, (void*)0, 0};
32693 static swig_type_info _swigt__p_wxNativeFontInfo = {"_p_wxNativeFontInfo", "wxNativeFontInfo *", 0, 0, (void*)0, 0};
32694 static swig_type_info _swigt__p_wxNativePixelData = {"_p_wxNativePixelData", "wxNativePixelData *", 0, 0, (void*)0, 0};
32695 static swig_type_info _swigt__p_wxNativePixelData_Accessor = {"_p_wxNativePixelData_Accessor", "wxNativePixelData_Accessor *", 0, 0, (void*)0, 0};
32696 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
32697 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
32698 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
32699 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
32700 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
32701 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
32702 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
32703 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
32704 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
32705 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
32706 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
32707 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
32708 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
32709 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
32710 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
32711 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
32712 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
32713 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
32714 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
32715 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
32716 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
32717 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
32718 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
32719 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
32720 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
32721 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
32722 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
32723 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
32724 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
32725 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
32726 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
32727 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
32728 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
32729 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
32730 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
32731 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
32732 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
32733 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
32734 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
32735 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
32736 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
32737 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
32738 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
32739 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
32740 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
32741 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
32742 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
32743 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
32744 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
32745 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
32746 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
32747 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
32748 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
32749 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
32750 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
32751 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
32752 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
32753 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
32754 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
32755 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
32756 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
32757 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
32758 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
32759 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
32760 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
32761 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
32762 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
32763 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
32764 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
32765 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
32766 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
32767 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
32768 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
32769 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
32770 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
32771 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
32772 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
32773 static swig_type_info _swigt__p_wxPaintDC = {"_p_wxPaintDC", "wxPaintDC *", 0, 0, (void*)0, 0};
32774 static swig_type_info _swigt__p_wxPalette = {"_p_wxPalette", "wxPalette *", 0, 0, (void*)0, 0};
32775 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
32776 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
32777 static swig_type_info _swigt__p_wxPenList = {"_p_wxPenList", "wxPenList *", 0, 0, (void*)0, 0};
32778 static swig_type_info _swigt__p_wxPixelDataBase = {"_p_wxPixelDataBase", "wxPixelDataBase *", 0, 0, (void*)0, 0};
32779 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
32780 static swig_type_info _swigt__p_wxPostScriptDC = {"_p_wxPostScriptDC", "wxPostScriptDC *", 0, 0, (void*)0, 0};
32781 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};
32782 static swig_type_info _swigt__p_wxPrinterDC = {"_p_wxPrinterDC", "wxPrinterDC *", 0, 0, (void*)0, 0};
32783 static swig_type_info _swigt__p_wxPseudoDC = {"_p_wxPseudoDC", "wxPseudoDC *", 0, 0, (void*)0, 0};
32784 static swig_type_info _swigt__p_wxPyFontEnumerator = {"_p_wxPyFontEnumerator", "wxPyFontEnumerator *", 0, 0, (void*)0, 0};
32785 static swig_type_info _swigt__p_wxPyLocale = {"_p_wxPyLocale", "wxPyLocale *", 0, 0, (void*)0, 0};
32786 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
32787 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
32788 static swig_type_info _swigt__p_wxRegionIterator = {"_p_wxRegionIterator", "wxRegionIterator *", 0, 0, (void*)0, 0};
32789 static swig_type_info _swigt__p_wxRendererNative = {"_p_wxRendererNative", "wxRendererNative *", 0, 0, (void*)0, 0};
32790 static swig_type_info _swigt__p_wxRendererVersion = {"_p_wxRendererVersion", "wxRendererVersion *", 0, 0, (void*)0, 0};
32791 static swig_type_info _swigt__p_wxScreenDC = {"_p_wxScreenDC", "wxScreenDC *", 0, 0, (void*)0, 0};
32792 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
32793 static swig_type_info _swigt__p_wxSplitterRenderParams = {"_p_wxSplitterRenderParams", "wxSplitterRenderParams *", 0, 0, (void*)0, 0};
32794 static swig_type_info _swigt__p_wxStockGDI = {"_p_wxStockGDI", "wxStockGDI *", 0, 0, (void*)0, 0};
32795 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
32796 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
32797 static swig_type_info _swigt__p_wxWindowDC = {"_p_wxWindowDC", "wxWindowDC *", 0, 0, (void*)0, 0};
32798
32799 static swig_type_info *swig_type_initial[] = {
32800 &_swigt__p_buffer,
32801 &_swigt__p_char,
32802 &_swigt__p_double,
32803 &_swigt__p_form_ops_t,
32804 &_swigt__p_int,
32805 &_swigt__p_unsigned_char,
32806 &_swigt__p_unsigned_int,
32807 &_swigt__p_unsigned_long,
32808 &_swigt__p_wxANIHandler,
32809 &_swigt__p_wxAcceleratorTable,
32810 &_swigt__p_wxActivateEvent,
32811 &_swigt__p_wxAlphaPixelData,
32812 &_swigt__p_wxAlphaPixelData_Accessor,
32813 &_swigt__p_wxBMPHandler,
32814 &_swigt__p_wxBitmap,
32815 &_swigt__p_wxBoxSizer,
32816 &_swigt__p_wxBrush,
32817 &_swigt__p_wxBrushList,
32818 &_swigt__p_wxBufferedDC,
32819 &_swigt__p_wxBufferedPaintDC,
32820 &_swigt__p_wxCURHandler,
32821 &_swigt__p_wxChar,
32822 &_swigt__p_wxChildFocusEvent,
32823 &_swigt__p_wxClientDC,
32824 &_swigt__p_wxClipboardTextEvent,
32825 &_swigt__p_wxCloseEvent,
32826 &_swigt__p_wxColour,
32827 &_swigt__p_wxColourDatabase,
32828 &_swigt__p_wxCommandEvent,
32829 &_swigt__p_wxContextMenuEvent,
32830 &_swigt__p_wxControl,
32831 &_swigt__p_wxControlWithItems,
32832 &_swigt__p_wxCursor,
32833 &_swigt__p_wxDC,
32834 &_swigt__p_wxDash,
32835 &_swigt__p_wxDateEvent,
32836 &_swigt__p_wxDisplayChangedEvent,
32837 &_swigt__p_wxDropFilesEvent,
32838 &_swigt__p_wxDuplexMode,
32839 &_swigt__p_wxEffects,
32840 &_swigt__p_wxEncodingConverter,
32841 &_swigt__p_wxEraseEvent,
32842 &_swigt__p_wxEvent,
32843 &_swigt__p_wxEvtHandler,
32844 &_swigt__p_wxFSFile,
32845 &_swigt__p_wxFileSystem,
32846 &_swigt__p_wxFlexGridSizer,
32847 &_swigt__p_wxFocusEvent,
32848 &_swigt__p_wxFont,
32849 &_swigt__p_wxFontList,
32850 &_swigt__p_wxFontMapper,
32851 &_swigt__p_wxGBSizerItem,
32852 &_swigt__p_wxGDIObjListBase,
32853 &_swigt__p_wxGDIObject,
32854 &_swigt__p_wxGIFHandler,
32855 &_swigt__p_wxGridBagSizer,
32856 &_swigt__p_wxGridSizer,
32857 &_swigt__p_wxICOHandler,
32858 &_swigt__p_wxIcon,
32859 &_swigt__p_wxIconBundle,
32860 &_swigt__p_wxIconLocation,
32861 &_swigt__p_wxIconizeEvent,
32862 &_swigt__p_wxIdleEvent,
32863 &_swigt__p_wxImage,
32864 &_swigt__p_wxImageHandler,
32865 &_swigt__p_wxImageList,
32866 &_swigt__p_wxIndividualLayoutConstraint,
32867 &_swigt__p_wxInitDialogEvent,
32868 &_swigt__p_wxJPEGHandler,
32869 &_swigt__p_wxKeyEvent,
32870 &_swigt__p_wxLanguageInfo,
32871 &_swigt__p_wxLayoutConstraints,
32872 &_swigt__p_wxLocale,
32873 &_swigt__p_wxMask,
32874 &_swigt__p_wxMaximizeEvent,
32875 &_swigt__p_wxMemoryDC,
32876 &_swigt__p_wxMenu,
32877 &_swigt__p_wxMenuBar,
32878 &_swigt__p_wxMenuEvent,
32879 &_swigt__p_wxMenuItem,
32880 &_swigt__p_wxMetaFile,
32881 &_swigt__p_wxMetaFileDC,
32882 &_swigt__p_wxMirrorDC,
32883 &_swigt__p_wxMouseCaptureChangedEvent,
32884 &_swigt__p_wxMouseCaptureLostEvent,
32885 &_swigt__p_wxMouseEvent,
32886 &_swigt__p_wxMoveEvent,
32887 &_swigt__p_wxNativeEncodingInfo,
32888 &_swigt__p_wxNativeFontInfo,
32889 &_swigt__p_wxNativePixelData,
32890 &_swigt__p_wxNativePixelData_Accessor,
32891 &_swigt__p_wxNavigationKeyEvent,
32892 &_swigt__p_wxNcPaintEvent,
32893 &_swigt__p_wxNotifyEvent,
32894 &_swigt__p_wxObject,
32895 &_swigt__p_wxPCXHandler,
32896 &_swigt__p_wxPNGHandler,
32897 &_swigt__p_wxPNMHandler,
32898 &_swigt__p_wxPaintDC,
32899 &_swigt__p_wxPaintEvent,
32900 &_swigt__p_wxPalette,
32901 &_swigt__p_wxPaletteChangedEvent,
32902 &_swigt__p_wxPaperSize,
32903 &_swigt__p_wxPen,
32904 &_swigt__p_wxPenList,
32905 &_swigt__p_wxPixelDataBase,
32906 &_swigt__p_wxPoint,
32907 &_swigt__p_wxPostScriptDC,
32908 &_swigt__p_wxPrintData,
32909 &_swigt__p_wxPrinterDC,
32910 &_swigt__p_wxPseudoDC,
32911 &_swigt__p_wxPyApp,
32912 &_swigt__p_wxPyCommandEvent,
32913 &_swigt__p_wxPyEvent,
32914 &_swigt__p_wxPyFontEnumerator,
32915 &_swigt__p_wxPyImageHandler,
32916 &_swigt__p_wxPyLocale,
32917 &_swigt__p_wxPySizer,
32918 &_swigt__p_wxPyValidator,
32919 &_swigt__p_wxQueryNewPaletteEvent,
32920 &_swigt__p_wxRect,
32921 &_swigt__p_wxRegion,
32922 &_swigt__p_wxRegionIterator,
32923 &_swigt__p_wxRendererNative,
32924 &_swigt__p_wxRendererVersion,
32925 &_swigt__p_wxScreenDC,
32926 &_swigt__p_wxScrollEvent,
32927 &_swigt__p_wxScrollWinEvent,
32928 &_swigt__p_wxSetCursorEvent,
32929 &_swigt__p_wxShowEvent,
32930 &_swigt__p_wxSize,
32931 &_swigt__p_wxSizeEvent,
32932 &_swigt__p_wxSizer,
32933 &_swigt__p_wxSizerItem,
32934 &_swigt__p_wxSplitterRenderParams,
32935 &_swigt__p_wxStaticBoxSizer,
32936 &_swigt__p_wxStdDialogButtonSizer,
32937 &_swigt__p_wxStockGDI,
32938 &_swigt__p_wxString,
32939 &_swigt__p_wxSysColourChangedEvent,
32940 &_swigt__p_wxTIFFHandler,
32941 &_swigt__p_wxUpdateUIEvent,
32942 &_swigt__p_wxValidator,
32943 &_swigt__p_wxWindow,
32944 &_swigt__p_wxWindowCreateEvent,
32945 &_swigt__p_wxWindowDC,
32946 &_swigt__p_wxWindowDestroyEvent,
32947 &_swigt__p_wxXPMHandler,
32948 };
32949
32950 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
32951 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
32952 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
32953 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
32954 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
32955 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
32956 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
32957 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
32958 static swig_cast_info _swigc__p_wxAlphaPixelData[] = { {&_swigt__p_wxAlphaPixelData, 0, 0, 0},{0, 0, 0, 0}};
32959 static swig_cast_info _swigc__p_wxAlphaPixelData_Accessor[] = { {&_swigt__p_wxAlphaPixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
32960 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
32961 static swig_cast_info _swigc__p_wxBrush[] = { {&_swigt__p_wxBrush, 0, 0, 0},{0, 0, 0, 0}};
32962 static swig_cast_info _swigc__p_wxBrushList[] = { {&_swigt__p_wxBrushList, 0, 0, 0},{0, 0, 0, 0}};
32963 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}};
32964 static swig_cast_info _swigc__p_wxBufferedPaintDC[] = { {&_swigt__p_wxBufferedPaintDC, 0, 0, 0},{0, 0, 0, 0}};
32965 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
32966 static swig_cast_info _swigc__p_wxClientDC[] = { {&_swigt__p_wxClientDC, 0, 0, 0},{0, 0, 0, 0}};
32967 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
32968 static swig_cast_info _swigc__p_wxColourDatabase[] = { {&_swigt__p_wxColourDatabase, 0, 0, 0},{0, 0, 0, 0}};
32969 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
32970 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}};
32971 static swig_cast_info _swigc__p_wxDash[] = { {&_swigt__p_wxDash, 0, 0, 0},{0, 0, 0, 0}};
32972 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
32973 static swig_cast_info _swigc__p_wxEffects[] = { {&_swigt__p_wxEffects, 0, 0, 0},{0, 0, 0, 0}};
32974 static swig_cast_info _swigc__p_wxEncodingConverter[] = { {&_swigt__p_wxEncodingConverter, 0, 0, 0},{0, 0, 0, 0}};
32975 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
32976 static swig_cast_info _swigc__p_wxFontList[] = { {&_swigt__p_wxFontList, 0, 0, 0},{0, 0, 0, 0}};
32977 static swig_cast_info _swigc__p_wxFontMapper[] = { {&_swigt__p_wxFontMapper, 0, 0, 0},{0, 0, 0, 0}};
32978 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}};
32979 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}};
32980 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
32981 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
32982 static swig_cast_info _swigc__p_wxIconLocation[] = { {&_swigt__p_wxIconLocation, 0, 0, 0},{0, 0, 0, 0}};
32983 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
32984 static swig_cast_info _swigc__p_wxImageList[] = { {&_swigt__p_wxImageList, 0, 0, 0},{0, 0, 0, 0}};
32985 static swig_cast_info _swigc__p_wxLanguageInfo[] = { {&_swigt__p_wxLanguageInfo, 0, 0, 0},{0, 0, 0, 0}};
32986 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}};
32987 static swig_cast_info _swigc__p_wxMask[] = { {&_swigt__p_wxMask, 0, 0, 0},{0, 0, 0, 0}};
32988 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}};
32989 static swig_cast_info _swigc__p_wxMetaFile[] = { {&_swigt__p_wxMetaFile, 0, 0, 0},{0, 0, 0, 0}};
32990 static swig_cast_info _swigc__p_wxMetaFileDC[] = { {&_swigt__p_wxMetaFileDC, 0, 0, 0},{0, 0, 0, 0}};
32991 static swig_cast_info _swigc__p_wxMirrorDC[] = { {&_swigt__p_wxMirrorDC, 0, 0, 0},{0, 0, 0, 0}};
32992 static swig_cast_info _swigc__p_wxNativeEncodingInfo[] = { {&_swigt__p_wxNativeEncodingInfo, 0, 0, 0},{0, 0, 0, 0}};
32993 static swig_cast_info _swigc__p_wxNativeFontInfo[] = { {&_swigt__p_wxNativeFontInfo, 0, 0, 0},{0, 0, 0, 0}};
32994 static swig_cast_info _swigc__p_wxNativePixelData[] = { {&_swigt__p_wxNativePixelData, 0, 0, 0},{0, 0, 0, 0}};
32995 static swig_cast_info _swigc__p_wxNativePixelData_Accessor[] = { {&_swigt__p_wxNativePixelData_Accessor, 0, 0, 0},{0, 0, 0, 0}};
32996 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
32997 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32998 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32999 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
33000 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
33001 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
33002 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
33003 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
33004 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
33005 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
33006 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
33007 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
33008 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
33009 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
33010 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
33011 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
33012 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
33013 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
33014 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
33015 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
33016 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
33017 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
33018 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
33019 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
33020 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
33021 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
33022 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
33023 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
33024 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
33025 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
33026 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
33027 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
33028 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
33029 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
33030 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
33031 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
33032 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
33033 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
33034 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
33035 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
33036 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
33037 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
33038 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
33039 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
33040 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
33041 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
33042 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
33043 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
33044 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
33045 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
33046 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
33047 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
33048 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
33049 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
33050 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
33051 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
33052 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
33053 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
33054 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
33055 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
33056 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
33057 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
33058 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
33059 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
33060 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
33061 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
33062 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
33063 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
33064 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
33065 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
33066 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
33067 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
33068 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
33069 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
33070 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
33071 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
33072 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}};
33073 static swig_cast_info _swigc__p_wxPaintDC[] = { {&_swigt__p_wxPaintDC, 0, 0, 0},{0, 0, 0, 0}};
33074 static swig_cast_info _swigc__p_wxPalette[] = { {&_swigt__p_wxPalette, 0, 0, 0},{0, 0, 0, 0}};
33075 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
33076 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
33077 static swig_cast_info _swigc__p_wxPenList[] = { {&_swigt__p_wxPenList, 0, 0, 0},{0, 0, 0, 0}};
33078 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}};
33079 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
33080 static swig_cast_info _swigc__p_wxPostScriptDC[] = { {&_swigt__p_wxPostScriptDC, 0, 0, 0},{0, 0, 0, 0}};
33081 static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
33082 static swig_cast_info _swigc__p_wxPrinterDC[] = { {&_swigt__p_wxPrinterDC, 0, 0, 0},{0, 0, 0, 0}};
33083 static swig_cast_info _swigc__p_wxPseudoDC[] = { {&_swigt__p_wxPseudoDC, 0, 0, 0},{0, 0, 0, 0}};
33084 static swig_cast_info _swigc__p_wxPyFontEnumerator[] = { {&_swigt__p_wxPyFontEnumerator, 0, 0, 0},{0, 0, 0, 0}};
33085 static swig_cast_info _swigc__p_wxPyLocale[] = { {&_swigt__p_wxPyLocale, 0, 0, 0},{0, 0, 0, 0}};
33086 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
33087 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
33088 static swig_cast_info _swigc__p_wxRegionIterator[] = { {&_swigt__p_wxRegionIterator, 0, 0, 0},{0, 0, 0, 0}};
33089 static swig_cast_info _swigc__p_wxRendererNative[] = { {&_swigt__p_wxRendererNative, 0, 0, 0},{0, 0, 0, 0}};
33090 static swig_cast_info _swigc__p_wxRendererVersion[] = { {&_swigt__p_wxRendererVersion, 0, 0, 0},{0, 0, 0, 0}};
33091 static swig_cast_info _swigc__p_wxScreenDC[] = { {&_swigt__p_wxScreenDC, 0, 0, 0},{0, 0, 0, 0}};
33092 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
33093 static swig_cast_info _swigc__p_wxSplitterRenderParams[] = { {&_swigt__p_wxSplitterRenderParams, 0, 0, 0},{0, 0, 0, 0}};
33094 static swig_cast_info _swigc__p_wxStockGDI[] = { {&_swigt__p_wxStockGDI, 0, 0, 0},{0, 0, 0, 0}};
33095 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
33096 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}};
33097 static swig_cast_info _swigc__p_wxWindowDC[] = { {&_swigt__p_wxWindowDC, 0, 0, 0},{0, 0, 0, 0}};
33098
33099 static swig_cast_info *swig_cast_initial[] = {
33100 _swigc__p_buffer,
33101 _swigc__p_char,
33102 _swigc__p_double,
33103 _swigc__p_form_ops_t,
33104 _swigc__p_int,
33105 _swigc__p_unsigned_char,
33106 _swigc__p_unsigned_int,
33107 _swigc__p_unsigned_long,
33108 _swigc__p_wxANIHandler,
33109 _swigc__p_wxAcceleratorTable,
33110 _swigc__p_wxActivateEvent,
33111 _swigc__p_wxAlphaPixelData,
33112 _swigc__p_wxAlphaPixelData_Accessor,
33113 _swigc__p_wxBMPHandler,
33114 _swigc__p_wxBitmap,
33115 _swigc__p_wxBoxSizer,
33116 _swigc__p_wxBrush,
33117 _swigc__p_wxBrushList,
33118 _swigc__p_wxBufferedDC,
33119 _swigc__p_wxBufferedPaintDC,
33120 _swigc__p_wxCURHandler,
33121 _swigc__p_wxChar,
33122 _swigc__p_wxChildFocusEvent,
33123 _swigc__p_wxClientDC,
33124 _swigc__p_wxClipboardTextEvent,
33125 _swigc__p_wxCloseEvent,
33126 _swigc__p_wxColour,
33127 _swigc__p_wxColourDatabase,
33128 _swigc__p_wxCommandEvent,
33129 _swigc__p_wxContextMenuEvent,
33130 _swigc__p_wxControl,
33131 _swigc__p_wxControlWithItems,
33132 _swigc__p_wxCursor,
33133 _swigc__p_wxDC,
33134 _swigc__p_wxDash,
33135 _swigc__p_wxDateEvent,
33136 _swigc__p_wxDisplayChangedEvent,
33137 _swigc__p_wxDropFilesEvent,
33138 _swigc__p_wxDuplexMode,
33139 _swigc__p_wxEffects,
33140 _swigc__p_wxEncodingConverter,
33141 _swigc__p_wxEraseEvent,
33142 _swigc__p_wxEvent,
33143 _swigc__p_wxEvtHandler,
33144 _swigc__p_wxFSFile,
33145 _swigc__p_wxFileSystem,
33146 _swigc__p_wxFlexGridSizer,
33147 _swigc__p_wxFocusEvent,
33148 _swigc__p_wxFont,
33149 _swigc__p_wxFontList,
33150 _swigc__p_wxFontMapper,
33151 _swigc__p_wxGBSizerItem,
33152 _swigc__p_wxGDIObjListBase,
33153 _swigc__p_wxGDIObject,
33154 _swigc__p_wxGIFHandler,
33155 _swigc__p_wxGridBagSizer,
33156 _swigc__p_wxGridSizer,
33157 _swigc__p_wxICOHandler,
33158 _swigc__p_wxIcon,
33159 _swigc__p_wxIconBundle,
33160 _swigc__p_wxIconLocation,
33161 _swigc__p_wxIconizeEvent,
33162 _swigc__p_wxIdleEvent,
33163 _swigc__p_wxImage,
33164 _swigc__p_wxImageHandler,
33165 _swigc__p_wxImageList,
33166 _swigc__p_wxIndividualLayoutConstraint,
33167 _swigc__p_wxInitDialogEvent,
33168 _swigc__p_wxJPEGHandler,
33169 _swigc__p_wxKeyEvent,
33170 _swigc__p_wxLanguageInfo,
33171 _swigc__p_wxLayoutConstraints,
33172 _swigc__p_wxLocale,
33173 _swigc__p_wxMask,
33174 _swigc__p_wxMaximizeEvent,
33175 _swigc__p_wxMemoryDC,
33176 _swigc__p_wxMenu,
33177 _swigc__p_wxMenuBar,
33178 _swigc__p_wxMenuEvent,
33179 _swigc__p_wxMenuItem,
33180 _swigc__p_wxMetaFile,
33181 _swigc__p_wxMetaFileDC,
33182 _swigc__p_wxMirrorDC,
33183 _swigc__p_wxMouseCaptureChangedEvent,
33184 _swigc__p_wxMouseCaptureLostEvent,
33185 _swigc__p_wxMouseEvent,
33186 _swigc__p_wxMoveEvent,
33187 _swigc__p_wxNativeEncodingInfo,
33188 _swigc__p_wxNativeFontInfo,
33189 _swigc__p_wxNativePixelData,
33190 _swigc__p_wxNativePixelData_Accessor,
33191 _swigc__p_wxNavigationKeyEvent,
33192 _swigc__p_wxNcPaintEvent,
33193 _swigc__p_wxNotifyEvent,
33194 _swigc__p_wxObject,
33195 _swigc__p_wxPCXHandler,
33196 _swigc__p_wxPNGHandler,
33197 _swigc__p_wxPNMHandler,
33198 _swigc__p_wxPaintDC,
33199 _swigc__p_wxPaintEvent,
33200 _swigc__p_wxPalette,
33201 _swigc__p_wxPaletteChangedEvent,
33202 _swigc__p_wxPaperSize,
33203 _swigc__p_wxPen,
33204 _swigc__p_wxPenList,
33205 _swigc__p_wxPixelDataBase,
33206 _swigc__p_wxPoint,
33207 _swigc__p_wxPostScriptDC,
33208 _swigc__p_wxPrintData,
33209 _swigc__p_wxPrinterDC,
33210 _swigc__p_wxPseudoDC,
33211 _swigc__p_wxPyApp,
33212 _swigc__p_wxPyCommandEvent,
33213 _swigc__p_wxPyEvent,
33214 _swigc__p_wxPyFontEnumerator,
33215 _swigc__p_wxPyImageHandler,
33216 _swigc__p_wxPyLocale,
33217 _swigc__p_wxPySizer,
33218 _swigc__p_wxPyValidator,
33219 _swigc__p_wxQueryNewPaletteEvent,
33220 _swigc__p_wxRect,
33221 _swigc__p_wxRegion,
33222 _swigc__p_wxRegionIterator,
33223 _swigc__p_wxRendererNative,
33224 _swigc__p_wxRendererVersion,
33225 _swigc__p_wxScreenDC,
33226 _swigc__p_wxScrollEvent,
33227 _swigc__p_wxScrollWinEvent,
33228 _swigc__p_wxSetCursorEvent,
33229 _swigc__p_wxShowEvent,
33230 _swigc__p_wxSize,
33231 _swigc__p_wxSizeEvent,
33232 _swigc__p_wxSizer,
33233 _swigc__p_wxSizerItem,
33234 _swigc__p_wxSplitterRenderParams,
33235 _swigc__p_wxStaticBoxSizer,
33236 _swigc__p_wxStdDialogButtonSizer,
33237 _swigc__p_wxStockGDI,
33238 _swigc__p_wxString,
33239 _swigc__p_wxSysColourChangedEvent,
33240 _swigc__p_wxTIFFHandler,
33241 _swigc__p_wxUpdateUIEvent,
33242 _swigc__p_wxValidator,
33243 _swigc__p_wxWindow,
33244 _swigc__p_wxWindowCreateEvent,
33245 _swigc__p_wxWindowDC,
33246 _swigc__p_wxWindowDestroyEvent,
33247 _swigc__p_wxXPMHandler,
33248 };
33249
33250
33251 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33252
33253 static swig_const_info swig_const_table[] = {
33254 {0, 0, 0, 0.0, 0, 0}};
33255
33256 #ifdef __cplusplus
33257 }
33258 #endif
33259 /* -----------------------------------------------------------------------------
33260 * Type initialization:
33261 * This problem is tough by the requirement that no dynamic
33262 * memory is used. Also, since swig_type_info structures store pointers to
33263 * swig_cast_info structures and swig_cast_info structures store pointers back
33264 * to swig_type_info structures, we need some lookup code at initialization.
33265 * The idea is that swig generates all the structures that are needed.
33266 * The runtime then collects these partially filled structures.
33267 * The SWIG_InitializeModule function takes these initial arrays out of
33268 * swig_module, and does all the lookup, filling in the swig_module.types
33269 * array with the correct data and linking the correct swig_cast_info
33270 * structures together.
33271 *
33272 * The generated swig_type_info structures are assigned staticly to an initial
33273 * array. We just loop though that array, and handle each type individually.
33274 * First we lookup if this type has been already loaded, and if so, use the
33275 * loaded structure instead of the generated one. Then we have to fill in the
33276 * cast linked list. The cast data is initially stored in something like a
33277 * two-dimensional array. Each row corresponds to a type (there are the same
33278 * number of rows as there are in the swig_type_initial array). Each entry in
33279 * a column is one of the swig_cast_info structures for that type.
33280 * The cast_initial array is actually an array of arrays, because each row has
33281 * a variable number of columns. So to actually build the cast linked list,
33282 * we find the array of casts associated with the type, and loop through it
33283 * adding the casts to the list. The one last trick we need to do is making
33284 * sure the type pointer in the swig_cast_info struct is correct.
33285 *
33286 * First off, we lookup the cast->type name to see if it is already loaded.
33287 * There are three cases to handle:
33288 * 1) If the cast->type has already been loaded AND the type we are adding
33289 * casting info to has not been loaded (it is in this module), THEN we
33290 * replace the cast->type pointer with the type pointer that has already
33291 * been loaded.
33292 * 2) If BOTH types (the one we are adding casting info to, and the
33293 * cast->type) are loaded, THEN the cast info has already been loaded by
33294 * the previous module so we just ignore it.
33295 * 3) Finally, if cast->type has not already been loaded, then we add that
33296 * swig_cast_info to the linked list (because the cast->type) pointer will
33297 * be correct.
33298 * ----------------------------------------------------------------------------- */
33299
33300 #ifdef __cplusplus
33301 extern "C" {
33302 #if 0
33303 } /* c-mode */
33304 #endif
33305 #endif
33306
33307 #if 0
33308 #define SWIGRUNTIME_DEBUG
33309 #endif
33310
33311 SWIGRUNTIME void
33312 SWIG_InitializeModule(void *clientdata) {
33313 size_t i;
33314 swig_module_info *module_head;
33315 static int init_run = 0;
33316
33317 clientdata = clientdata;
33318
33319 if (init_run) return;
33320 init_run = 1;
33321
33322 /* Initialize the swig_module */
33323 swig_module.type_initial = swig_type_initial;
33324 swig_module.cast_initial = swig_cast_initial;
33325
33326 /* Try and load any already created modules */
33327 module_head = SWIG_GetModule(clientdata);
33328 if (module_head) {
33329 swig_module.next = module_head->next;
33330 module_head->next = &swig_module;
33331 } else {
33332 /* This is the first module loaded */
33333 swig_module.next = &swig_module;
33334 SWIG_SetModule(clientdata, &swig_module);
33335 }
33336
33337 /* Now work on filling in swig_module.types */
33338 #ifdef SWIGRUNTIME_DEBUG
33339 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
33340 #endif
33341 for (i = 0; i < swig_module.size; ++i) {
33342 swig_type_info *type = 0;
33343 swig_type_info *ret;
33344 swig_cast_info *cast;
33345
33346 #ifdef SWIGRUNTIME_DEBUG
33347 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
33348 #endif
33349
33350 /* if there is another module already loaded */
33351 if (swig_module.next != &swig_module) {
33352 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
33353 }
33354 if (type) {
33355 /* Overwrite clientdata field */
33356 #ifdef SWIGRUNTIME_DEBUG
33357 printf("SWIG_InitializeModule: found type %s\n", type->name);
33358 #endif
33359 if (swig_module.type_initial[i]->clientdata) {
33360 type->clientdata = swig_module.type_initial[i]->clientdata;
33361 #ifdef SWIGRUNTIME_DEBUG
33362 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
33363 #endif
33364 }
33365 } else {
33366 type = swig_module.type_initial[i];
33367 }
33368
33369 /* Insert casting types */
33370 cast = swig_module.cast_initial[i];
33371 while (cast->type) {
33372 /* Don't need to add information already in the list */
33373 ret = 0;
33374 #ifdef SWIGRUNTIME_DEBUG
33375 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
33376 #endif
33377 if (swig_module.next != &swig_module) {
33378 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
33379 #ifdef SWIGRUNTIME_DEBUG
33380 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
33381 #endif
33382 }
33383 if (ret) {
33384 if (type == swig_module.type_initial[i]) {
33385 #ifdef SWIGRUNTIME_DEBUG
33386 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
33387 #endif
33388 cast->type = ret;
33389 ret = 0;
33390 } else {
33391 /* Check for casting already in the list */
33392 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
33393 #ifdef SWIGRUNTIME_DEBUG
33394 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
33395 #endif
33396 if (!ocast) ret = 0;
33397 }
33398 }
33399
33400 if (!ret) {
33401 #ifdef SWIGRUNTIME_DEBUG
33402 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
33403 #endif
33404 if (type->cast) {
33405 type->cast->prev = cast;
33406 cast->next = type->cast;
33407 }
33408 type->cast = cast;
33409 }
33410 cast++;
33411 }
33412 /* Set entry in modules->types array equal to the type */
33413 swig_module.types[i] = type;
33414 }
33415 swig_module.types[i] = 0;
33416
33417 #ifdef SWIGRUNTIME_DEBUG
33418 printf("**** SWIG_InitializeModule: Cast List ******\n");
33419 for (i = 0; i < swig_module.size; ++i) {
33420 int j = 0;
33421 swig_cast_info *cast = swig_module.cast_initial[i];
33422 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
33423 while (cast->type) {
33424 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
33425 cast++;
33426 ++j;
33427 }
33428 printf("---- Total casts: %d\n",j);
33429 }
33430 printf("**** SWIG_InitializeModule: Cast List ******\n");
33431 #endif
33432 }
33433
33434 /* This function will propagate the clientdata field of type to
33435 * any new swig_type_info structures that have been added into the list
33436 * of equivalent types. It is like calling
33437 * SWIG_TypeClientData(type, clientdata) a second time.
33438 */
33439 SWIGRUNTIME void
33440 SWIG_PropagateClientData(void) {
33441 size_t i;
33442 swig_cast_info *equiv;
33443 static int init_run = 0;
33444
33445 if (init_run) return;
33446 init_run = 1;
33447
33448 for (i = 0; i < swig_module.size; i++) {
33449 if (swig_module.types[i]->clientdata) {
33450 equiv = swig_module.types[i]->cast;
33451 while (equiv) {
33452 if (!equiv->converter) {
33453 if (equiv->type && !equiv->type->clientdata)
33454 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
33455 }
33456 equiv = equiv->next;
33457 }
33458 }
33459 }
33460 }
33461
33462 #ifdef __cplusplus
33463 #if 0
33464 {
33465 /* c-mode */
33466 #endif
33467 }
33468 #endif
33469
33470
33471
33472 #ifdef __cplusplus
33473 extern "C" {
33474 #endif
33475
33476 /* Python-specific SWIG API */
33477 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33478 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33479 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33480
33481 /* -----------------------------------------------------------------------------
33482 * global variable support code.
33483 * ----------------------------------------------------------------------------- */
33484
33485 typedef struct swig_globalvar {
33486 char *name; /* Name of global variable */
33487 PyObject *(*get_attr)(void); /* Return the current value */
33488 int (*set_attr)(PyObject *); /* Set the value */
33489 struct swig_globalvar *next;
33490 } swig_globalvar;
33491
33492 typedef struct swig_varlinkobject {
33493 PyObject_HEAD
33494 swig_globalvar *vars;
33495 } swig_varlinkobject;
33496
33497 SWIGINTERN PyObject *
33498 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
33499 return PyString_FromString("<Swig global variables>");
33500 }
33501
33502 SWIGINTERN PyObject *
33503 swig_varlink_str(swig_varlinkobject *v) {
33504 PyObject *str = PyString_FromString("(");
33505 swig_globalvar *var;
33506 for (var = v->vars; var; var=var->next) {
33507 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
33508 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
33509 }
33510 PyString_ConcatAndDel(&str,PyString_FromString(")"));
33511 return str;
33512 }
33513
33514 SWIGINTERN int
33515 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
33516 PyObject *str = swig_varlink_str(v);
33517 fprintf(fp,"Swig global variables ");
33518 fprintf(fp,"%s\n", PyString_AsString(str));
33519 Py_DECREF(str);
33520 return 0;
33521 }
33522
33523 SWIGINTERN void
33524 swig_varlink_dealloc(swig_varlinkobject *v) {
33525 swig_globalvar *var = v->vars;
33526 while (var) {
33527 swig_globalvar *n = var->next;
33528 free(var->name);
33529 free(var);
33530 var = n;
33531 }
33532 }
33533
33534 SWIGINTERN PyObject *
33535 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33536 PyObject *res = NULL;
33537 swig_globalvar *var = v->vars;
33538 while (var) {
33539 if (strcmp(var->name,n) == 0) {
33540 res = (*var->get_attr)();
33541 break;
33542 }
33543 var = var->next;
33544 }
33545 if (res == NULL && !PyErr_Occurred()) {
33546 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33547 }
33548 return res;
33549 }
33550
33551 SWIGINTERN int
33552 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33553 int res = 1;
33554 swig_globalvar *var = v->vars;
33555 while (var) {
33556 if (strcmp(var->name,n) == 0) {
33557 res = (*var->set_attr)(p);
33558 break;
33559 }
33560 var = var->next;
33561 }
33562 if (res == 1 && !PyErr_Occurred()) {
33563 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33564 }
33565 return res;
33566 }
33567
33568 SWIGINTERN PyTypeObject*
33569 swig_varlink_type(void) {
33570 static char varlink__doc__[] = "Swig var link object";
33571 static PyTypeObject varlink_type;
33572 static int type_init = 0;
33573 if (!type_init) {
33574 const PyTypeObject tmp
33575 = {
33576 PyObject_HEAD_INIT(NULL)
33577 0, /* Number of items in variable part (ob_size) */
33578 (char *)"swigvarlink", /* Type name (tp_name) */
33579 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33580 0, /* Itemsize (tp_itemsize) */
33581 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
33582 (printfunc) swig_varlink_print, /* Print (tp_print) */
33583 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33584 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33585 0, /* tp_compare */
33586 (reprfunc) swig_varlink_repr, /* tp_repr */
33587 0, /* tp_as_number */
33588 0, /* tp_as_sequence */
33589 0, /* tp_as_mapping */
33590 0, /* tp_hash */
33591 0, /* tp_call */
33592 (reprfunc)swig_varlink_str, /* tp_str */
33593 0, /* tp_getattro */
33594 0, /* tp_setattro */
33595 0, /* tp_as_buffer */
33596 0, /* tp_flags */
33597 varlink__doc__, /* tp_doc */
33598 0, /* tp_traverse */
33599 0, /* tp_clear */
33600 0, /* tp_richcompare */
33601 0, /* tp_weaklistoffset */
33602 #if PY_VERSION_HEX >= 0x02020000
33603 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33604 #endif
33605 #if PY_VERSION_HEX >= 0x02030000
33606 0, /* tp_del */
33607 #endif
33608 #ifdef COUNT_ALLOCS
33609 0,0,0,0 /* tp_alloc -> tp_next */
33610 #endif
33611 };
33612 varlink_type = tmp;
33613 varlink_type.ob_type = &PyType_Type;
33614 type_init = 1;
33615 }
33616 return &varlink_type;
33617 }
33618
33619 /* Create a variable linking object for use later */
33620 SWIGINTERN PyObject *
33621 SWIG_Python_newvarlink(void) {
33622 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
33623 if (result) {
33624 result->vars = 0;
33625 }
33626 return ((PyObject*) result);
33627 }
33628
33629 SWIGINTERN void
33630 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33631 swig_varlinkobject *v = (swig_varlinkobject *) p;
33632 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33633 if (gv) {
33634 size_t size = strlen(name)+1;
33635 gv->name = (char *)malloc(size);
33636 if (gv->name) {
33637 strncpy(gv->name,name,size);
33638 gv->get_attr = get_attr;
33639 gv->set_attr = set_attr;
33640 gv->next = v->vars;
33641 }
33642 }
33643 v->vars = gv;
33644 }
33645
33646 SWIGINTERN PyObject *
33647 SWIG_globals() {
33648 static PyObject *_SWIG_globals = 0;
33649 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
33650 return _SWIG_globals;
33651 }
33652
33653 /* -----------------------------------------------------------------------------
33654 * constants/methods manipulation
33655 * ----------------------------------------------------------------------------- */
33656
33657 /* Install Constants */
33658 SWIGINTERN void
33659 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33660 PyObject *obj = 0;
33661 size_t i;
33662 for (i = 0; constants[i].type; ++i) {
33663 switch(constants[i].type) {
33664 case SWIG_PY_POINTER:
33665 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33666 break;
33667 case SWIG_PY_BINARY:
33668 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33669 break;
33670 default:
33671 obj = 0;
33672 break;
33673 }
33674 if (obj) {
33675 PyDict_SetItemString(d, constants[i].name, obj);
33676 Py_DECREF(obj);
33677 }
33678 }
33679 }
33680
33681 /* -----------------------------------------------------------------------------*/
33682 /* Fix SwigMethods to carry the callback ptrs when needed */
33683 /* -----------------------------------------------------------------------------*/
33684
33685 SWIGINTERN void
33686 SWIG_Python_FixMethods(PyMethodDef *methods,
33687 swig_const_info *const_table,
33688 swig_type_info **types,
33689 swig_type_info **types_initial) {
33690 size_t i;
33691 for (i = 0; methods[i].ml_name; ++i) {
33692 const char *c = methods[i].ml_doc;
33693 if (c && (c = strstr(c, "swig_ptr: "))) {
33694 int j;
33695 swig_const_info *ci = 0;
33696 const char *name = c + 10;
33697 for (j = 0; const_table[j].type; ++j) {
33698 if (strncmp(const_table[j].name, name,
33699 strlen(const_table[j].name)) == 0) {
33700 ci = &(const_table[j]);
33701 break;
33702 }
33703 }
33704 if (ci) {
33705 size_t shift = (ci->ptype) - types;
33706 swig_type_info *ty = types_initial[shift];
33707 size_t ldoc = (c - methods[i].ml_doc);
33708 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33709 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33710 if (ndoc) {
33711 char *buff = ndoc;
33712 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
33713 if (ptr) {
33714 strncpy(buff, methods[i].ml_doc, ldoc);
33715 buff += ldoc;
33716 strncpy(buff, "swig_ptr: ", 10);
33717 buff += 10;
33718 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33719 methods[i].ml_doc = ndoc;
33720 }
33721 }
33722 }
33723 }
33724 }
33725 }
33726
33727 #ifdef __cplusplus
33728 }
33729 #endif
33730
33731 /* -----------------------------------------------------------------------------*
33732 * Partial Init method
33733 * -----------------------------------------------------------------------------*/
33734
33735 #ifdef __cplusplus
33736 extern "C"
33737 #endif
33738 SWIGEXPORT void SWIG_init(void) {
33739 PyObject *m, *d;
33740
33741 /* Fix SwigMethods to carry the callback ptrs when needed */
33742 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
33743
33744 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33745 d = PyModule_GetDict(m);
33746
33747 SWIG_InitializeModule(0);
33748 SWIG_InstallConstants(d,swig_const_table);
33749
33750
33751 SWIG_Python_SetConstant(d, "C2S_NAME",SWIG_From_int(static_cast< int >(wxC2S_NAME)));
33752 SWIG_Python_SetConstant(d, "C2S_CSS_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_CSS_SYNTAX)));
33753 SWIG_Python_SetConstant(d, "C2S_HTML_SYNTAX",SWIG_From_int(static_cast< int >(wxC2S_HTML_SYNTAX)));
33754 SWIG_Python_SetConstant(d, "ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxALPHA_TRANSPARENT)));
33755 SWIG_Python_SetConstant(d, "ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxALPHA_OPAQUE)));
33756 SWIG_Python_SetConstant(d, "OutRegion",SWIG_From_int(static_cast< int >(wxOutRegion)));
33757 SWIG_Python_SetConstant(d, "PartRegion",SWIG_From_int(static_cast< int >(wxPartRegion)));
33758 SWIG_Python_SetConstant(d, "InRegion",SWIG_From_int(static_cast< int >(wxInRegion)));
33759 SWIG_Python_SetConstant(d, "FONTFAMILY_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DEFAULT)));
33760 SWIG_Python_SetConstant(d, "FONTFAMILY_DECORATIVE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_DECORATIVE)));
33761 SWIG_Python_SetConstant(d, "FONTFAMILY_ROMAN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_ROMAN)));
33762 SWIG_Python_SetConstant(d, "FONTFAMILY_SCRIPT",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SCRIPT)));
33763 SWIG_Python_SetConstant(d, "FONTFAMILY_SWISS",SWIG_From_int(static_cast< int >(wxFONTFAMILY_SWISS)));
33764 SWIG_Python_SetConstant(d, "FONTFAMILY_MODERN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MODERN)));
33765 SWIG_Python_SetConstant(d, "FONTFAMILY_TELETYPE",SWIG_From_int(static_cast< int >(wxFONTFAMILY_TELETYPE)));
33766 SWIG_Python_SetConstant(d, "FONTFAMILY_MAX",SWIG_From_int(static_cast< int >(wxFONTFAMILY_MAX)));
33767 SWIG_Python_SetConstant(d, "FONTFAMILY_UNKNOWN",SWIG_From_int(static_cast< int >(wxFONTFAMILY_UNKNOWN)));
33768 SWIG_Python_SetConstant(d, "FONTSTYLE_NORMAL",SWIG_From_int(static_cast< int >(wxFONTSTYLE_NORMAL)));
33769 SWIG_Python_SetConstant(d, "FONTSTYLE_ITALIC",SWIG_From_int(static_cast< int >(wxFONTSTYLE_ITALIC)));
33770 SWIG_Python_SetConstant(d, "FONTSTYLE_SLANT",SWIG_From_int(static_cast< int >(wxFONTSTYLE_SLANT)));
33771 SWIG_Python_SetConstant(d, "FONTSTYLE_MAX",SWIG_From_int(static_cast< int >(wxFONTSTYLE_MAX)));
33772 SWIG_Python_SetConstant(d, "FONTWEIGHT_NORMAL",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_NORMAL)));
33773 SWIG_Python_SetConstant(d, "FONTWEIGHT_LIGHT",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_LIGHT)));
33774 SWIG_Python_SetConstant(d, "FONTWEIGHT_BOLD",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_BOLD)));
33775 SWIG_Python_SetConstant(d, "FONTWEIGHT_MAX",SWIG_From_int(static_cast< int >(wxFONTWEIGHT_MAX)));
33776 SWIG_Python_SetConstant(d, "FONTFLAG_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTFLAG_DEFAULT)));
33777 SWIG_Python_SetConstant(d, "FONTFLAG_ITALIC",SWIG_From_int(static_cast< int >(wxFONTFLAG_ITALIC)));
33778 SWIG_Python_SetConstant(d, "FONTFLAG_SLANT",SWIG_From_int(static_cast< int >(wxFONTFLAG_SLANT)));
33779 SWIG_Python_SetConstant(d, "FONTFLAG_LIGHT",SWIG_From_int(static_cast< int >(wxFONTFLAG_LIGHT)));
33780 SWIG_Python_SetConstant(d, "FONTFLAG_BOLD",SWIG_From_int(static_cast< int >(wxFONTFLAG_BOLD)));
33781 SWIG_Python_SetConstant(d, "FONTFLAG_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_ANTIALIASED)));
33782 SWIG_Python_SetConstant(d, "FONTFLAG_NOT_ANTIALIASED",SWIG_From_int(static_cast< int >(wxFONTFLAG_NOT_ANTIALIASED)));
33783 SWIG_Python_SetConstant(d, "FONTFLAG_UNDERLINED",SWIG_From_int(static_cast< int >(wxFONTFLAG_UNDERLINED)));
33784 SWIG_Python_SetConstant(d, "FONTFLAG_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxFONTFLAG_STRIKETHROUGH)));
33785 SWIG_Python_SetConstant(d, "FONTFLAG_MASK",SWIG_From_int(static_cast< int >(wxFONTFLAG_MASK)));
33786 SWIG_Python_SetConstant(d, "FONTENCODING_SYSTEM",SWIG_From_int(static_cast< int >(wxFONTENCODING_SYSTEM)));
33787 SWIG_Python_SetConstant(d, "FONTENCODING_DEFAULT",SWIG_From_int(static_cast< int >(wxFONTENCODING_DEFAULT)));
33788 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_1",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_1)));
33789 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_2",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_2)));
33790 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_3",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_3)));
33791 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_4",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_4)));
33792 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_5",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_5)));
33793 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_6",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_6)));
33794 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_7",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_7)));
33795 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_8",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_8)));
33796 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_9",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_9)));
33797 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_10",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_10)));
33798 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_11",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_11)));
33799 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_12",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_12)));
33800 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_13",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_13)));
33801 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_14",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_14)));
33802 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_15",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_15)));
33803 SWIG_Python_SetConstant(d, "FONTENCODING_ISO8859_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_ISO8859_MAX)));
33804 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8)));
33805 SWIG_Python_SetConstant(d, "FONTENCODING_KOI8_U",SWIG_From_int(static_cast< int >(wxFONTENCODING_KOI8_U)));
33806 SWIG_Python_SetConstant(d, "FONTENCODING_ALTERNATIVE",SWIG_From_int(static_cast< int >(wxFONTENCODING_ALTERNATIVE)));
33807 SWIG_Python_SetConstant(d, "FONTENCODING_BULGARIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_BULGARIAN)));
33808 SWIG_Python_SetConstant(d, "FONTENCODING_CP437",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP437)));
33809 SWIG_Python_SetConstant(d, "FONTENCODING_CP850",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP850)));
33810 SWIG_Python_SetConstant(d, "FONTENCODING_CP852",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP852)));
33811 SWIG_Python_SetConstant(d, "FONTENCODING_CP855",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP855)));
33812 SWIG_Python_SetConstant(d, "FONTENCODING_CP866",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP866)));
33813 SWIG_Python_SetConstant(d, "FONTENCODING_CP874",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP874)));
33814 SWIG_Python_SetConstant(d, "FONTENCODING_CP932",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP932)));
33815 SWIG_Python_SetConstant(d, "FONTENCODING_CP936",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP936)));
33816 SWIG_Python_SetConstant(d, "FONTENCODING_CP949",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP949)));
33817 SWIG_Python_SetConstant(d, "FONTENCODING_CP950",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP950)));
33818 SWIG_Python_SetConstant(d, "FONTENCODING_CP1250",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1250)));
33819 SWIG_Python_SetConstant(d, "FONTENCODING_CP1251",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1251)));
33820 SWIG_Python_SetConstant(d, "FONTENCODING_CP1252",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1252)));
33821 SWIG_Python_SetConstant(d, "FONTENCODING_CP1253",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1253)));
33822 SWIG_Python_SetConstant(d, "FONTENCODING_CP1254",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1254)));
33823 SWIG_Python_SetConstant(d, "FONTENCODING_CP1255",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1255)));
33824 SWIG_Python_SetConstant(d, "FONTENCODING_CP1256",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1256)));
33825 SWIG_Python_SetConstant(d, "FONTENCODING_CP1257",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP1257)));
33826 SWIG_Python_SetConstant(d, "FONTENCODING_CP12_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_CP12_MAX)));
33827 SWIG_Python_SetConstant(d, "FONTENCODING_UTF7",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF7)));
33828 SWIG_Python_SetConstant(d, "FONTENCODING_UTF8",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF8)));
33829 SWIG_Python_SetConstant(d, "FONTENCODING_EUC_JP",SWIG_From_int(static_cast< int >(wxFONTENCODING_EUC_JP)));
33830 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16BE)));
33831 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16LE)));
33832 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32BE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32BE)));
33833 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32LE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32LE)));
33834 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMAN)));
33835 SWIG_Python_SetConstant(d, "FONTENCODING_MACJAPANESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACJAPANESE)));
33836 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESETRAD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESETRAD)));
33837 SWIG_Python_SetConstant(d, "FONTENCODING_MACKOREAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKOREAN)));
33838 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABIC)));
33839 SWIG_Python_SetConstant(d, "FONTENCODING_MACHEBREW",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACHEBREW)));
33840 SWIG_Python_SetConstant(d, "FONTENCODING_MACGREEK",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGREEK)));
33841 SWIG_Python_SetConstant(d, "FONTENCODING_MACCYRILLIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCYRILLIC)));
33842 SWIG_Python_SetConstant(d, "FONTENCODING_MACDEVANAGARI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDEVANAGARI)));
33843 SWIG_Python_SetConstant(d, "FONTENCODING_MACGURMUKHI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGURMUKHI)));
33844 SWIG_Python_SetConstant(d, "FONTENCODING_MACGUJARATI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGUJARATI)));
33845 SWIG_Python_SetConstant(d, "FONTENCODING_MACORIYA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACORIYA)));
33846 SWIG_Python_SetConstant(d, "FONTENCODING_MACBENGALI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBENGALI)));
33847 SWIG_Python_SetConstant(d, "FONTENCODING_MACTAMIL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTAMIL)));
33848 SWIG_Python_SetConstant(d, "FONTENCODING_MACTELUGU",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTELUGU)));
33849 SWIG_Python_SetConstant(d, "FONTENCODING_MACKANNADA",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKANNADA)));
33850 SWIG_Python_SetConstant(d, "FONTENCODING_MACMALAJALAM",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMALAJALAM)));
33851 SWIG_Python_SetConstant(d, "FONTENCODING_MACSINHALESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSINHALESE)));
33852 SWIG_Python_SetConstant(d, "FONTENCODING_MACBURMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACBURMESE)));
33853 SWIG_Python_SetConstant(d, "FONTENCODING_MACKHMER",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKHMER)));
33854 SWIG_Python_SetConstant(d, "FONTENCODING_MACTHAI",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTHAI)));
33855 SWIG_Python_SetConstant(d, "FONTENCODING_MACLAOTIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACLAOTIAN)));
33856 SWIG_Python_SetConstant(d, "FONTENCODING_MACGEORGIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGEORGIAN)));
33857 SWIG_Python_SetConstant(d, "FONTENCODING_MACARMENIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARMENIAN)));
33858 SWIG_Python_SetConstant(d, "FONTENCODING_MACCHINESESIMP",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCHINESESIMP)));
33859 SWIG_Python_SetConstant(d, "FONTENCODING_MACTIBETAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTIBETAN)));
33860 SWIG_Python_SetConstant(d, "FONTENCODING_MACMONGOLIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMONGOLIAN)));
33861 SWIG_Python_SetConstant(d, "FONTENCODING_MACETHIOPIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACETHIOPIC)));
33862 SWIG_Python_SetConstant(d, "FONTENCODING_MACCENTRALEUR",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCENTRALEUR)));
33863 SWIG_Python_SetConstant(d, "FONTENCODING_MACVIATNAMESE",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACVIATNAMESE)));
33864 SWIG_Python_SetConstant(d, "FONTENCODING_MACARABICEXT",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACARABICEXT)));
33865 SWIG_Python_SetConstant(d, "FONTENCODING_MACSYMBOL",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACSYMBOL)));
33866 SWIG_Python_SetConstant(d, "FONTENCODING_MACDINGBATS",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACDINGBATS)));
33867 SWIG_Python_SetConstant(d, "FONTENCODING_MACTURKISH",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACTURKISH)));
33868 SWIG_Python_SetConstant(d, "FONTENCODING_MACCROATIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCROATIAN)));
33869 SWIG_Python_SetConstant(d, "FONTENCODING_MACICELANDIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACICELANDIC)));
33870 SWIG_Python_SetConstant(d, "FONTENCODING_MACROMANIAN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACROMANIAN)));
33871 SWIG_Python_SetConstant(d, "FONTENCODING_MACCELTIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACCELTIC)));
33872 SWIG_Python_SetConstant(d, "FONTENCODING_MACGAELIC",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACGAELIC)));
33873 SWIG_Python_SetConstant(d, "FONTENCODING_MACKEYBOARD",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACKEYBOARD)));
33874 SWIG_Python_SetConstant(d, "FONTENCODING_MACMIN",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMIN)));
33875 SWIG_Python_SetConstant(d, "FONTENCODING_MACMAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MACMAX)));
33876 SWIG_Python_SetConstant(d, "FONTENCODING_MAX",SWIG_From_int(static_cast< int >(wxFONTENCODING_MAX)));
33877 SWIG_Python_SetConstant(d, "FONTENCODING_UTF16",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF16)));
33878 SWIG_Python_SetConstant(d, "FONTENCODING_UTF32",SWIG_From_int(static_cast< int >(wxFONTENCODING_UTF32)));
33879 SWIG_Python_SetConstant(d, "FONTENCODING_UNICODE",SWIG_From_int(static_cast< int >(wxFONTENCODING_UNICODE)));
33880 SWIG_Python_SetConstant(d, "FONTENCODING_GB2312",SWIG_From_int(static_cast< int >(wxFONTENCODING_GB2312)));
33881 SWIG_Python_SetConstant(d, "FONTENCODING_BIG5",SWIG_From_int(static_cast< int >(wxFONTENCODING_BIG5)));
33882 SWIG_Python_SetConstant(d, "FONTENCODING_SHIFT_JIS",SWIG_From_int(static_cast< int >(wxFONTENCODING_SHIFT_JIS)));
33883
33884 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
33885
33886 SWIG_Python_SetConstant(d, "LANGUAGE_DEFAULT",SWIG_From_int(static_cast< int >(wxLANGUAGE_DEFAULT)));
33887 SWIG_Python_SetConstant(d, "LANGUAGE_UNKNOWN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UNKNOWN)));
33888 SWIG_Python_SetConstant(d, "LANGUAGE_ABKHAZIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ABKHAZIAN)));
33889 SWIG_Python_SetConstant(d, "LANGUAGE_AFAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFAR)));
33890 SWIG_Python_SetConstant(d, "LANGUAGE_AFRIKAANS",SWIG_From_int(static_cast< int >(wxLANGUAGE_AFRIKAANS)));
33891 SWIG_Python_SetConstant(d, "LANGUAGE_ALBANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ALBANIAN)));
33892 SWIG_Python_SetConstant(d, "LANGUAGE_AMHARIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AMHARIC)));
33893 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC)));
33894 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_ALGERIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_ALGERIA)));
33895 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_BAHRAIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_BAHRAIN)));
33896 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_EGYPT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_EGYPT)));
33897 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_IRAQ",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_IRAQ)));
33898 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_JORDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_JORDAN)));
33899 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_KUWAIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_KUWAIT)));
33900 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LEBANON",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LEBANON)));
33901 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_LIBYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_LIBYA)));
33902 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_MOROCCO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_MOROCCO)));
33903 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_OMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_OMAN)));
33904 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_QATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_QATAR)));
33905 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SAUDI_ARABIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
33906 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SUDAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SUDAN)));
33907 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_SYRIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_SYRIA)));
33908 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_TUNISIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_TUNISIA)));
33909 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_UAE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_UAE)));
33910 SWIG_Python_SetConstant(d, "LANGUAGE_ARABIC_YEMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARABIC_YEMEN)));
33911 SWIG_Python_SetConstant(d, "LANGUAGE_ARMENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ARMENIAN)));
33912 SWIG_Python_SetConstant(d, "LANGUAGE_ASSAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ASSAMESE)));
33913 SWIG_Python_SetConstant(d, "LANGUAGE_AYMARA",SWIG_From_int(static_cast< int >(wxLANGUAGE_AYMARA)));
33914 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI)));
33915 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_CYRILLIC)));
33916 SWIG_Python_SetConstant(d, "LANGUAGE_AZERI_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_AZERI_LATIN)));
33917 SWIG_Python_SetConstant(d, "LANGUAGE_BASHKIR",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASHKIR)));
33918 SWIG_Python_SetConstant(d, "LANGUAGE_BASQUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BASQUE)));
33919 SWIG_Python_SetConstant(d, "LANGUAGE_BELARUSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BELARUSIAN)));
33920 SWIG_Python_SetConstant(d, "LANGUAGE_BENGALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BENGALI)));
33921 SWIG_Python_SetConstant(d, "LANGUAGE_BHUTANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BHUTANI)));
33922 SWIG_Python_SetConstant(d, "LANGUAGE_BIHARI",SWIG_From_int(static_cast< int >(wxLANGUAGE_BIHARI)));
33923 SWIG_Python_SetConstant(d, "LANGUAGE_BISLAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_BISLAMA)));
33924 SWIG_Python_SetConstant(d, "LANGUAGE_BRETON",SWIG_From_int(static_cast< int >(wxLANGUAGE_BRETON)));
33925 SWIG_Python_SetConstant(d, "LANGUAGE_BULGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_BULGARIAN)));
33926 SWIG_Python_SetConstant(d, "LANGUAGE_BURMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_BURMESE)));
33927 SWIG_Python_SetConstant(d, "LANGUAGE_CAMBODIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CAMBODIAN)));
33928 SWIG_Python_SetConstant(d, "LANGUAGE_CATALAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CATALAN)));
33929 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE)));
33930 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SIMPLIFIED",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SIMPLIFIED)));
33931 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TRADITIONAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TRADITIONAL)));
33932 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_HONGKONG",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_HONGKONG)));
33933 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_MACAU",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_MACAU)));
33934 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_SINGAPORE",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_SINGAPORE)));
33935 SWIG_Python_SetConstant(d, "LANGUAGE_CHINESE_TAIWAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CHINESE_TAIWAN)));
33936 SWIG_Python_SetConstant(d, "LANGUAGE_CORSICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CORSICAN)));
33937 SWIG_Python_SetConstant(d, "LANGUAGE_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_CROATIAN)));
33938 SWIG_Python_SetConstant(d, "LANGUAGE_CZECH",SWIG_From_int(static_cast< int >(wxLANGUAGE_CZECH)));
33939 SWIG_Python_SetConstant(d, "LANGUAGE_DANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DANISH)));
33940 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH)));
33941 SWIG_Python_SetConstant(d, "LANGUAGE_DUTCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_DUTCH_BELGIAN)));
33942 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH)));
33943 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_UK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_UK)));
33944 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_US)));
33945 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_AUSTRALIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_AUSTRALIA)));
33946 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BELIZE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BELIZE)));
33947 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_BOTSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_BOTSWANA)));
33948 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CANADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CANADA)));
33949 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_CARIBBEAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_CARIBBEAN)));
33950 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_DENMARK",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_DENMARK)));
33951 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_EIRE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_EIRE)));
33952 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_JAMAICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_JAMAICA)));
33953 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_NEW_ZEALAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
33954 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_PHILIPPINES",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_PHILIPPINES)));
33955 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_SOUTH_AFRICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
33956 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_TRINIDAD",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_TRINIDAD)));
33957 SWIG_Python_SetConstant(d, "LANGUAGE_ENGLISH_ZIMBABWE",SWIG_From_int(static_cast< int >(wxLANGUAGE_ENGLISH_ZIMBABWE)));
33958 SWIG_Python_SetConstant(d, "LANGUAGE_ESPERANTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESPERANTO)));
33959 SWIG_Python_SetConstant(d, "LANGUAGE_ESTONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ESTONIAN)));
33960 SWIG_Python_SetConstant(d, "LANGUAGE_FAEROESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_FAEROESE)));
33961 SWIG_Python_SetConstant(d, "LANGUAGE_FARSI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FARSI)));
33962 SWIG_Python_SetConstant(d, "LANGUAGE_FIJI",SWIG_From_int(static_cast< int >(wxLANGUAGE_FIJI)));
33963 SWIG_Python_SetConstant(d, "LANGUAGE_FINNISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FINNISH)));
33964 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH)));
33965 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_BELGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_BELGIAN)));
33966 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_CANADIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_CANADIAN)));
33967 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_LUXEMBOURG)));
33968 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_MONACO",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_MONACO)));
33969 SWIG_Python_SetConstant(d, "LANGUAGE_FRENCH_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRENCH_SWISS)));
33970 SWIG_Python_SetConstant(d, "LANGUAGE_FRISIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_FRISIAN)));
33971 SWIG_Python_SetConstant(d, "LANGUAGE_GALICIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GALICIAN)));
33972 SWIG_Python_SetConstant(d, "LANGUAGE_GEORGIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GEORGIAN)));
33973 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN)));
33974 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_AUSTRIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_AUSTRIAN)));
33975 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_BELGIUM",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_BELGIUM)));
33976 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LIECHTENSTEIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
33977 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_LUXEMBOURG",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_LUXEMBOURG)));
33978 SWIG_Python_SetConstant(d, "LANGUAGE_GERMAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_GERMAN_SWISS)));
33979 SWIG_Python_SetConstant(d, "LANGUAGE_GREEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREEK)));
33980 SWIG_Python_SetConstant(d, "LANGUAGE_GREENLANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_GREENLANDIC)));
33981 SWIG_Python_SetConstant(d, "LANGUAGE_GUARANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUARANI)));
33982 SWIG_Python_SetConstant(d, "LANGUAGE_GUJARATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_GUJARATI)));
33983 SWIG_Python_SetConstant(d, "LANGUAGE_HAUSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_HAUSA)));
33984 SWIG_Python_SetConstant(d, "LANGUAGE_HEBREW",SWIG_From_int(static_cast< int >(wxLANGUAGE_HEBREW)));
33985 SWIG_Python_SetConstant(d, "LANGUAGE_HINDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_HINDI)));
33986 SWIG_Python_SetConstant(d, "LANGUAGE_HUNGARIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_HUNGARIAN)));
33987 SWIG_Python_SetConstant(d, "LANGUAGE_ICELANDIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_ICELANDIC)));
33988 SWIG_Python_SetConstant(d, "LANGUAGE_INDONESIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_INDONESIAN)));
33989 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUA)));
33990 SWIG_Python_SetConstant(d, "LANGUAGE_INTERLINGUE",SWIG_From_int(static_cast< int >(wxLANGUAGE_INTERLINGUE)));
33991 SWIG_Python_SetConstant(d, "LANGUAGE_INUKTITUT",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUKTITUT)));
33992 SWIG_Python_SetConstant(d, "LANGUAGE_INUPIAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_INUPIAK)));
33993 SWIG_Python_SetConstant(d, "LANGUAGE_IRISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_IRISH)));
33994 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN)));
33995 SWIG_Python_SetConstant(d, "LANGUAGE_ITALIAN_SWISS",SWIG_From_int(static_cast< int >(wxLANGUAGE_ITALIAN_SWISS)));
33996 SWIG_Python_SetConstant(d, "LANGUAGE_JAPANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAPANESE)));
33997 SWIG_Python_SetConstant(d, "LANGUAGE_JAVANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_JAVANESE)));
33998 SWIG_Python_SetConstant(d, "LANGUAGE_KANNADA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KANNADA)));
33999 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI)));
34000 SWIG_Python_SetConstant(d, "LANGUAGE_KASHMIRI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KASHMIRI_INDIA)));
34001 SWIG_Python_SetConstant(d, "LANGUAGE_KAZAKH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KAZAKH)));
34002 SWIG_Python_SetConstant(d, "LANGUAGE_KERNEWEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_KERNEWEK)));
34003 SWIG_Python_SetConstant(d, "LANGUAGE_KINYARWANDA",SWIG_From_int(static_cast< int >(wxLANGUAGE_KINYARWANDA)));
34004 SWIG_Python_SetConstant(d, "LANGUAGE_KIRGHIZ",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRGHIZ)));
34005 SWIG_Python_SetConstant(d, "LANGUAGE_KIRUNDI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KIRUNDI)));
34006 SWIG_Python_SetConstant(d, "LANGUAGE_KONKANI",SWIG_From_int(static_cast< int >(wxLANGUAGE_KONKANI)));
34007 SWIG_Python_SetConstant(d, "LANGUAGE_KOREAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_KOREAN)));
34008 SWIG_Python_SetConstant(d, "LANGUAGE_KURDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_KURDISH)));
34009 SWIG_Python_SetConstant(d, "LANGUAGE_LAOTHIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LAOTHIAN)));
34010 SWIG_Python_SetConstant(d, "LANGUAGE_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATIN)));
34011 SWIG_Python_SetConstant(d, "LANGUAGE_LATVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LATVIAN)));
34012 SWIG_Python_SetConstant(d, "LANGUAGE_LINGALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_LINGALA)));
34013 SWIG_Python_SetConstant(d, "LANGUAGE_LITHUANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_LITHUANIAN)));
34014 SWIG_Python_SetConstant(d, "LANGUAGE_MACEDONIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MACEDONIAN)));
34015 SWIG_Python_SetConstant(d, "LANGUAGE_MALAGASY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAGASY)));
34016 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY)));
34017 SWIG_Python_SetConstant(d, "LANGUAGE_MALAYALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAYALAM)));
34018 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_BRUNEI_DARUSSALAM",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
34019 SWIG_Python_SetConstant(d, "LANGUAGE_MALAY_MALAYSIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALAY_MALAYSIA)));
34020 SWIG_Python_SetConstant(d, "LANGUAGE_MALTESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_MALTESE)));
34021 SWIG_Python_SetConstant(d, "LANGUAGE_MANIPURI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MANIPURI)));
34022 SWIG_Python_SetConstant(d, "LANGUAGE_MAORI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MAORI)));
34023 SWIG_Python_SetConstant(d, "LANGUAGE_MARATHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_MARATHI)));
34024 SWIG_Python_SetConstant(d, "LANGUAGE_MOLDAVIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MOLDAVIAN)));
34025 SWIG_Python_SetConstant(d, "LANGUAGE_MONGOLIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_MONGOLIAN)));
34026 SWIG_Python_SetConstant(d, "LANGUAGE_NAURU",SWIG_From_int(static_cast< int >(wxLANGUAGE_NAURU)));
34027 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI)));
34028 SWIG_Python_SetConstant(d, "LANGUAGE_NEPALI_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_NEPALI_INDIA)));
34029 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_BOKMAL",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_BOKMAL)));
34030 SWIG_Python_SetConstant(d, "LANGUAGE_NORWEGIAN_NYNORSK",SWIG_From_int(static_cast< int >(wxLANGUAGE_NORWEGIAN_NYNORSK)));
34031 SWIG_Python_SetConstant(d, "LANGUAGE_OCCITAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_OCCITAN)));
34032 SWIG_Python_SetConstant(d, "LANGUAGE_ORIYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_ORIYA)));
34033 SWIG_Python_SetConstant(d, "LANGUAGE_OROMO",SWIG_From_int(static_cast< int >(wxLANGUAGE_OROMO)));
34034 SWIG_Python_SetConstant(d, "LANGUAGE_PASHTO",SWIG_From_int(static_cast< int >(wxLANGUAGE_PASHTO)));
34035 SWIG_Python_SetConstant(d, "LANGUAGE_POLISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_POLISH)));
34036 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE)));
34037 SWIG_Python_SetConstant(d, "LANGUAGE_PORTUGUESE_BRAZILIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
34038 SWIG_Python_SetConstant(d, "LANGUAGE_PUNJABI",SWIG_From_int(static_cast< int >(wxLANGUAGE_PUNJABI)));
34039 SWIG_Python_SetConstant(d, "LANGUAGE_QUECHUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_QUECHUA)));
34040 SWIG_Python_SetConstant(d, "LANGUAGE_RHAETO_ROMANCE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RHAETO_ROMANCE)));
34041 SWIG_Python_SetConstant(d, "LANGUAGE_ROMANIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_ROMANIAN)));
34042 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN)));
34043 SWIG_Python_SetConstant(d, "LANGUAGE_RUSSIAN_UKRAINE",SWIG_From_int(static_cast< int >(wxLANGUAGE_RUSSIAN_UKRAINE)));
34044 SWIG_Python_SetConstant(d, "LANGUAGE_SAMOAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SAMOAN)));
34045 SWIG_Python_SetConstant(d, "LANGUAGE_SANGHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANGHO)));
34046 SWIG_Python_SetConstant(d, "LANGUAGE_SANSKRIT",SWIG_From_int(static_cast< int >(wxLANGUAGE_SANSKRIT)));
34047 SWIG_Python_SetConstant(d, "LANGUAGE_SCOTS_GAELIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SCOTS_GAELIC)));
34048 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN)));
34049 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_CYRILLIC)));
34050 SWIG_Python_SetConstant(d, "LANGUAGE_SERBIAN_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBIAN_LATIN)));
34051 SWIG_Python_SetConstant(d, "LANGUAGE_SERBO_CROATIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SERBO_CROATIAN)));
34052 SWIG_Python_SetConstant(d, "LANGUAGE_SESOTHO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SESOTHO)));
34053 SWIG_Python_SetConstant(d, "LANGUAGE_SETSWANA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SETSWANA)));
34054 SWIG_Python_SetConstant(d, "LANGUAGE_SHONA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SHONA)));
34055 SWIG_Python_SetConstant(d, "LANGUAGE_SINDHI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINDHI)));
34056 SWIG_Python_SetConstant(d, "LANGUAGE_SINHALESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SINHALESE)));
34057 SWIG_Python_SetConstant(d, "LANGUAGE_SISWATI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SISWATI)));
34058 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVAK",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVAK)));
34059 SWIG_Python_SetConstant(d, "LANGUAGE_SLOVENIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SLOVENIAN)));
34060 SWIG_Python_SetConstant(d, "LANGUAGE_SOMALI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SOMALI)));
34061 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH)));
34062 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ARGENTINA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ARGENTINA)));
34063 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_BOLIVIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_BOLIVIA)));
34064 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_CHILE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_CHILE)));
34065 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COLOMBIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COLOMBIA)));
34066 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_COSTA_RICA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_COSTA_RICA)));
34067 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_DOMINICAN_REPUBLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
34068 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_ECUADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_ECUADOR)));
34069 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_EL_SALVADOR",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_EL_SALVADOR)));
34070 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_GUATEMALA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_GUATEMALA)));
34071 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_HONDURAS",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_HONDURAS)));
34072 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MEXICAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MEXICAN)));
34073 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_MODERN",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_MODERN)));
34074 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_NICARAGUA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_NICARAGUA)));
34075 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PANAMA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PANAMA)));
34076 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PARAGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PARAGUAY)));
34077 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PERU",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PERU)));
34078 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_PUERTO_RICO",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_PUERTO_RICO)));
34079 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_URUGUAY",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_URUGUAY)));
34080 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_US",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_US)));
34081 SWIG_Python_SetConstant(d, "LANGUAGE_SPANISH_VENEZUELA",SWIG_From_int(static_cast< int >(wxLANGUAGE_SPANISH_VENEZUELA)));
34082 SWIG_Python_SetConstant(d, "LANGUAGE_SUNDANESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_SUNDANESE)));
34083 SWIG_Python_SetConstant(d, "LANGUAGE_SWAHILI",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWAHILI)));
34084 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH)));
34085 SWIG_Python_SetConstant(d, "LANGUAGE_SWEDISH_FINLAND",SWIG_From_int(static_cast< int >(wxLANGUAGE_SWEDISH_FINLAND)));
34086 SWIG_Python_SetConstant(d, "LANGUAGE_TAGALOG",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAGALOG)));
34087 SWIG_Python_SetConstant(d, "LANGUAGE_TAJIK",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAJIK)));
34088 SWIG_Python_SetConstant(d, "LANGUAGE_TAMIL",SWIG_From_int(static_cast< int >(wxLANGUAGE_TAMIL)));
34089 SWIG_Python_SetConstant(d, "LANGUAGE_TATAR",SWIG_From_int(static_cast< int >(wxLANGUAGE_TATAR)));
34090 SWIG_Python_SetConstant(d, "LANGUAGE_TELUGU",SWIG_From_int(static_cast< int >(wxLANGUAGE_TELUGU)));
34091 SWIG_Python_SetConstant(d, "LANGUAGE_THAI",SWIG_From_int(static_cast< int >(wxLANGUAGE_THAI)));
34092 SWIG_Python_SetConstant(d, "LANGUAGE_TIBETAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIBETAN)));
34093 SWIG_Python_SetConstant(d, "LANGUAGE_TIGRINYA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TIGRINYA)));
34094 SWIG_Python_SetConstant(d, "LANGUAGE_TONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TONGA)));
34095 SWIG_Python_SetConstant(d, "LANGUAGE_TSONGA",SWIG_From_int(static_cast< int >(wxLANGUAGE_TSONGA)));
34096 SWIG_Python_SetConstant(d, "LANGUAGE_TURKISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKISH)));
34097 SWIG_Python_SetConstant(d, "LANGUAGE_TURKMEN",SWIG_From_int(static_cast< int >(wxLANGUAGE_TURKMEN)));
34098 SWIG_Python_SetConstant(d, "LANGUAGE_TWI",SWIG_From_int(static_cast< int >(wxLANGUAGE_TWI)));
34099 SWIG_Python_SetConstant(d, "LANGUAGE_UIGHUR",SWIG_From_int(static_cast< int >(wxLANGUAGE_UIGHUR)));
34100 SWIG_Python_SetConstant(d, "LANGUAGE_UKRAINIAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UKRAINIAN)));
34101 SWIG_Python_SetConstant(d, "LANGUAGE_URDU",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU)));
34102 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_INDIA",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_INDIA)));
34103 SWIG_Python_SetConstant(d, "LANGUAGE_URDU_PAKISTAN",SWIG_From_int(static_cast< int >(wxLANGUAGE_URDU_PAKISTAN)));
34104 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK)));
34105 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_CYRILLIC",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_CYRILLIC)));
34106 SWIG_Python_SetConstant(d, "LANGUAGE_UZBEK_LATIN",SWIG_From_int(static_cast< int >(wxLANGUAGE_UZBEK_LATIN)));
34107 SWIG_Python_SetConstant(d, "LANGUAGE_VIETNAMESE",SWIG_From_int(static_cast< int >(wxLANGUAGE_VIETNAMESE)));
34108 SWIG_Python_SetConstant(d, "LANGUAGE_VOLAPUK",SWIG_From_int(static_cast< int >(wxLANGUAGE_VOLAPUK)));
34109 SWIG_Python_SetConstant(d, "LANGUAGE_WELSH",SWIG_From_int(static_cast< int >(wxLANGUAGE_WELSH)));
34110 SWIG_Python_SetConstant(d, "LANGUAGE_WOLOF",SWIG_From_int(static_cast< int >(wxLANGUAGE_WOLOF)));
34111 SWIG_Python_SetConstant(d, "LANGUAGE_XHOSA",SWIG_From_int(static_cast< int >(wxLANGUAGE_XHOSA)));
34112 SWIG_Python_SetConstant(d, "LANGUAGE_YIDDISH",SWIG_From_int(static_cast< int >(wxLANGUAGE_YIDDISH)));
34113 SWIG_Python_SetConstant(d, "LANGUAGE_YORUBA",SWIG_From_int(static_cast< int >(wxLANGUAGE_YORUBA)));
34114 SWIG_Python_SetConstant(d, "LANGUAGE_ZHUANG",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZHUANG)));
34115 SWIG_Python_SetConstant(d, "LANGUAGE_ZULU",SWIG_From_int(static_cast< int >(wxLANGUAGE_ZULU)));
34116 SWIG_Python_SetConstant(d, "LANGUAGE_USER_DEFINED",SWIG_From_int(static_cast< int >(wxLANGUAGE_USER_DEFINED)));
34117 SWIG_Python_SetConstant(d, "LOCALE_CAT_NUMBER",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_NUMBER)));
34118 SWIG_Python_SetConstant(d, "LOCALE_CAT_DATE",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_DATE)));
34119 SWIG_Python_SetConstant(d, "LOCALE_CAT_MONEY",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MONEY)));
34120 SWIG_Python_SetConstant(d, "LOCALE_CAT_MAX",SWIG_From_int(static_cast< int >(wxLOCALE_CAT_MAX)));
34121 SWIG_Python_SetConstant(d, "LOCALE_THOUSANDS_SEP",SWIG_From_int(static_cast< int >(wxLOCALE_THOUSANDS_SEP)));
34122 SWIG_Python_SetConstant(d, "LOCALE_DECIMAL_POINT",SWIG_From_int(static_cast< int >(wxLOCALE_DECIMAL_POINT)));
34123 SWIG_Python_SetConstant(d, "LOCALE_LOAD_DEFAULT",SWIG_From_int(static_cast< int >(wxLOCALE_LOAD_DEFAULT)));
34124 SWIG_Python_SetConstant(d, "LOCALE_CONV_ENCODING",SWIG_From_int(static_cast< int >(wxLOCALE_CONV_ENCODING)));
34125 SWIG_Python_SetConstant(d, "CONVERT_STRICT",SWIG_From_int(static_cast< int >(wxCONVERT_STRICT)));
34126 SWIG_Python_SetConstant(d, "CONVERT_SUBSTITUTE",SWIG_From_int(static_cast< int >(wxCONVERT_SUBSTITUTE)));
34127 SWIG_Python_SetConstant(d, "PLATFORM_CURRENT",SWIG_From_int(static_cast< int >(wxPLATFORM_CURRENT)));
34128 SWIG_Python_SetConstant(d, "PLATFORM_UNIX",SWIG_From_int(static_cast< int >(wxPLATFORM_UNIX)));
34129 SWIG_Python_SetConstant(d, "PLATFORM_WINDOWS",SWIG_From_int(static_cast< int >(wxPLATFORM_WINDOWS)));
34130 SWIG_Python_SetConstant(d, "PLATFORM_OS2",SWIG_From_int(static_cast< int >(wxPLATFORM_OS2)));
34131 SWIG_Python_SetConstant(d, "PLATFORM_MAC",SWIG_From_int(static_cast< int >(wxPLATFORM_MAC)));
34132 SWIG_Python_SetConstant(d, "BUFFER_VIRTUAL_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_VIRTUAL_AREA)));
34133 SWIG_Python_SetConstant(d, "BUFFER_CLIENT_AREA",SWIG_From_int(static_cast< int >(wxBUFFER_CLIENT_AREA)));
34134 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_NORMAL)));
34135 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_TRANSPARENT)));
34136 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_SELECTED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_SELECTED)));
34137 SWIG_Python_SetConstant(d, "IMAGELIST_DRAW_FOCUSED",SWIG_From_int(static_cast< int >(wxIMAGELIST_DRAW_FOCUSED)));
34138 SWIG_Python_SetConstant(d, "IMAGE_LIST_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_NORMAL)));
34139 SWIG_Python_SetConstant(d, "IMAGE_LIST_SMALL",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_SMALL)));
34140 SWIG_Python_SetConstant(d, "IMAGE_LIST_STATE",SWIG_From_int(static_cast< int >(wxIMAGE_LIST_STATE)));
34141 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLACK)));
34142 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_BLUE)));
34143 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_CYAN)));
34144 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREEN)));
34145 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_GREY)));
34146 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_LIGHTGREY)));
34147 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_MEDIUMGREY)));
34148 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_RED",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_RED)));
34149 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_TRANSPARENT)));
34150 SWIG_Python_SetConstant(d, "StockGDI_BRUSH_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::BRUSH_WHITE)));
34151 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLACK)));
34152 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_BLUE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_BLUE)));
34153 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_CYAN)));
34154 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_GREEN)));
34155 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_LIGHTGREY)));
34156 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_RED",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_RED)));
34157 SWIG_Python_SetConstant(d, "StockGDI_COLOUR_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::COLOUR_WHITE)));
34158 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_CROSS)));
34159 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_HOURGLASS",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_HOURGLASS)));
34160 SWIG_Python_SetConstant(d, "StockGDI_CURSOR_STANDARD",SWIG_From_int(static_cast< int >(wxStockGDI::CURSOR_STANDARD)));
34161 SWIG_Python_SetConstant(d, "StockGDI_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_ITALIC)));
34162 SWIG_Python_SetConstant(d, "StockGDI_FONT_NORMAL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_NORMAL)));
34163 SWIG_Python_SetConstant(d, "StockGDI_FONT_SMALL",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SMALL)));
34164 SWIG_Python_SetConstant(d, "StockGDI_FONT_SWISS",SWIG_From_int(static_cast< int >(wxStockGDI::FONT_SWISS)));
34165 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACK",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACK)));
34166 SWIG_Python_SetConstant(d, "StockGDI_PEN_BLACKDASHED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_BLACKDASHED)));
34167 SWIG_Python_SetConstant(d, "StockGDI_PEN_CYAN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_CYAN)));
34168 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREEN",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREEN)));
34169 SWIG_Python_SetConstant(d, "StockGDI_PEN_GREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_GREY)));
34170 SWIG_Python_SetConstant(d, "StockGDI_PEN_LIGHTGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_LIGHTGREY)));
34171 SWIG_Python_SetConstant(d, "StockGDI_PEN_MEDIUMGREY",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_MEDIUMGREY)));
34172 SWIG_Python_SetConstant(d, "StockGDI_PEN_RED",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_RED)));
34173 SWIG_Python_SetConstant(d, "StockGDI_PEN_TRANSPARENT",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_TRANSPARENT)));
34174 SWIG_Python_SetConstant(d, "StockGDI_PEN_WHITE",SWIG_From_int(static_cast< int >(wxStockGDI::PEN_WHITE)));
34175 SWIG_Python_SetConstant(d, "StockGDI_ITEMCOUNT",SWIG_From_int(static_cast< int >(wxStockGDI::ITEMCOUNT)));
34176 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
34177 SWIG_addvarlink(SWIG_globals(),(char*)"NullBitmap",NullBitmap_get, NullBitmap_set);
34178 SWIG_addvarlink(SWIG_globals(),(char*)"NullIcon",NullIcon_get, NullIcon_set);
34179 SWIG_addvarlink(SWIG_globals(),(char*)"NullCursor",NullCursor_get, NullCursor_set);
34180 SWIG_addvarlink(SWIG_globals(),(char*)"NullPen",NullPen_get, NullPen_set);
34181 SWIG_addvarlink(SWIG_globals(),(char*)"NullBrush",NullBrush_get, NullBrush_set);
34182 SWIG_addvarlink(SWIG_globals(),(char*)"NullPalette",NullPalette_get, NullPalette_set);
34183 SWIG_addvarlink(SWIG_globals(),(char*)"NullFont",NullFont_get, NullFont_set);
34184 SWIG_addvarlink(SWIG_globals(),(char*)"NullColour",NullColour_get, NullColour_set);
34185 SWIG_Python_SetConstant(d, "CONTROL_DISABLED",SWIG_From_int(static_cast< int >(wxCONTROL_DISABLED)));
34186 SWIG_Python_SetConstant(d, "CONTROL_FOCUSED",SWIG_From_int(static_cast< int >(wxCONTROL_FOCUSED)));
34187 SWIG_Python_SetConstant(d, "CONTROL_PRESSED",SWIG_From_int(static_cast< int >(wxCONTROL_PRESSED)));
34188 SWIG_Python_SetConstant(d, "CONTROL_ISDEFAULT",SWIG_From_int(static_cast< int >(wxCONTROL_ISDEFAULT)));
34189 SWIG_Python_SetConstant(d, "CONTROL_ISSUBMENU",SWIG_From_int(static_cast< int >(wxCONTROL_ISSUBMENU)));
34190 SWIG_Python_SetConstant(d, "CONTROL_EXPANDED",SWIG_From_int(static_cast< int >(wxCONTROL_EXPANDED)));
34191 SWIG_Python_SetConstant(d, "CONTROL_CURRENT",SWIG_From_int(static_cast< int >(wxCONTROL_CURRENT)));
34192 SWIG_Python_SetConstant(d, "CONTROL_SELECTED",SWIG_From_int(static_cast< int >(wxCONTROL_SELECTED)));
34193 SWIG_Python_SetConstant(d, "CONTROL_CHECKED",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKED)));
34194 SWIG_Python_SetConstant(d, "CONTROL_CHECKABLE",SWIG_From_int(static_cast< int >(wxCONTROL_CHECKABLE)));
34195 SWIG_Python_SetConstant(d, "CONTROL_UNDETERMINED",SWIG_From_int(static_cast< int >(wxCONTROL_UNDETERMINED)));
34196 SWIG_Python_SetConstant(d, "CONTROL_FLAGS_MASK",SWIG_From_int(static_cast< int >(wxCONTROL_FLAGS_MASK)));
34197 SWIG_Python_SetConstant(d, "CONTROL_DIRTY",SWIG_From_int(static_cast< int >(wxCONTROL_DIRTY)));
34198 SWIG_Python_SetConstant(d, "RendererVersion_Current_Version",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Version)));
34199 SWIG_Python_SetConstant(d, "RendererVersion_Current_Age",SWIG_From_int(static_cast< int >(wxRendererVersion::Current_Age)));
34200
34201 // Work around a chicken/egg problem in drawlist.cpp
34202 wxPyDrawList_SetAPIPtr();
34203
34204 }
34205
wxWidgets (Impactor)