]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
merge #4 from 2.6 branch
[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.24
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
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxRendererVersion swig_types[6]
1349 #define SWIGTYPE_p_wxDuplexMode swig_types[7]
1350 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[8]
1351 #define SWIGTYPE_p_char swig_types[9]
1352 #define SWIGTYPE_p_wxIconLocation swig_types[10]
1353 #define SWIGTYPE_p_wxImage swig_types[11]
1354 #define SWIGTYPE_p_wxMetaFileDC swig_types[12]
1355 #define SWIGTYPE_p_wxMask swig_types[13]
1356 #define SWIGTYPE_p_wxSize swig_types[14]
1357 #define SWIGTYPE_p_wxFont swig_types[15]
1358 #define SWIGTYPE_p_wxWindow swig_types[16]
1359 #define SWIGTYPE_p_double swig_types[17]
1360 #define SWIGTYPE_p_wxMemoryDC swig_types[18]
1361 #define SWIGTYPE_p_wxFontMapper swig_types[19]
1362 #define SWIGTYPE_p_wxEffects swig_types[20]
1363 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[21]
1364 #define SWIGTYPE_p_wxPalette swig_types[22]
1365 #define SWIGTYPE_p_wxBitmap swig_types[23]
1366 #define SWIGTYPE_p_wxObject swig_types[24]
1367 #define SWIGTYPE_p_wxRegionIterator swig_types[25]
1368 #define SWIGTYPE_p_wxRect swig_types[26]
1369 #define SWIGTYPE_p_wxPaperSize swig_types[27]
1370 #define SWIGTYPE_p_wxString swig_types[28]
1371 #define SWIGTYPE_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_unsigned_int swig_types[30]
1373 #define SWIGTYPE_p_wxPrinterDC swig_types[31]
1374 #define SWIGTYPE_p_wxIconBundle swig_types[32]
1375 #define SWIGTYPE_p_wxPoint swig_types[33]
1376 #define SWIGTYPE_p_wxDash swig_types[34]
1377 #define SWIGTYPE_p_wxScreenDC swig_types[35]
1378 #define SWIGTYPE_p_wxCursor swig_types[36]
1379 #define SWIGTYPE_p_wxClientDC swig_types[37]
1380 #define SWIGTYPE_p_wxBufferedDC swig_types[38]
1381 #define SWIGTYPE_p_wxImageList swig_types[39]
1382 #define SWIGTYPE_p_unsigned_char swig_types[40]
1383 #define SWIGTYPE_p_wxGDIObject swig_types[41]
1384 #define SWIGTYPE_p_wxIcon swig_types[42]
1385 #define SWIGTYPE_p_wxLocale swig_types[43]
1386 #define SWIGTYPE_ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_std__ptrdiff_t swig_types[45]
1388 #define SWIGTYPE_p_wxRegion swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_wxRendererNative swig_types[58]
1401 #define SWIGTYPE_p_unsigned_long swig_types[59]
1402 #define SWIGTYPE_p_wxNativeFontInfo swig_types[60]
1403 #define SWIGTYPE_p_wxEncodingConverter swig_types[61]
1404 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[62]
1405 #define SWIGTYPE_p_wxColourDatabase swig_types[63]
1406 static swig_type_info *swig_types[65];
1407
1408 /* -------- TYPES TABLE (END) -------- */
1409
1410
1411 /*-----------------------------------------------
1412 @(target):= _gdi_.so
1413 ------------------------------------------------*/
1414 #define SWIG_init init_gdi_
1415
1416 #define SWIG_name "_gdi_"
1417
1418 #include "wx/wxPython/wxPython.h"
1419 #include "wx/wxPython/pyclasses.h"
1420
1421
1422 static const wxString wxPyEmptyString(wxEmptyString);
1423
1424 #include <limits.h>
1425
1426
1427 SWIGINTERN int
1428 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1429 const char *errmsg)
1430 {
1431 if (value < min_value) {
1432 if (errmsg) {
1433 PyErr_Format(PyExc_OverflowError,
1434 "value %ld is less than '%s' minimum %ld",
1435 value, errmsg, min_value);
1436 }
1437 return 0;
1438 } else if (value > max_value) {
1439 if (errmsg) {
1440 PyErr_Format(PyExc_OverflowError,
1441 "value %ld is greater than '%s' maximum %ld",
1442 value, errmsg, max_value);
1443 }
1444 return 0;
1445 }
1446 return 1;
1447 }
1448
1449
1450 SWIGINTERN int
1451 SWIG_AsVal_long(PyObject* obj, long* val)
1452 {
1453 if (PyNumber_Check(obj)) {
1454 if (val) *val = PyInt_AsLong(obj);
1455 return 1;
1456 }
1457 else {
1458 SWIG_type_error("number", obj);
1459 }
1460 return 0;
1461 }
1462
1463
1464 #if INT_MAX != LONG_MAX
1465 SWIGINTERN int
1466 SWIG_AsVal_int(PyObject *obj, int *val)
1467 {
1468 const char* errmsg = val ? "int" : (char*)0;
1469 long v;
1470 if (SWIG_AsVal_long(obj, &v)) {
1471 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1472 if (val) *val = (int)(v);
1473 return 1;
1474 } else {
1475 return 0;
1476 }
1477 } else {
1478 PyErr_Clear();
1479 }
1480 if (val) {
1481 SWIG_type_error(errmsg, obj);
1482 }
1483 return 0;
1484 }
1485 #else
1486 SWIGINTERNSHORT int
1487 SWIG_AsVal_int(PyObject *obj, int *val)
1488 {
1489 return SWIG_AsVal_long(obj,(long*)val);
1490 }
1491 #endif
1492
1493
1494 SWIGINTERN int
1495 SWIG_AsVal_bool(PyObject *obj, bool *val)
1496 {
1497 if (obj == Py_True) {
1498 if (val) *val = true;
1499 return 1;
1500 }
1501 if (obj == Py_False) {
1502 if (val) *val = false;
1503 return 1;
1504 }
1505 int res = 0;
1506 if (SWIG_AsVal_int(obj, &res)) {
1507 if (val) *val = res ? true : false;
1508 return 1;
1509 } else {
1510 PyErr_Clear();
1511 }
1512 if (val) {
1513 SWIG_type_error("bool", obj);
1514 }
1515 return 0;
1516 }
1517
1518
1519 SWIGINTERNSHORT bool
1520 SWIG_As_bool(PyObject* obj)
1521 {
1522 bool v;
1523 if (!SWIG_AsVal_bool(obj, &v)) {
1524 /*
1525 this is needed to make valgrind/purify happier.
1526 */
1527 memset((void*)&v, 0, sizeof(bool));
1528 }
1529 return v;
1530 }
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_Check_bool(PyObject* obj)
1535 {
1536 return SWIG_AsVal_bool(obj, (bool*)0);
1537 }
1538
1539
1540 SWIGINTERN int
1541 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1542 {
1543 long v = 0;
1544 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1545 SWIG_type_error("unsigned number", obj);
1546 }
1547 else if (val)
1548 *val = (unsigned long)v;
1549 return 1;
1550 }
1551
1552
1553 SWIGINTERNSHORT int
1554 SWIG_CheckUnsignedLongInRange(unsigned long value,
1555 unsigned long max_value,
1556 const char *errmsg)
1557 {
1558 if (value > max_value) {
1559 if (errmsg) {
1560 PyErr_Format(PyExc_OverflowError,
1561 "value %lu is greater than '%s' minimum %lu",
1562 value, errmsg, max_value);
1563 }
1564 return 0;
1565 }
1566 return 1;
1567 }
1568
1569
1570 SWIGINTERN int
1571 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1572 {
1573 const char* errmsg = val ? "unsigned char" : (char*)0;
1574 unsigned long v;
1575 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1576 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1577 if (val) *val = (unsigned char)(v);
1578 return 1;
1579 } else {
1580 return 0;
1581 }
1582 } else {
1583 PyErr_Clear();
1584 }
1585 if (val) {
1586 SWIG_type_error(errmsg, obj);
1587 }
1588 return 0;
1589 }
1590
1591
1592 SWIGINTERNSHORT unsigned char
1593 SWIG_As_unsigned_SS_char(PyObject* obj)
1594 {
1595 unsigned char v;
1596 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1597 /*
1598 this is needed to make valgrind/purify happier.
1599 */
1600 memset((void*)&v, 0, sizeof(unsigned char));
1601 }
1602 return v;
1603 }
1604
1605
1606 SWIGINTERNSHORT int
1607 SWIG_Check_unsigned_SS_char(PyObject* obj)
1608 {
1609 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1610 }
1611
1612
1613 SWIGINTERNSHORT unsigned long
1614 SWIG_As_unsigned_SS_long(PyObject* obj)
1615 {
1616 unsigned long v;
1617 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(unsigned long));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_unsigned_SS_long(PyObject* obj)
1629 {
1630 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1631 }
1632
1633
1634 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1635 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1636 /*@@*/
1637
1638
1639 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1640 #define SWIG_From_long PyInt_FromLong
1641 /*@@*/
1642
1643 static PyObject *wxColour_Get(wxColour *self){
1644 PyObject* rv = PyTuple_New(3);
1645 int red = -1;
1646 int green = -1;
1647 int blue = -1;
1648 if (self->Ok()) {
1649 red = self->Red();
1650 green = self->Green();
1651 blue = self->Blue();
1652 }
1653 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1654 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1655 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1656 return rv;
1657 }
1658 static unsigned long wxColour_GetRGB(wxColour *self){
1659 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1660 }
1661
1662 SWIGINTERNSHORT PyObject*
1663 SWIG_From_unsigned_SS_long(unsigned long value)
1664 {
1665 return (value > LONG_MAX) ?
1666 PyLong_FromUnsignedLong(value)
1667 : PyInt_FromLong((long)(value));
1668 }
1669
1670
1671 SWIGINTERNSHORT int
1672 SWIG_As_int(PyObject* obj)
1673 {
1674 int v;
1675 if (!SWIG_AsVal_int(obj, &v)) {
1676 /*
1677 this is needed to make valgrind/purify happier.
1678 */
1679 memset((void*)&v, 0, sizeof(int));
1680 }
1681 return v;
1682 }
1683
1684
1685 SWIGINTERNSHORT int
1686 SWIG_Check_int(PyObject* obj)
1687 {
1688 return SWIG_AsVal_int(obj, (int*)0);
1689 }
1690
1691
1692 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1693 #define SWIG_From_int PyInt_FromLong
1694 /*@@*/
1695
1696
1697 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1698 PyObject* o2;
1699 PyObject* o3;
1700
1701 if (!target) {
1702 target = o;
1703 } else if (target == Py_None) {
1704 Py_DECREF(Py_None);
1705 target = o;
1706 } else {
1707 if (!PyTuple_Check(target)) {
1708 o2 = target;
1709 target = PyTuple_New(1);
1710 PyTuple_SetItem(target, 0, o2);
1711 }
1712 o3 = PyTuple_New(1);
1713 PyTuple_SetItem(o3, 0, o);
1714
1715 o2 = target;
1716 target = PySequence_Concat(o2, o3);
1717 Py_DECREF(o2);
1718 Py_DECREF(o3);
1719 }
1720 return target;
1721 }
1722
1723
1724 static PyObject *wxPen_GetDashes(wxPen *self){
1725 wxDash* dashes;
1726 int count = self->GetDashes(&dashes);
1727 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1728 PyObject* retval = PyList_New(0);
1729 for (int x=0; x<count; x++) {
1730 PyObject* pyint = PyInt_FromLong(dashes[x]);
1731 PyList_Append(retval, pyint);
1732 Py_DECREF(pyint);
1733 }
1734 wxPyEndBlockThreads(blocked);
1735 return retval;
1736 }
1737 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1739 int size = PyList_Size(pyDashes);
1740 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1741
1742 // black magic warning! The array of wxDashes needs to exist as
1743 // long as the pen does because wxPen does not copy the array. So
1744 // stick a copy in a Python string object and attach it to _self,
1745 // and then call SetDashes with a pointer to that array. Then
1746 // when the Python pen object is destroyed the array will be
1747 // cleaned up too.
1748 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1749 PyObject_SetAttrString(_self, "_dashes", strDashes);
1750
1751 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1752 delete [] dashes;
1753 Py_DECREF(strDashes);
1754 wxPyEndBlockThreads(blocked);
1755 }
1756 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1757 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1758
1759 #include <wx/image.h>
1760
1761 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1762 char** cArray = NULL;
1763 int count;
1764
1765 if (!PyList_Check(listOfStrings)) {
1766 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1767 return NULL;
1768 }
1769 count = PyList_Size(listOfStrings);
1770 cArray = new char*[count];
1771
1772 for(int x=0; x<count; x++) {
1773 // TODO: Need some validation and error checking here
1774 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1775 }
1776 return cArray;
1777 }
1778
1779
1780 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1781 char** cArray = NULL;
1782 wxBitmap* bmp;
1783
1784 cArray = ConvertListOfStrings(listOfStrings);
1785 if (! cArray)
1786 return NULL;
1787 bmp = new wxBitmap(cArray);
1788 delete [] cArray;
1789 return bmp;
1790 }
1791 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1792 char* buf;
1793 int length;
1794 PyString_AsStringAndSize(bits, &buf, &length);
1795 return new wxBitmap(buf, width, height, depth);
1796 }
1797
1798 SWIGINTERNSHORT long
1799 SWIG_As_long(PyObject* obj)
1800 {
1801 long v;
1802 if (!SWIG_AsVal_long(obj, &v)) {
1803 /*
1804 this is needed to make valgrind/purify happier.
1805 */
1806 memset((void*)&v, 0, sizeof(long));
1807 }
1808 return v;
1809 }
1810
1811
1812 SWIGINTERNSHORT int
1813 SWIG_Check_long(PyObject* obj)
1814 {
1815 return SWIG_AsVal_long(obj, (long*)0);
1816 }
1817
1818 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1819 static wxSize wxBitmap_GetSize(wxBitmap *self){
1820 wxSize size(self->GetWidth(), self->GetHeight());
1821 return size;
1822 }
1823 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1824 wxMask *mask = new wxMask(*self, colour);
1825 self->SetMask(mask);
1826 }
1827 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1828 self->SetWidth(size.x);
1829 self->SetHeight(size.y);
1830 }
1831 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1832 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1833 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1834 if ( !colour.Ok() )
1835 return new wxMask(bitmap, *wxBLACK);
1836 else
1837 return new wxMask(bitmap, colour);
1838 }
1839
1840 #include <wx/iconbndl.h>
1841
1842 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1843 wxIcon* icon = new wxIcon();
1844 icon->CopyFromBitmap(bmp);
1845 return icon;
1846 }
1847 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1848 char** cArray = NULL;
1849 wxIcon* icon;
1850
1851 cArray = ConvertListOfStrings(listOfStrings);
1852 if (! cArray)
1853 return NULL;
1854 icon = new wxIcon(cArray);
1855 delete [] cArray;
1856 return icon;
1857 }
1858 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1859 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1860
1861 return new wxIconLocation(*filename, num);
1862
1863
1864
1865 }
1866 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1867
1868 self->SetIndex(num);
1869
1870
1871
1872 }
1873 static int wxIconLocation_GetIndex(wxIconLocation *self){
1874
1875 return self->GetIndex();
1876
1877
1878
1879 }
1880 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1881 #ifdef __WXGTK__
1882 wxImage img(cursorName, type);
1883 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1884 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1885 return new wxCursor(img);
1886 #else
1887 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1888 #endif
1889 }
1890 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1891
1892
1893 static void wxRegionIterator_Next(wxRegionIterator *self){
1894 (*self) ++;
1895 }
1896 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1897 return self->operator bool();
1898 }
1899
1900 #include <wx/fontutil.h>
1901 #include <wx/fontmap.h>
1902 #include <wx/fontenum.h>
1903
1904 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1905 return self->ToString();
1906 }
1907
1908 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1909 { wxPyRaiseNotImplemented(); return NULL; }
1910
1911 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1912 { wxPyRaiseNotImplemented(); return false; }
1913
1914 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1915 wxFontEncoding alt_enc;
1916 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1917 return PyInt_FromLong(alt_enc);
1918 else {
1919 Py_INCREF(Py_None);
1920 return Py_None;
1921 }
1922 }
1923 static wxFont *new_wxFont(wxString const &info){
1924 wxNativeFontInfo nfi;
1925 nfi.FromString(info);
1926 return new wxFont(nfi);
1927 }
1928 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1929 return wxFont::New(pointSize, family, flags, face, encoding);
1930 }
1931 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1932 return wxFontBase::New(pixelSize, family,
1933 style, weight, underlined,
1934 face, encoding);
1935 }
1936 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1937 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1938 }
1939 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1940 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1941
1942 class wxPyFontEnumerator : public wxFontEnumerator {
1943 public:
1944 wxPyFontEnumerator() {}
1945 ~wxPyFontEnumerator() {}
1946
1947 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1948 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1949
1950 PYPRIVATE;
1951 };
1952
1953 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1954 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1955
1956
1957 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1958 wxArrayString* arr = self->GetEncodings();
1959 if (arr)
1960 return wxArrayString2PyList_helper(*arr);
1961 else
1962 return PyList_New(0);
1963 }
1964 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1965 wxArrayString* arr = self->GetFacenames();
1966 if (arr)
1967 return wxArrayString2PyList_helper(*arr);
1968 else
1969 return PyList_New(0);
1970 }
1971
1972 #include <locale.h>
1973
1974 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1975 wxLocale* loc;
1976 if (language == -1)
1977 loc = new wxLocale();
1978 else
1979 loc = new wxLocale(language, flags);
1980 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1981 // for the floating point conversions and such to work right.
1982 #if PY_VERSION_HEX < 0x02040000
1983 setlocale(LC_NUMERIC, "C");
1984 #endif
1985 return loc;
1986 }
1987 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1988 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1989 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1990 // for the floating point conversions and such to work right.
1991 #if PY_VERSION_HEX < 0x02040000
1992 setlocale(LC_NUMERIC, "C");
1993 #endif
1994 return rc;
1995 }
1996 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1997 bool rc = self->Init(language, flags);
1998 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1999 // for the floating point conversions and such to work right.
2000 #if PY_VERSION_HEX < 0x02040000
2001 setlocale(LC_NUMERIC, "C");
2002 #endif
2003 return rc;
2004 }
2005
2006 #include "wx/wxPython/pydrawxxx.h"
2007
2008 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2009 wxColour col;
2010 self->GetPixel(x, y, &col);
2011 return col;
2012 }
2013 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2014 wxColour col;
2015 self->GetPixel(pt, &col);
2016 return col;
2017 }
2018
2019 SWIGINTERN int
2020 SWIG_AsVal_double(PyObject *obj, double* val)
2021 {
2022 if (PyNumber_Check(obj)) {
2023 if (val) *val = PyFloat_AsDouble(obj);
2024 return 1;
2025 }
2026 else {
2027 SWIG_type_error("number", obj);
2028 }
2029 return 0;
2030 }
2031
2032
2033 SWIGINTERNSHORT double
2034 SWIG_As_double(PyObject* obj)
2035 {
2036 double v;
2037 if (!SWIG_AsVal_double(obj, &v)) {
2038 /*
2039 this is needed to make valgrind/purify happier.
2040 */
2041 memset((void*)&v, 0, sizeof(double));
2042 }
2043 return v;
2044 }
2045
2046
2047 SWIGINTERNSHORT int
2048 SWIG_Check_double(PyObject* obj)
2049 {
2050 return SWIG_AsVal_double(obj, (double*)0);
2051 }
2052
2053 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2054 wxRect rv;
2055 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2056 return rv;
2057 }
2058
2059 static wxRect wxDC_GetClippingRect(wxDC *self){
2060 wxRect rect;
2061 self->GetClippingBox(rect);
2062 return rect;
2063 }
2064 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2065 wxArrayInt widths;
2066 self->GetPartialTextExtents(text, widths);
2067 return widths;
2068 }
2069
2070 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2071 #define SWIG_From_double PyFloat_FromDouble
2072 /*@@*/
2073
2074
2075 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2076 self->SetLogicalOrigin(point.x, point.y);
2077 }
2078 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2079 self->SetDeviceOrigin(point.x, point.y);
2080 }
2081 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2082 self->CalcBoundingBox(point.x, point.y);
2083 }
2084 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2092 }
2093 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2094 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2095 }
2096 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2097 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2098 }
2099 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2100 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2101 }
2102
2103 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2104 *x1 = dc->MinX();
2105 *y1 = dc->MinY();
2106 *x2 = dc->MaxX();
2107 *y2 = dc->MaxY();
2108 }
2109
2110
2111 #include <wx/dcbuffer.h>
2112
2113
2114 #include <wx/dcps.h>
2115
2116
2117 #include <wx/metafile.h>
2118
2119
2120
2121 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2122 self->AddColour(name, wxColour(red, green, blue));
2123 }
2124
2125 #include <wx/effects.h>
2126
2127
2128 #include "wx/renderer.h"
2129
2130
2131 SWIGINTERNSHORT PyObject*
2132 SWIG_From_bool(bool value)
2133 {
2134 PyObject *obj = value ? Py_True : Py_False;
2135 Py_INCREF(obj);
2136 return obj;
2137 }
2138
2139 #ifdef __cplusplus
2140 extern "C" {
2141 #endif
2142 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2143 PyObject *resultobj;
2144 wxGDIObject *result;
2145 char *kwnames[] = {
2146 NULL
2147 };
2148
2149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2150 {
2151 if (!wxPyCheckForApp()) SWIG_fail;
2152 PyThreadState* __tstate = wxPyBeginAllowThreads();
2153 result = (wxGDIObject *)new wxGDIObject();
2154
2155 wxPyEndAllowThreads(__tstate);
2156 if (PyErr_Occurred()) SWIG_fail;
2157 }
2158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2159 return resultobj;
2160 fail:
2161 return NULL;
2162 }
2163
2164
2165 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2166 PyObject *resultobj;
2167 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2168 PyObject * obj0 = 0 ;
2169 char *kwnames[] = {
2170 (char *) "self", NULL
2171 };
2172
2173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2175 if (SWIG_arg_fail(1)) SWIG_fail;
2176 {
2177 PyThreadState* __tstate = wxPyBeginAllowThreads();
2178 delete arg1;
2179
2180 wxPyEndAllowThreads(__tstate);
2181 if (PyErr_Occurred()) SWIG_fail;
2182 }
2183 Py_INCREF(Py_None); resultobj = Py_None;
2184 return resultobj;
2185 fail:
2186 return NULL;
2187 }
2188
2189
2190 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2191 PyObject *resultobj;
2192 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2193 bool result;
2194 PyObject * obj0 = 0 ;
2195 char *kwnames[] = {
2196 (char *) "self", NULL
2197 };
2198
2199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2201 if (SWIG_arg_fail(1)) SWIG_fail;
2202 {
2203 PyThreadState* __tstate = wxPyBeginAllowThreads();
2204 result = (bool)(arg1)->GetVisible();
2205
2206 wxPyEndAllowThreads(__tstate);
2207 if (PyErr_Occurred()) SWIG_fail;
2208 }
2209 {
2210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2211 }
2212 return resultobj;
2213 fail:
2214 return NULL;
2215 }
2216
2217
2218 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2219 PyObject *resultobj;
2220 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2221 bool arg2 ;
2222 PyObject * obj0 = 0 ;
2223 PyObject * obj1 = 0 ;
2224 char *kwnames[] = {
2225 (char *) "self",(char *) "visible", NULL
2226 };
2227
2228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2230 if (SWIG_arg_fail(1)) SWIG_fail;
2231 {
2232 arg2 = (bool)(SWIG_As_bool(obj1));
2233 if (SWIG_arg_fail(2)) SWIG_fail;
2234 }
2235 {
2236 PyThreadState* __tstate = wxPyBeginAllowThreads();
2237 (arg1)->SetVisible(arg2);
2238
2239 wxPyEndAllowThreads(__tstate);
2240 if (PyErr_Occurred()) SWIG_fail;
2241 }
2242 Py_INCREF(Py_None); resultobj = Py_None;
2243 return resultobj;
2244 fail:
2245 return NULL;
2246 }
2247
2248
2249 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2250 PyObject *resultobj;
2251 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2252 bool result;
2253 PyObject * obj0 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2260 if (SWIG_arg_fail(1)) SWIG_fail;
2261 {
2262 PyThreadState* __tstate = wxPyBeginAllowThreads();
2263 result = (bool)(arg1)->IsNull();
2264
2265 wxPyEndAllowThreads(__tstate);
2266 if (PyErr_Occurred()) SWIG_fail;
2267 }
2268 {
2269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2270 }
2271 return resultobj;
2272 fail:
2273 return NULL;
2274 }
2275
2276
2277 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2278 PyObject *obj;
2279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2280 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2281 Py_INCREF(obj);
2282 return Py_BuildValue((char *)"");
2283 }
2284 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2285 PyObject *resultobj;
2286 byte arg1 = (byte) 0 ;
2287 byte arg2 = (byte) 0 ;
2288 byte arg3 = (byte) 0 ;
2289 wxColour *result;
2290 PyObject * obj0 = 0 ;
2291 PyObject * obj1 = 0 ;
2292 PyObject * obj2 = 0 ;
2293 char *kwnames[] = {
2294 (char *) "red",(char *) "green",(char *) "blue", NULL
2295 };
2296
2297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2298 if (obj0) {
2299 {
2300 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2301 if (SWIG_arg_fail(1)) SWIG_fail;
2302 }
2303 }
2304 if (obj1) {
2305 {
2306 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2307 if (SWIG_arg_fail(2)) SWIG_fail;
2308 }
2309 }
2310 if (obj2) {
2311 {
2312 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2313 if (SWIG_arg_fail(3)) SWIG_fail;
2314 }
2315 }
2316 {
2317 PyThreadState* __tstate = wxPyBeginAllowThreads();
2318 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2319
2320 wxPyEndAllowThreads(__tstate);
2321 if (PyErr_Occurred()) SWIG_fail;
2322 }
2323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2324 return resultobj;
2325 fail:
2326 return NULL;
2327 }
2328
2329
2330 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2331 PyObject *resultobj;
2332 wxString *arg1 = 0 ;
2333 wxColour *result;
2334 bool temp1 = false ;
2335 PyObject * obj0 = 0 ;
2336 char *kwnames[] = {
2337 (char *) "colorName", NULL
2338 };
2339
2340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2341 {
2342 arg1 = wxString_in_helper(obj0);
2343 if (arg1 == NULL) SWIG_fail;
2344 temp1 = true;
2345 }
2346 {
2347 if (!wxPyCheckForApp()) SWIG_fail;
2348 PyThreadState* __tstate = wxPyBeginAllowThreads();
2349 result = (wxColour *)new wxColour((wxString const &)*arg1);
2350
2351 wxPyEndAllowThreads(__tstate);
2352 if (PyErr_Occurred()) SWIG_fail;
2353 }
2354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2355 {
2356 if (temp1)
2357 delete arg1;
2358 }
2359 return resultobj;
2360 fail:
2361 {
2362 if (temp1)
2363 delete arg1;
2364 }
2365 return NULL;
2366 }
2367
2368
2369 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2370 PyObject *resultobj;
2371 unsigned long arg1 ;
2372 wxColour *result;
2373 PyObject * obj0 = 0 ;
2374 char *kwnames[] = {
2375 (char *) "colRGB", NULL
2376 };
2377
2378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2379 {
2380 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2381 if (SWIG_arg_fail(1)) SWIG_fail;
2382 }
2383 {
2384 PyThreadState* __tstate = wxPyBeginAllowThreads();
2385 result = (wxColour *)new wxColour(arg1);
2386
2387 wxPyEndAllowThreads(__tstate);
2388 if (PyErr_Occurred()) SWIG_fail;
2389 }
2390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2391 return resultobj;
2392 fail:
2393 return NULL;
2394 }
2395
2396
2397 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2398 PyObject *resultobj;
2399 wxColour *arg1 = (wxColour *) 0 ;
2400 PyObject * obj0 = 0 ;
2401 char *kwnames[] = {
2402 (char *) "self", NULL
2403 };
2404
2405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2407 if (SWIG_arg_fail(1)) SWIG_fail;
2408 {
2409 PyThreadState* __tstate = wxPyBeginAllowThreads();
2410 delete arg1;
2411
2412 wxPyEndAllowThreads(__tstate);
2413 if (PyErr_Occurred()) SWIG_fail;
2414 }
2415 Py_INCREF(Py_None); resultobj = Py_None;
2416 return resultobj;
2417 fail:
2418 return NULL;
2419 }
2420
2421
2422 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2423 PyObject *resultobj;
2424 wxColour *arg1 = (wxColour *) 0 ;
2425 byte result;
2426 PyObject * obj0 = 0 ;
2427 char *kwnames[] = {
2428 (char *) "self", NULL
2429 };
2430
2431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2433 if (SWIG_arg_fail(1)) SWIG_fail;
2434 {
2435 PyThreadState* __tstate = wxPyBeginAllowThreads();
2436 result = (byte)(arg1)->Red();
2437
2438 wxPyEndAllowThreads(__tstate);
2439 if (PyErr_Occurred()) SWIG_fail;
2440 }
2441 {
2442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2443 }
2444 return resultobj;
2445 fail:
2446 return NULL;
2447 }
2448
2449
2450 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2451 PyObject *resultobj;
2452 wxColour *arg1 = (wxColour *) 0 ;
2453 byte result;
2454 PyObject * obj0 = 0 ;
2455 char *kwnames[] = {
2456 (char *) "self", NULL
2457 };
2458
2459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2461 if (SWIG_arg_fail(1)) SWIG_fail;
2462 {
2463 PyThreadState* __tstate = wxPyBeginAllowThreads();
2464 result = (byte)(arg1)->Green();
2465
2466 wxPyEndAllowThreads(__tstate);
2467 if (PyErr_Occurred()) SWIG_fail;
2468 }
2469 {
2470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2471 }
2472 return resultobj;
2473 fail:
2474 return NULL;
2475 }
2476
2477
2478 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2479 PyObject *resultobj;
2480 wxColour *arg1 = (wxColour *) 0 ;
2481 byte result;
2482 PyObject * obj0 = 0 ;
2483 char *kwnames[] = {
2484 (char *) "self", NULL
2485 };
2486
2487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2489 if (SWIG_arg_fail(1)) SWIG_fail;
2490 {
2491 PyThreadState* __tstate = wxPyBeginAllowThreads();
2492 result = (byte)(arg1)->Blue();
2493
2494 wxPyEndAllowThreads(__tstate);
2495 if (PyErr_Occurred()) SWIG_fail;
2496 }
2497 {
2498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2499 }
2500 return resultobj;
2501 fail:
2502 return NULL;
2503 }
2504
2505
2506 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2507 PyObject *resultobj;
2508 wxColour *arg1 = (wxColour *) 0 ;
2509 bool result;
2510 PyObject * obj0 = 0 ;
2511 char *kwnames[] = {
2512 (char *) "self", NULL
2513 };
2514
2515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2517 if (SWIG_arg_fail(1)) SWIG_fail;
2518 {
2519 PyThreadState* __tstate = wxPyBeginAllowThreads();
2520 result = (bool)(arg1)->Ok();
2521
2522 wxPyEndAllowThreads(__tstate);
2523 if (PyErr_Occurred()) SWIG_fail;
2524 }
2525 {
2526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2527 }
2528 return resultobj;
2529 fail:
2530 return NULL;
2531 }
2532
2533
2534 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2535 PyObject *resultobj;
2536 wxColour *arg1 = (wxColour *) 0 ;
2537 byte arg2 ;
2538 byte arg3 ;
2539 byte arg4 ;
2540 PyObject * obj0 = 0 ;
2541 PyObject * obj1 = 0 ;
2542 PyObject * obj2 = 0 ;
2543 PyObject * obj3 = 0 ;
2544 char *kwnames[] = {
2545 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2546 };
2547
2548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2550 if (SWIG_arg_fail(1)) SWIG_fail;
2551 {
2552 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2553 if (SWIG_arg_fail(2)) SWIG_fail;
2554 }
2555 {
2556 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2557 if (SWIG_arg_fail(3)) SWIG_fail;
2558 }
2559 {
2560 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2561 if (SWIG_arg_fail(4)) SWIG_fail;
2562 }
2563 {
2564 PyThreadState* __tstate = wxPyBeginAllowThreads();
2565 (arg1)->Set(arg2,arg3,arg4);
2566
2567 wxPyEndAllowThreads(__tstate);
2568 if (PyErr_Occurred()) SWIG_fail;
2569 }
2570 Py_INCREF(Py_None); resultobj = Py_None;
2571 return resultobj;
2572 fail:
2573 return NULL;
2574 }
2575
2576
2577 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2578 PyObject *resultobj;
2579 wxColour *arg1 = (wxColour *) 0 ;
2580 unsigned long arg2 ;
2581 PyObject * obj0 = 0 ;
2582 PyObject * obj1 = 0 ;
2583 char *kwnames[] = {
2584 (char *) "self",(char *) "colRGB", NULL
2585 };
2586
2587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2589 if (SWIG_arg_fail(1)) SWIG_fail;
2590 {
2591 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2592 if (SWIG_arg_fail(2)) SWIG_fail;
2593 }
2594 {
2595 PyThreadState* __tstate = wxPyBeginAllowThreads();
2596 (arg1)->Set(arg2);
2597
2598 wxPyEndAllowThreads(__tstate);
2599 if (PyErr_Occurred()) SWIG_fail;
2600 }
2601 Py_INCREF(Py_None); resultobj = Py_None;
2602 return resultobj;
2603 fail:
2604 return NULL;
2605 }
2606
2607
2608 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2609 PyObject *resultobj;
2610 wxColour *arg1 = (wxColour *) 0 ;
2611 wxString *arg2 = 0 ;
2612 bool temp2 = false ;
2613 PyObject * obj0 = 0 ;
2614 PyObject * obj1 = 0 ;
2615 char *kwnames[] = {
2616 (char *) "self",(char *) "colourName", NULL
2617 };
2618
2619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2621 if (SWIG_arg_fail(1)) SWIG_fail;
2622 {
2623 arg2 = wxString_in_helper(obj1);
2624 if (arg2 == NULL) SWIG_fail;
2625 temp2 = true;
2626 }
2627 {
2628 PyThreadState* __tstate = wxPyBeginAllowThreads();
2629 (arg1)->InitFromName((wxString const &)*arg2);
2630
2631 wxPyEndAllowThreads(__tstate);
2632 if (PyErr_Occurred()) SWIG_fail;
2633 }
2634 Py_INCREF(Py_None); resultobj = Py_None;
2635 {
2636 if (temp2)
2637 delete arg2;
2638 }
2639 return resultobj;
2640 fail:
2641 {
2642 if (temp2)
2643 delete arg2;
2644 }
2645 return NULL;
2646 }
2647
2648
2649 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2650 PyObject *resultobj;
2651 wxColour *arg1 = (wxColour *) 0 ;
2652 long result;
2653 PyObject * obj0 = 0 ;
2654 char *kwnames[] = {
2655 (char *) "self", NULL
2656 };
2657
2658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2660 if (SWIG_arg_fail(1)) SWIG_fail;
2661 {
2662 PyThreadState* __tstate = wxPyBeginAllowThreads();
2663 result = (long)((wxColour const *)arg1)->GetPixel();
2664
2665 wxPyEndAllowThreads(__tstate);
2666 if (PyErr_Occurred()) SWIG_fail;
2667 }
2668 {
2669 resultobj = SWIG_From_long((long)(result));
2670 }
2671 return resultobj;
2672 fail:
2673 return NULL;
2674 }
2675
2676
2677 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2678 PyObject *resultobj;
2679 wxColour *arg1 = (wxColour *) 0 ;
2680 wxColour *arg2 = 0 ;
2681 bool result;
2682 wxColour temp2 ;
2683 PyObject * obj0 = 0 ;
2684 PyObject * obj1 = 0 ;
2685 char *kwnames[] = {
2686 (char *) "self",(char *) "colour", NULL
2687 };
2688
2689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2691 if (SWIG_arg_fail(1)) SWIG_fail;
2692 {
2693 arg2 = &temp2;
2694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2695 }
2696 {
2697 PyThreadState* __tstate = wxPyBeginAllowThreads();
2698 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2699
2700 wxPyEndAllowThreads(__tstate);
2701 if (PyErr_Occurred()) SWIG_fail;
2702 }
2703 {
2704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2705 }
2706 return resultobj;
2707 fail:
2708 return NULL;
2709 }
2710
2711
2712 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2713 PyObject *resultobj;
2714 wxColour *arg1 = (wxColour *) 0 ;
2715 wxColour *arg2 = 0 ;
2716 bool result;
2717 wxColour temp2 ;
2718 PyObject * obj0 = 0 ;
2719 PyObject * obj1 = 0 ;
2720 char *kwnames[] = {
2721 (char *) "self",(char *) "colour", NULL
2722 };
2723
2724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2726 if (SWIG_arg_fail(1)) SWIG_fail;
2727 {
2728 arg2 = &temp2;
2729 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2730 }
2731 {
2732 PyThreadState* __tstate = wxPyBeginAllowThreads();
2733 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2734
2735 wxPyEndAllowThreads(__tstate);
2736 if (PyErr_Occurred()) SWIG_fail;
2737 }
2738 {
2739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2740 }
2741 return resultobj;
2742 fail:
2743 return NULL;
2744 }
2745
2746
2747 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2748 PyObject *resultobj;
2749 wxColour *arg1 = (wxColour *) 0 ;
2750 PyObject *result;
2751 PyObject * obj0 = 0 ;
2752 char *kwnames[] = {
2753 (char *) "self", NULL
2754 };
2755
2756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2758 if (SWIG_arg_fail(1)) SWIG_fail;
2759 {
2760 PyThreadState* __tstate = wxPyBeginAllowThreads();
2761 result = (PyObject *)wxColour_Get(arg1);
2762
2763 wxPyEndAllowThreads(__tstate);
2764 if (PyErr_Occurred()) SWIG_fail;
2765 }
2766 resultobj = result;
2767 return resultobj;
2768 fail:
2769 return NULL;
2770 }
2771
2772
2773 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2774 PyObject *resultobj;
2775 wxColour *arg1 = (wxColour *) 0 ;
2776 unsigned long result;
2777 PyObject * obj0 = 0 ;
2778 char *kwnames[] = {
2779 (char *) "self", NULL
2780 };
2781
2782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2784 if (SWIG_arg_fail(1)) SWIG_fail;
2785 {
2786 PyThreadState* __tstate = wxPyBeginAllowThreads();
2787 result = (unsigned long)wxColour_GetRGB(arg1);
2788
2789 wxPyEndAllowThreads(__tstate);
2790 if (PyErr_Occurred()) SWIG_fail;
2791 }
2792 {
2793 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2794 }
2795 return resultobj;
2796 fail:
2797 return NULL;
2798 }
2799
2800
2801 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2802 PyObject *obj;
2803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2804 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2805 Py_INCREF(obj);
2806 return Py_BuildValue((char *)"");
2807 }
2808 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2809 PyObject *resultobj;
2810 int arg1 ;
2811 unsigned char *arg2 = (unsigned char *) 0 ;
2812 unsigned char *arg3 = (unsigned char *) 0 ;
2813 unsigned char *arg4 = (unsigned char *) 0 ;
2814 wxPalette *result;
2815 PyObject * obj0 = 0 ;
2816 PyObject * obj1 = 0 ;
2817 PyObject * obj2 = 0 ;
2818 PyObject * obj3 = 0 ;
2819 char *kwnames[] = {
2820 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2821 };
2822
2823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2824 {
2825 arg1 = (int)(SWIG_As_int(obj0));
2826 if (SWIG_arg_fail(1)) SWIG_fail;
2827 }
2828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2829 if (SWIG_arg_fail(2)) SWIG_fail;
2830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(3)) SWIG_fail;
2832 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2833 if (SWIG_arg_fail(4)) SWIG_fail;
2834 {
2835 if (!wxPyCheckForApp()) SWIG_fail;
2836 PyThreadState* __tstate = wxPyBeginAllowThreads();
2837 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2838
2839 wxPyEndAllowThreads(__tstate);
2840 if (PyErr_Occurred()) SWIG_fail;
2841 }
2842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2843 return resultobj;
2844 fail:
2845 return NULL;
2846 }
2847
2848
2849 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2850 PyObject *resultobj;
2851 wxPalette *arg1 = (wxPalette *) 0 ;
2852 PyObject * obj0 = 0 ;
2853 char *kwnames[] = {
2854 (char *) "self", NULL
2855 };
2856
2857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(1)) SWIG_fail;
2860 {
2861 PyThreadState* __tstate = wxPyBeginAllowThreads();
2862 delete arg1;
2863
2864 wxPyEndAllowThreads(__tstate);
2865 if (PyErr_Occurred()) SWIG_fail;
2866 }
2867 Py_INCREF(Py_None); resultobj = Py_None;
2868 return resultobj;
2869 fail:
2870 return NULL;
2871 }
2872
2873
2874 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2875 PyObject *resultobj;
2876 wxPalette *arg1 = (wxPalette *) 0 ;
2877 byte arg2 ;
2878 byte arg3 ;
2879 byte arg4 ;
2880 int result;
2881 PyObject * obj0 = 0 ;
2882 PyObject * obj1 = 0 ;
2883 PyObject * obj2 = 0 ;
2884 PyObject * obj3 = 0 ;
2885 char *kwnames[] = {
2886 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2887 };
2888
2889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 {
2893 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2894 if (SWIG_arg_fail(2)) SWIG_fail;
2895 }
2896 {
2897 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2898 if (SWIG_arg_fail(3)) SWIG_fail;
2899 }
2900 {
2901 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2902 if (SWIG_arg_fail(4)) SWIG_fail;
2903 }
2904 {
2905 PyThreadState* __tstate = wxPyBeginAllowThreads();
2906 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2907
2908 wxPyEndAllowThreads(__tstate);
2909 if (PyErr_Occurred()) SWIG_fail;
2910 }
2911 {
2912 resultobj = SWIG_From_int((int)(result));
2913 }
2914 return resultobj;
2915 fail:
2916 return NULL;
2917 }
2918
2919
2920 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2921 PyObject *resultobj;
2922 wxPalette *arg1 = (wxPalette *) 0 ;
2923 int arg2 ;
2924 byte *arg3 = (byte *) 0 ;
2925 byte *arg4 = (byte *) 0 ;
2926 byte *arg5 = (byte *) 0 ;
2927 bool result;
2928 byte temp3 ;
2929 int res3 = 0 ;
2930 byte temp4 ;
2931 int res4 = 0 ;
2932 byte temp5 ;
2933 int res5 = 0 ;
2934 PyObject * obj0 = 0 ;
2935 PyObject * obj1 = 0 ;
2936 char *kwnames[] = {
2937 (char *) "self",(char *) "pixel", NULL
2938 };
2939
2940 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2941 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2942 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2945 if (SWIG_arg_fail(1)) SWIG_fail;
2946 {
2947 arg2 = (int)(SWIG_As_int(obj1));
2948 if (SWIG_arg_fail(2)) SWIG_fail;
2949 }
2950 {
2951 PyThreadState* __tstate = wxPyBeginAllowThreads();
2952 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2953
2954 wxPyEndAllowThreads(__tstate);
2955 if (PyErr_Occurred()) SWIG_fail;
2956 }
2957 {
2958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2959 }
2960 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2961 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2962 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2963 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2964 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2965 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2966 return resultobj;
2967 fail:
2968 return NULL;
2969 }
2970
2971
2972 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2973 PyObject *resultobj;
2974 wxPalette *arg1 = (wxPalette *) 0 ;
2975 int result;
2976 PyObject * obj0 = 0 ;
2977 char *kwnames[] = {
2978 (char *) "self", NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2983 if (SWIG_arg_fail(1)) SWIG_fail;
2984 {
2985 PyThreadState* __tstate = wxPyBeginAllowThreads();
2986 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2987
2988 wxPyEndAllowThreads(__tstate);
2989 if (PyErr_Occurred()) SWIG_fail;
2990 }
2991 {
2992 resultobj = SWIG_From_int((int)(result));
2993 }
2994 return resultobj;
2995 fail:
2996 return NULL;
2997 }
2998
2999
3000 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3001 PyObject *resultobj;
3002 wxPalette *arg1 = (wxPalette *) 0 ;
3003 bool result;
3004 PyObject * obj0 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 {
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = (bool)(arg1)->Ok();
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3029 PyObject *obj;
3030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3031 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3032 Py_INCREF(obj);
3033 return Py_BuildValue((char *)"");
3034 }
3035 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3036 PyObject *resultobj;
3037 wxColour *arg1 = 0 ;
3038 int arg2 = (int) 1 ;
3039 int arg3 = (int) wxSOLID ;
3040 wxPen *result;
3041 wxColour temp1 ;
3042 PyObject * obj0 = 0 ;
3043 PyObject * obj1 = 0 ;
3044 PyObject * obj2 = 0 ;
3045 char *kwnames[] = {
3046 (char *) "colour",(char *) "width",(char *) "style", NULL
3047 };
3048
3049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3050 {
3051 arg1 = &temp1;
3052 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3053 }
3054 if (obj1) {
3055 {
3056 arg2 = (int)(SWIG_As_int(obj1));
3057 if (SWIG_arg_fail(2)) SWIG_fail;
3058 }
3059 }
3060 if (obj2) {
3061 {
3062 arg3 = (int)(SWIG_As_int(obj2));
3063 if (SWIG_arg_fail(3)) SWIG_fail;
3064 }
3065 }
3066 {
3067 if (!wxPyCheckForApp()) SWIG_fail;
3068 PyThreadState* __tstate = wxPyBeginAllowThreads();
3069 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3070
3071 wxPyEndAllowThreads(__tstate);
3072 if (PyErr_Occurred()) SWIG_fail;
3073 }
3074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3075 return resultobj;
3076 fail:
3077 return NULL;
3078 }
3079
3080
3081 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3082 PyObject *resultobj;
3083 wxPen *arg1 = (wxPen *) 0 ;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "self", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 {
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 delete arg1;
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 Py_INCREF(Py_None); resultobj = Py_None;
3100 return resultobj;
3101 fail:
3102 return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3107 PyObject *resultobj;
3108 wxPen *arg1 = (wxPen *) 0 ;
3109 int result;
3110 PyObject * obj0 = 0 ;
3111 char *kwnames[] = {
3112 (char *) "self", NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3117 if (SWIG_arg_fail(1)) SWIG_fail;
3118 {
3119 PyThreadState* __tstate = wxPyBeginAllowThreads();
3120 result = (int)(arg1)->GetCap();
3121
3122 wxPyEndAllowThreads(__tstate);
3123 if (PyErr_Occurred()) SWIG_fail;
3124 }
3125 {
3126 resultobj = SWIG_From_int((int)(result));
3127 }
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxPen *arg1 = (wxPen *) 0 ;
3137 wxColour result;
3138 PyObject * obj0 = 0 ;
3139 char *kwnames[] = {
3140 (char *) "self", NULL
3141 };
3142
3143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 {
3147 PyThreadState* __tstate = wxPyBeginAllowThreads();
3148 result = (arg1)->GetColour();
3149
3150 wxPyEndAllowThreads(__tstate);
3151 if (PyErr_Occurred()) SWIG_fail;
3152 }
3153 {
3154 wxColour * resultptr;
3155 resultptr = new wxColour((wxColour &)(result));
3156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 int result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3175 if (SWIG_arg_fail(1)) SWIG_fail;
3176 {
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 result = (int)(arg1)->GetJoin();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 resultobj = SWIG_From_int((int)(result));
3185 }
3186 return resultobj;
3187 fail:
3188 return NULL;
3189 }
3190
3191
3192 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3193 PyObject *resultobj;
3194 wxPen *arg1 = (wxPen *) 0 ;
3195 int result;
3196 PyObject * obj0 = 0 ;
3197 char *kwnames[] = {
3198 (char *) "self", NULL
3199 };
3200
3201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3203 if (SWIG_arg_fail(1)) SWIG_fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (int)(arg1)->GetStyle();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 {
3212 resultobj = SWIG_From_int((int)(result));
3213 }
3214 return resultobj;
3215 fail:
3216 return NULL;
3217 }
3218
3219
3220 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3221 PyObject *resultobj;
3222 wxPen *arg1 = (wxPen *) 0 ;
3223 int result;
3224 PyObject * obj0 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "self", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3231 if (SWIG_arg_fail(1)) SWIG_fail;
3232 {
3233 PyThreadState* __tstate = wxPyBeginAllowThreads();
3234 result = (int)(arg1)->GetWidth();
3235
3236 wxPyEndAllowThreads(__tstate);
3237 if (PyErr_Occurred()) SWIG_fail;
3238 }
3239 {
3240 resultobj = SWIG_From_int((int)(result));
3241 }
3242 return resultobj;
3243 fail:
3244 return NULL;
3245 }
3246
3247
3248 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3249 PyObject *resultobj;
3250 wxPen *arg1 = (wxPen *) 0 ;
3251 bool result;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "self", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3259 if (SWIG_arg_fail(1)) SWIG_fail;
3260 {
3261 PyThreadState* __tstate = wxPyBeginAllowThreads();
3262 result = (bool)(arg1)->Ok();
3263
3264 wxPyEndAllowThreads(__tstate);
3265 if (PyErr_Occurred()) SWIG_fail;
3266 }
3267 {
3268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3269 }
3270 return resultobj;
3271 fail:
3272 return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxPen *arg1 = (wxPen *) 0 ;
3279 int arg2 ;
3280 PyObject * obj0 = 0 ;
3281 PyObject * obj1 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self",(char *) "cap_style", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 (arg1)->SetCap(arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 return resultobj;
3302 fail:
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxPen *arg1 = (wxPen *) 0 ;
3310 wxColour *arg2 = 0 ;
3311 wxColour temp2 ;
3312 PyObject * obj0 = 0 ;
3313 PyObject * obj1 = 0 ;
3314 char *kwnames[] = {
3315 (char *) "self",(char *) "colour", NULL
3316 };
3317
3318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3320 if (SWIG_arg_fail(1)) SWIG_fail;
3321 {
3322 arg2 = &temp2;
3323 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3324 }
3325 {
3326 PyThreadState* __tstate = wxPyBeginAllowThreads();
3327 (arg1)->SetColour(*arg2);
3328
3329 wxPyEndAllowThreads(__tstate);
3330 if (PyErr_Occurred()) SWIG_fail;
3331 }
3332 Py_INCREF(Py_None); resultobj = Py_None;
3333 return resultobj;
3334 fail:
3335 return NULL;
3336 }
3337
3338
3339 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj;
3341 wxPen *arg1 = (wxPen *) 0 ;
3342 int arg2 ;
3343 PyObject * obj0 = 0 ;
3344 PyObject * obj1 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "self",(char *) "join_style", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3351 if (SWIG_arg_fail(1)) SWIG_fail;
3352 {
3353 arg2 = (int)(SWIG_As_int(obj1));
3354 if (SWIG_arg_fail(2)) SWIG_fail;
3355 }
3356 {
3357 PyThreadState* __tstate = wxPyBeginAllowThreads();
3358 (arg1)->SetJoin(arg2);
3359
3360 wxPyEndAllowThreads(__tstate);
3361 if (PyErr_Occurred()) SWIG_fail;
3362 }
3363 Py_INCREF(Py_None); resultobj = Py_None;
3364 return resultobj;
3365 fail:
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxPen *arg1 = (wxPen *) 0 ;
3373 int arg2 ;
3374 PyObject * obj0 = 0 ;
3375 PyObject * obj1 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self",(char *) "style", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 {
3384 arg2 = (int)(SWIG_As_int(obj1));
3385 if (SWIG_arg_fail(2)) SWIG_fail;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 (arg1)->SetStyle(arg2);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 Py_INCREF(Py_None); resultobj = Py_None;
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 wxPen *arg1 = (wxPen *) 0 ;
3404 int arg2 ;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "self",(char *) "width", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3413 if (SWIG_arg_fail(1)) SWIG_fail;
3414 {
3415 arg2 = (int)(SWIG_As_int(obj1));
3416 if (SWIG_arg_fail(2)) SWIG_fail;
3417 }
3418 {
3419 PyThreadState* __tstate = wxPyBeginAllowThreads();
3420 (arg1)->SetWidth(arg2);
3421
3422 wxPyEndAllowThreads(__tstate);
3423 if (PyErr_Occurred()) SWIG_fail;
3424 }
3425 Py_INCREF(Py_None); resultobj = Py_None;
3426 return resultobj;
3427 fail:
3428 return NULL;
3429 }
3430
3431
3432 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3433 PyObject *resultobj;
3434 wxPen *arg1 = (wxPen *) 0 ;
3435 int arg2 ;
3436 wxDash *arg3 = (wxDash *) 0 ;
3437 PyObject * obj0 = 0 ;
3438 PyObject * obj1 = 0 ;
3439 char *kwnames[] = {
3440 (char *) "self",(char *) "dashes", NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3445 if (SWIG_arg_fail(1)) SWIG_fail;
3446 {
3447 arg2 = PyList_Size(obj1);
3448 arg3 = (wxDash*)byte_LIST_helper(obj1);
3449 if (arg3 == NULL) SWIG_fail;
3450 }
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 (arg1)->SetDashes(arg2,arg3);
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 Py_INCREF(Py_None); resultobj = Py_None;
3459 {
3460 if (arg3) delete [] arg3;
3461 }
3462 return resultobj;
3463 fail:
3464 {
3465 if (arg3) delete [] arg3;
3466 }
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxPen *arg1 = (wxPen *) 0 ;
3474 PyObject *result;
3475 PyObject * obj0 = 0 ;
3476 char *kwnames[] = {
3477 (char *) "self", NULL
3478 };
3479
3480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3482 if (SWIG_arg_fail(1)) SWIG_fail;
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (PyObject *)wxPen_GetDashes(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 resultobj = result;
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxPen *arg1 = (wxPen *) 0 ;
3500 PyObject *arg2 = (PyObject *) 0 ;
3501 PyObject *arg3 = (PyObject *) 0 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 PyObject * obj2 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 arg2 = obj1;
3513 arg3 = obj2;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 wxPen__SetDashes(arg1,arg2,arg3);
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 Py_INCREF(Py_None); resultobj = Py_None;
3522 return resultobj;
3523 fail:
3524 return NULL;
3525 }
3526
3527
3528 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3529 PyObject *resultobj;
3530 wxPen *arg1 = (wxPen *) 0 ;
3531 int result;
3532 PyObject * obj0 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 PyThreadState* __tstate = wxPyBeginAllowThreads();
3542 result = (int)((wxPen const *)arg1)->GetDashCount();
3543
3544 wxPyEndAllowThreads(__tstate);
3545 if (PyErr_Occurred()) SWIG_fail;
3546 }
3547 {
3548 resultobj = SWIG_From_int((int)(result));
3549 }
3550 return resultobj;
3551 fail:
3552 return NULL;
3553 }
3554
3555
3556 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 wxPen *arg1 = (wxPen *) 0 ;
3559 wxBitmap *result;
3560 PyObject * obj0 = 0 ;
3561 char *kwnames[] = {
3562 (char *) "self", NULL
3563 };
3564
3565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3567 if (SWIG_arg_fail(1)) SWIG_fail;
3568 {
3569 PyThreadState* __tstate = wxPyBeginAllowThreads();
3570 result = (wxBitmap *)(arg1)->GetStipple();
3571
3572 wxPyEndAllowThreads(__tstate);
3573 if (PyErr_Occurred()) SWIG_fail;
3574 }
3575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3576 return resultobj;
3577 fail:
3578 return NULL;
3579 }
3580
3581
3582 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3583 PyObject *resultobj;
3584 wxPen *arg1 = (wxPen *) 0 ;
3585 wxBitmap *arg2 = 0 ;
3586 PyObject * obj0 = 0 ;
3587 PyObject * obj1 = 0 ;
3588 char *kwnames[] = {
3589 (char *) "self",(char *) "stipple", NULL
3590 };
3591
3592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3594 if (SWIG_arg_fail(1)) SWIG_fail;
3595 {
3596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3597 if (SWIG_arg_fail(2)) SWIG_fail;
3598 if (arg2 == NULL) {
3599 SWIG_null_ref("wxBitmap");
3600 }
3601 if (SWIG_arg_fail(2)) SWIG_fail;
3602 }
3603 {
3604 PyThreadState* __tstate = wxPyBeginAllowThreads();
3605 (arg1)->SetStipple(*arg2);
3606
3607 wxPyEndAllowThreads(__tstate);
3608 if (PyErr_Occurred()) SWIG_fail;
3609 }
3610 Py_INCREF(Py_None); resultobj = Py_None;
3611 return resultobj;
3612 fail:
3613 return NULL;
3614 }
3615
3616
3617 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3618 PyObject *resultobj;
3619 wxPen *arg1 = (wxPen *) 0 ;
3620 wxPen *arg2 = (wxPen *) 0 ;
3621 bool result;
3622 PyObject * obj0 = 0 ;
3623 PyObject * obj1 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "self",(char *) "other", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3630 if (SWIG_arg_fail(1)) SWIG_fail;
3631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3632 if (SWIG_arg_fail(2)) SWIG_fail;
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3642 }
3643 return resultobj;
3644 fail:
3645 return NULL;
3646 }
3647
3648
3649 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3650 PyObject *resultobj;
3651 wxPen *arg1 = (wxPen *) 0 ;
3652 wxPen *arg2 = (wxPen *) 0 ;
3653 bool result;
3654 PyObject * obj0 = 0 ;
3655 PyObject * obj1 = 0 ;
3656 char *kwnames[] = {
3657 (char *) "self",(char *) "other", NULL
3658 };
3659
3660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3662 if (SWIG_arg_fail(1)) SWIG_fail;
3663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3664 if (SWIG_arg_fail(2)) SWIG_fail;
3665 {
3666 PyThreadState* __tstate = wxPyBeginAllowThreads();
3667 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3668
3669 wxPyEndAllowThreads(__tstate);
3670 if (PyErr_Occurred()) SWIG_fail;
3671 }
3672 {
3673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3674 }
3675 return resultobj;
3676 fail:
3677 return NULL;
3678 }
3679
3680
3681 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3682 PyObject *obj;
3683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3684 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3685 Py_INCREF(obj);
3686 return Py_BuildValue((char *)"");
3687 }
3688 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxColour *arg1 = 0 ;
3691 int arg2 = (int) wxSOLID ;
3692 wxBrush *result;
3693 wxColour temp1 ;
3694 PyObject * obj0 = 0 ;
3695 PyObject * obj1 = 0 ;
3696 char *kwnames[] = {
3697 (char *) "colour",(char *) "style", NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3701 {
3702 arg1 = &temp1;
3703 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3704 }
3705 if (obj1) {
3706 {
3707 arg2 = (int)(SWIG_As_int(obj1));
3708 if (SWIG_arg_fail(2)) SWIG_fail;
3709 }
3710 }
3711 {
3712 if (!wxPyCheckForApp()) SWIG_fail;
3713 PyThreadState* __tstate = wxPyBeginAllowThreads();
3714 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3715
3716 wxPyEndAllowThreads(__tstate);
3717 if (PyErr_Occurred()) SWIG_fail;
3718 }
3719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3720 return resultobj;
3721 fail:
3722 return NULL;
3723 }
3724
3725
3726 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3727 PyObject *resultobj;
3728 wxBitmap *arg1 = 0 ;
3729 wxBrush *result;
3730 PyObject * obj0 = 0 ;
3731 char *kwnames[] = {
3732 (char *) "stippleBitmap", NULL
3733 };
3734
3735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3736 {
3737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3738 if (SWIG_arg_fail(1)) SWIG_fail;
3739 if (arg1 == NULL) {
3740 SWIG_null_ref("wxBitmap");
3741 }
3742 if (SWIG_arg_fail(1)) SWIG_fail;
3743 }
3744 {
3745 if (!wxPyCheckForApp()) SWIG_fail;
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 wxBrush *arg1 = (wxBrush *) 0 ;
3762 PyObject * obj0 = 0 ;
3763 char *kwnames[] = {
3764 (char *) "self", NULL
3765 };
3766
3767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3769 if (SWIG_arg_fail(1)) SWIG_fail;
3770 {
3771 PyThreadState* __tstate = wxPyBeginAllowThreads();
3772 delete arg1;
3773
3774 wxPyEndAllowThreads(__tstate);
3775 if (PyErr_Occurred()) SWIG_fail;
3776 }
3777 Py_INCREF(Py_None); resultobj = Py_None;
3778 return resultobj;
3779 fail:
3780 return NULL;
3781 }
3782
3783
3784 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3785 PyObject *resultobj;
3786 wxBrush *arg1 = (wxBrush *) 0 ;
3787 wxColour *arg2 = 0 ;
3788 wxColour temp2 ;
3789 PyObject * obj0 = 0 ;
3790 PyObject * obj1 = 0 ;
3791 char *kwnames[] = {
3792 (char *) "self",(char *) "col", NULL
3793 };
3794
3795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3797 if (SWIG_arg_fail(1)) SWIG_fail;
3798 {
3799 arg2 = &temp2;
3800 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3801 }
3802 {
3803 PyThreadState* __tstate = wxPyBeginAllowThreads();
3804 (arg1)->SetColour((wxColour const &)*arg2);
3805
3806 wxPyEndAllowThreads(__tstate);
3807 if (PyErr_Occurred()) SWIG_fail;
3808 }
3809 Py_INCREF(Py_None); resultobj = Py_None;
3810 return resultobj;
3811 fail:
3812 return NULL;
3813 }
3814
3815
3816 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3817 PyObject *resultobj;
3818 wxBrush *arg1 = (wxBrush *) 0 ;
3819 int arg2 ;
3820 PyObject * obj0 = 0 ;
3821 PyObject * obj1 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "self",(char *) "style", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3828 if (SWIG_arg_fail(1)) SWIG_fail;
3829 {
3830 arg2 = (int)(SWIG_As_int(obj1));
3831 if (SWIG_arg_fail(2)) SWIG_fail;
3832 }
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 (arg1)->SetStyle(arg2);
3836
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 Py_INCREF(Py_None); resultobj = Py_None;
3841 return resultobj;
3842 fail:
3843 return NULL;
3844 }
3845
3846
3847 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3848 PyObject *resultobj;
3849 wxBrush *arg1 = (wxBrush *) 0 ;
3850 wxBitmap *arg2 = 0 ;
3851 PyObject * obj0 = 0 ;
3852 PyObject * obj1 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "self",(char *) "stipple", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3859 if (SWIG_arg_fail(1)) SWIG_fail;
3860 {
3861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3862 if (SWIG_arg_fail(2)) SWIG_fail;
3863 if (arg2 == NULL) {
3864 SWIG_null_ref("wxBitmap");
3865 }
3866 if (SWIG_arg_fail(2)) SWIG_fail;
3867 }
3868 {
3869 PyThreadState* __tstate = wxPyBeginAllowThreads();
3870 (arg1)->SetStipple((wxBitmap const &)*arg2);
3871
3872 wxPyEndAllowThreads(__tstate);
3873 if (PyErr_Occurred()) SWIG_fail;
3874 }
3875 Py_INCREF(Py_None); resultobj = Py_None;
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj;
3884 wxBrush *arg1 = (wxBrush *) 0 ;
3885 wxColour result;
3886 PyObject * obj0 = 0 ;
3887 char *kwnames[] = {
3888 (char *) "self", NULL
3889 };
3890
3891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3893 if (SWIG_arg_fail(1)) SWIG_fail;
3894 {
3895 PyThreadState* __tstate = wxPyBeginAllowThreads();
3896 result = ((wxBrush const *)arg1)->GetColour();
3897
3898 wxPyEndAllowThreads(__tstate);
3899 if (PyErr_Occurred()) SWIG_fail;
3900 }
3901 {
3902 wxColour * resultptr;
3903 resultptr = new wxColour((wxColour &)(result));
3904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3905 }
3906 return resultobj;
3907 fail:
3908 return NULL;
3909 }
3910
3911
3912 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3913 PyObject *resultobj;
3914 wxBrush *arg1 = (wxBrush *) 0 ;
3915 int result;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 PyThreadState* __tstate = wxPyBeginAllowThreads();
3926 result = (int)((wxBrush const *)arg1)->GetStyle();
3927
3928 wxPyEndAllowThreads(__tstate);
3929 if (PyErr_Occurred()) SWIG_fail;
3930 }
3931 {
3932 resultobj = SWIG_From_int((int)(result));
3933 }
3934 return resultobj;
3935 fail:
3936 return NULL;
3937 }
3938
3939
3940 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3941 PyObject *resultobj;
3942 wxBrush *arg1 = (wxBrush *) 0 ;
3943 wxBitmap *result;
3944 PyObject * obj0 = 0 ;
3945 char *kwnames[] = {
3946 (char *) "self", NULL
3947 };
3948
3949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3951 if (SWIG_arg_fail(1)) SWIG_fail;
3952 {
3953 PyThreadState* __tstate = wxPyBeginAllowThreads();
3954 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3955
3956 wxPyEndAllowThreads(__tstate);
3957 if (PyErr_Occurred()) SWIG_fail;
3958 }
3959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3960 return resultobj;
3961 fail:
3962 return NULL;
3963 }
3964
3965
3966 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3967 PyObject *resultobj;
3968 wxBrush *arg1 = (wxBrush *) 0 ;
3969 bool result;
3970 PyObject * obj0 = 0 ;
3971 char *kwnames[] = {
3972 (char *) "self", NULL
3973 };
3974
3975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3977 if (SWIG_arg_fail(1)) SWIG_fail;
3978 {
3979 PyThreadState* __tstate = wxPyBeginAllowThreads();
3980 result = (bool)((wxBrush const *)arg1)->IsHatch();
3981
3982 wxPyEndAllowThreads(__tstate);
3983 if (PyErr_Occurred()) SWIG_fail;
3984 }
3985 {
3986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3987 }
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxBrush *arg1 = (wxBrush *) 0 ;
3997 bool result;
3998 PyObject * obj0 = 0 ;
3999 char *kwnames[] = {
4000 (char *) "self", NULL
4001 };
4002
4003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
4004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4005 if (SWIG_arg_fail(1)) SWIG_fail;
4006 {
4007 PyThreadState* __tstate = wxPyBeginAllowThreads();
4008 result = (bool)(arg1)->Ok();
4009
4010 wxPyEndAllowThreads(__tstate);
4011 if (PyErr_Occurred()) SWIG_fail;
4012 }
4013 {
4014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4015 }
4016 return resultobj;
4017 fail:
4018 return NULL;
4019 }
4020
4021
4022 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4023 PyObject *obj;
4024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4025 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4026 Py_INCREF(obj);
4027 return Py_BuildValue((char *)"");
4028 }
4029 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj;
4031 wxString *arg1 = 0 ;
4032 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4033 wxBitmap *result;
4034 bool temp1 = false ;
4035 PyObject * obj0 = 0 ;
4036 PyObject * obj1 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "name",(char *) "type", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4042 {
4043 arg1 = wxString_in_helper(obj0);
4044 if (arg1 == NULL) SWIG_fail;
4045 temp1 = true;
4046 }
4047 if (obj1) {
4048 {
4049 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4050 if (SWIG_arg_fail(2)) SWIG_fail;
4051 }
4052 }
4053 {
4054 if (!wxPyCheckForApp()) SWIG_fail;
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4062 {
4063 if (temp1)
4064 delete arg1;
4065 }
4066 return resultobj;
4067 fail:
4068 {
4069 if (temp1)
4070 delete arg1;
4071 }
4072 return NULL;
4073 }
4074
4075
4076 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4077 PyObject *resultobj;
4078 wxBitmap *arg1 = (wxBitmap *) 0 ;
4079 PyObject * obj0 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "self", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 {
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 delete arg1;
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 Py_INCREF(Py_None); resultobj = Py_None;
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj;
4103 int arg1 ;
4104 int arg2 ;
4105 int arg3 = (int) -1 ;
4106 wxBitmap *result;
4107 PyObject * obj0 = 0 ;
4108 PyObject * obj1 = 0 ;
4109 PyObject * obj2 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "width",(char *) "height",(char *) "depth", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4115 {
4116 arg1 = (int)(SWIG_As_int(obj0));
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 }
4119 {
4120 arg2 = (int)(SWIG_As_int(obj1));
4121 if (SWIG_arg_fail(2)) SWIG_fail;
4122 }
4123 if (obj2) {
4124 {
4125 arg3 = (int)(SWIG_As_int(obj2));
4126 if (SWIG_arg_fail(3)) SWIG_fail;
4127 }
4128 }
4129 {
4130 if (!wxPyCheckForApp()) SWIG_fail;
4131 PyThreadState* __tstate = wxPyBeginAllowThreads();
4132 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4133
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj;
4146 wxIcon *arg1 = 0 ;
4147 wxBitmap *result;
4148 PyObject * obj0 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "icon", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4154 {
4155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4156 if (SWIG_arg_fail(1)) SWIG_fail;
4157 if (arg1 == NULL) {
4158 SWIG_null_ref("wxIcon");
4159 }
4160 if (SWIG_arg_fail(1)) SWIG_fail;
4161 }
4162 {
4163 if (!wxPyCheckForApp()) SWIG_fail;
4164 PyThreadState* __tstate = wxPyBeginAllowThreads();
4165 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4166
4167 wxPyEndAllowThreads(__tstate);
4168 if (PyErr_Occurred()) SWIG_fail;
4169 }
4170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4171 return resultobj;
4172 fail:
4173 return NULL;
4174 }
4175
4176
4177 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4178 PyObject *resultobj;
4179 wxImage *arg1 = 0 ;
4180 int arg2 = (int) -1 ;
4181 wxBitmap *result;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "image",(char *) "depth", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4189 {
4190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4191 if (SWIG_arg_fail(1)) SWIG_fail;
4192 if (arg1 == NULL) {
4193 SWIG_null_ref("wxImage");
4194 }
4195 if (SWIG_arg_fail(1)) SWIG_fail;
4196 }
4197 if (obj1) {
4198 {
4199 arg2 = (int)(SWIG_As_int(obj1));
4200 if (SWIG_arg_fail(2)) SWIG_fail;
4201 }
4202 }
4203 {
4204 if (!wxPyCheckForApp()) SWIG_fail;
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4207
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4212 return resultobj;
4213 fail:
4214 return NULL;
4215 }
4216
4217
4218 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4219 PyObject *resultobj;
4220 PyObject *arg1 = (PyObject *) 0 ;
4221 wxBitmap *result;
4222 PyObject * obj0 = 0 ;
4223 char *kwnames[] = {
4224 (char *) "listOfStrings", NULL
4225 };
4226
4227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4228 arg1 = obj0;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxBitmap *)new_wxBitmap(arg1);
4233
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 PyObject *arg1 = (PyObject *) 0 ;
4247 int arg2 ;
4248 int arg3 ;
4249 int arg4 = (int) 1 ;
4250 wxBitmap *result;
4251 PyObject * obj0 = 0 ;
4252 PyObject * obj1 = 0 ;
4253 PyObject * obj2 = 0 ;
4254 PyObject * obj3 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4260 arg1 = obj0;
4261 {
4262 arg2 = (int)(SWIG_As_int(obj1));
4263 if (SWIG_arg_fail(2)) SWIG_fail;
4264 }
4265 {
4266 arg3 = (int)(SWIG_As_int(obj2));
4267 if (SWIG_arg_fail(3)) SWIG_fail;
4268 }
4269 if (obj3) {
4270 {
4271 arg4 = (int)(SWIG_As_int(obj3));
4272 if (SWIG_arg_fail(4)) SWIG_fail;
4273 }
4274 }
4275 {
4276 if (!wxPyCheckForApp()) SWIG_fail;
4277 PyThreadState* __tstate = wxPyBeginAllowThreads();
4278 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4279
4280 wxPyEndAllowThreads(__tstate);
4281 if (PyErr_Occurred()) SWIG_fail;
4282 }
4283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4284 return resultobj;
4285 fail:
4286 return NULL;
4287 }
4288
4289
4290 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4291 PyObject *resultobj;
4292 wxBitmap *arg1 = (wxBitmap *) 0 ;
4293 long result;
4294 PyObject * obj0 = 0 ;
4295 char *kwnames[] = {
4296 (char *) "self", NULL
4297 };
4298
4299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4301 if (SWIG_arg_fail(1)) SWIG_fail;
4302 {
4303 PyThreadState* __tstate = wxPyBeginAllowThreads();
4304 result = (long)(arg1)->GetHandle();
4305
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 {
4310 resultobj = SWIG_From_long((long)(result));
4311 }
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxBitmap *arg1 = (wxBitmap *) 0 ;
4321 long arg2 ;
4322 PyObject * obj0 = 0 ;
4323 PyObject * obj1 = 0 ;
4324 char *kwnames[] = {
4325 (char *) "self",(char *) "handle", NULL
4326 };
4327
4328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4330 if (SWIG_arg_fail(1)) SWIG_fail;
4331 {
4332 arg2 = (long)(SWIG_As_long(obj1));
4333 if (SWIG_arg_fail(2)) SWIG_fail;
4334 }
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 wxBitmap_SetHandle(arg1,arg2);
4338
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 Py_INCREF(Py_None); resultobj = Py_None;
4343 return resultobj;
4344 fail:
4345 return NULL;
4346 }
4347
4348
4349 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4350 PyObject *resultobj;
4351 wxBitmap *arg1 = (wxBitmap *) 0 ;
4352 bool result;
4353 PyObject * obj0 = 0 ;
4354 char *kwnames[] = {
4355 (char *) "self", NULL
4356 };
4357
4358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4360 if (SWIG_arg_fail(1)) SWIG_fail;
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 result = (bool)(arg1)->Ok();
4364
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 {
4369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4370 }
4371 return resultobj;
4372 fail:
4373 return NULL;
4374 }
4375
4376
4377 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj;
4379 wxBitmap *arg1 = (wxBitmap *) 0 ;
4380 int result;
4381 PyObject * obj0 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 result = (int)(arg1)->GetWidth();
4392
4393 wxPyEndAllowThreads(__tstate);
4394 if (PyErr_Occurred()) SWIG_fail;
4395 }
4396 {
4397 resultobj = SWIG_From_int((int)(result));
4398 }
4399 return resultobj;
4400 fail:
4401 return NULL;
4402 }
4403
4404
4405 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4406 PyObject *resultobj;
4407 wxBitmap *arg1 = (wxBitmap *) 0 ;
4408 int result;
4409 PyObject * obj0 = 0 ;
4410 char *kwnames[] = {
4411 (char *) "self", NULL
4412 };
4413
4414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4416 if (SWIG_arg_fail(1)) SWIG_fail;
4417 {
4418 PyThreadState* __tstate = wxPyBeginAllowThreads();
4419 result = (int)(arg1)->GetHeight();
4420
4421 wxPyEndAllowThreads(__tstate);
4422 if (PyErr_Occurred()) SWIG_fail;
4423 }
4424 {
4425 resultobj = SWIG_From_int((int)(result));
4426 }
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4434 PyObject *resultobj;
4435 wxBitmap *arg1 = (wxBitmap *) 0 ;
4436 int result;
4437 PyObject * obj0 = 0 ;
4438 char *kwnames[] = {
4439 (char *) "self", NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4444 if (SWIG_arg_fail(1)) SWIG_fail;
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 result = (int)(arg1)->GetDepth();
4448
4449 wxPyEndAllowThreads(__tstate);
4450 if (PyErr_Occurred()) SWIG_fail;
4451 }
4452 {
4453 resultobj = SWIG_From_int((int)(result));
4454 }
4455 return resultobj;
4456 fail:
4457 return NULL;
4458 }
4459
4460
4461 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4462 PyObject *resultobj;
4463 wxBitmap *arg1 = (wxBitmap *) 0 ;
4464 wxSize result;
4465 PyObject * obj0 = 0 ;
4466 char *kwnames[] = {
4467 (char *) "self", NULL
4468 };
4469
4470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4472 if (SWIG_arg_fail(1)) SWIG_fail;
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = wxBitmap_GetSize(arg1);
4476
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 {
4481 wxSize * resultptr;
4482 resultptr = new wxSize((wxSize &)(result));
4483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 wxBitmap *arg1 = (wxBitmap *) 0 ;
4494 SwigValueWrapper<wxImage > result;
4495 PyObject * obj0 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 PyThreadState* __tstate = wxPyBeginAllowThreads();
4505 result = ((wxBitmap const *)arg1)->ConvertToImage();
4506
4507 wxPyEndAllowThreads(__tstate);
4508 if (PyErr_Occurred()) SWIG_fail;
4509 }
4510 {
4511 wxImage * resultptr;
4512 resultptr = new wxImage((wxImage &)(result));
4513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4514 }
4515 return resultobj;
4516 fail:
4517 return NULL;
4518 }
4519
4520
4521 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4522 PyObject *resultobj;
4523 wxBitmap *arg1 = (wxBitmap *) 0 ;
4524 wxMask *result;
4525 PyObject * obj0 = 0 ;
4526 char *kwnames[] = {
4527 (char *) "self", NULL
4528 };
4529
4530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4532 if (SWIG_arg_fail(1)) SWIG_fail;
4533 {
4534 PyThreadState* __tstate = wxPyBeginAllowThreads();
4535 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4536
4537 wxPyEndAllowThreads(__tstate);
4538 if (PyErr_Occurred()) SWIG_fail;
4539 }
4540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj;
4549 wxBitmap *arg1 = (wxBitmap *) 0 ;
4550 wxMask *arg2 = (wxMask *) 0 ;
4551 PyObject * obj0 = 0 ;
4552 PyObject * obj1 = 0 ;
4553 char *kwnames[] = {
4554 (char *) "self",(char *) "mask", NULL
4555 };
4556
4557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4559 if (SWIG_arg_fail(1)) SWIG_fail;
4560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4561 if (SWIG_arg_fail(2)) SWIG_fail;
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 (arg1)->SetMask(arg2);
4565
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 Py_INCREF(Py_None); resultobj = Py_None;
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj;
4578 wxBitmap *arg1 = (wxBitmap *) 0 ;
4579 wxColour *arg2 = 0 ;
4580 wxColour temp2 ;
4581 PyObject * obj0 = 0 ;
4582 PyObject * obj1 = 0 ;
4583 char *kwnames[] = {
4584 (char *) "self",(char *) "colour", NULL
4585 };
4586
4587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4589 if (SWIG_arg_fail(1)) SWIG_fail;
4590 {
4591 arg2 = &temp2;
4592 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4593 }
4594 {
4595 PyThreadState* __tstate = wxPyBeginAllowThreads();
4596 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4597
4598 wxPyEndAllowThreads(__tstate);
4599 if (PyErr_Occurred()) SWIG_fail;
4600 }
4601 Py_INCREF(Py_None); resultobj = Py_None;
4602 return resultobj;
4603 fail:
4604 return NULL;
4605 }
4606
4607
4608 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4609 PyObject *resultobj;
4610 wxBitmap *arg1 = (wxBitmap *) 0 ;
4611 wxRect *arg2 = 0 ;
4612 SwigValueWrapper<wxBitmap > result;
4613 wxRect temp2 ;
4614 PyObject * obj0 = 0 ;
4615 PyObject * obj1 = 0 ;
4616 char *kwnames[] = {
4617 (char *) "self",(char *) "rect", NULL
4618 };
4619
4620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4622 if (SWIG_arg_fail(1)) SWIG_fail;
4623 {
4624 arg2 = &temp2;
4625 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4626 }
4627 {
4628 PyThreadState* __tstate = wxPyBeginAllowThreads();
4629 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4630
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 wxBitmap * resultptr;
4636 resultptr = new wxBitmap((wxBitmap &)(result));
4637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4638 }
4639 return resultobj;
4640 fail:
4641 return NULL;
4642 }
4643
4644
4645 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4646 PyObject *resultobj;
4647 wxBitmap *arg1 = (wxBitmap *) 0 ;
4648 wxString *arg2 = 0 ;
4649 wxBitmapType arg3 ;
4650 wxPalette *arg4 = (wxPalette *) NULL ;
4651 bool result;
4652 bool temp2 = false ;
4653 PyObject * obj0 = 0 ;
4654 PyObject * obj1 = 0 ;
4655 PyObject * obj2 = 0 ;
4656 PyObject * obj3 = 0 ;
4657 char *kwnames[] = {
4658 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4659 };
4660
4661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4663 if (SWIG_arg_fail(1)) SWIG_fail;
4664 {
4665 arg2 = wxString_in_helper(obj1);
4666 if (arg2 == NULL) SWIG_fail;
4667 temp2 = true;
4668 }
4669 {
4670 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4671 if (SWIG_arg_fail(3)) SWIG_fail;
4672 }
4673 if (obj3) {
4674 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4675 if (SWIG_arg_fail(4)) SWIG_fail;
4676 }
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4680
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 {
4688 if (temp2)
4689 delete arg2;
4690 }
4691 return resultobj;
4692 fail:
4693 {
4694 if (temp2)
4695 delete arg2;
4696 }
4697 return NULL;
4698 }
4699
4700
4701 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4702 PyObject *resultobj;
4703 wxBitmap *arg1 = (wxBitmap *) 0 ;
4704 wxString *arg2 = 0 ;
4705 wxBitmapType arg3 ;
4706 bool result;
4707 bool temp2 = false ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 PyObject * obj2 = 0 ;
4711 char *kwnames[] = {
4712 (char *) "self",(char *) "name",(char *) "type", NULL
4713 };
4714
4715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4717 if (SWIG_arg_fail(1)) SWIG_fail;
4718 {
4719 arg2 = wxString_in_helper(obj1);
4720 if (arg2 == NULL) SWIG_fail;
4721 temp2 = true;
4722 }
4723 {
4724 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4725 if (SWIG_arg_fail(3)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 {
4735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4736 }
4737 {
4738 if (temp2)
4739 delete arg2;
4740 }
4741 return resultobj;
4742 fail:
4743 {
4744 if (temp2)
4745 delete arg2;
4746 }
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxBitmap *arg1 = (wxBitmap *) 0 ;
4754 wxPalette *result;
4755 PyObject * obj0 = 0 ;
4756 char *kwnames[] = {
4757 (char *) "self", NULL
4758 };
4759
4760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4762 if (SWIG_arg_fail(1)) SWIG_fail;
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4766
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj;
4779 wxBitmap *arg1 = (wxBitmap *) 0 ;
4780 wxPalette *arg2 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char *kwnames[] = {
4784 (char *) "self",(char *) "palette", NULL
4785 };
4786
4787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4789 if (SWIG_arg_fail(1)) SWIG_fail;
4790 {
4791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4792 if (SWIG_arg_fail(2)) SWIG_fail;
4793 if (arg2 == NULL) {
4794 SWIG_null_ref("wxPalette");
4795 }
4796 if (SWIG_arg_fail(2)) SWIG_fail;
4797 }
4798 {
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 (arg1)->SetPalette((wxPalette const &)*arg2);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 Py_INCREF(Py_None); resultobj = Py_None;
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4813 PyObject *resultobj;
4814 wxBitmap *arg1 = (wxBitmap *) 0 ;
4815 wxIcon *arg2 = 0 ;
4816 bool result;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char *kwnames[] = {
4820 (char *) "self",(char *) "icon", NULL
4821 };
4822
4823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4825 if (SWIG_arg_fail(1)) SWIG_fail;
4826 {
4827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4828 if (SWIG_arg_fail(2)) SWIG_fail;
4829 if (arg2 == NULL) {
4830 SWIG_null_ref("wxIcon");
4831 }
4832 if (SWIG_arg_fail(2)) SWIG_fail;
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 {
4842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4843 }
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj;
4852 wxBitmap *arg1 = (wxBitmap *) 0 ;
4853 int arg2 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char *kwnames[] = {
4857 (char *) "self",(char *) "height", NULL
4858 };
4859
4860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4862 if (SWIG_arg_fail(1)) SWIG_fail;
4863 {
4864 arg2 = (int)(SWIG_As_int(obj1));
4865 if (SWIG_arg_fail(2)) SWIG_fail;
4866 }
4867 {
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 (arg1)->SetHeight(arg2);
4870
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 Py_INCREF(Py_None); resultobj = Py_None;
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj;
4883 wxBitmap *arg1 = (wxBitmap *) 0 ;
4884 int arg2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self",(char *) "width", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 {
4895 arg2 = (int)(SWIG_As_int(obj1));
4896 if (SWIG_arg_fail(2)) SWIG_fail;
4897 }
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 (arg1)->SetWidth(arg2);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 Py_INCREF(Py_None); resultobj = Py_None;
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxBitmap *arg1 = (wxBitmap *) 0 ;
4915 int arg2 ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 char *kwnames[] = {
4919 (char *) "self",(char *) "depth", NULL
4920 };
4921
4922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4924 if (SWIG_arg_fail(1)) SWIG_fail;
4925 {
4926 arg2 = (int)(SWIG_As_int(obj1));
4927 if (SWIG_arg_fail(2)) SWIG_fail;
4928 }
4929 {
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 (arg1)->SetDepth(arg2);
4932
4933 wxPyEndAllowThreads(__tstate);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 Py_INCREF(Py_None); resultobj = Py_None;
4937 return resultobj;
4938 fail:
4939 return NULL;
4940 }
4941
4942
4943 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4944 PyObject *resultobj;
4945 wxBitmap *arg1 = (wxBitmap *) 0 ;
4946 wxSize *arg2 = 0 ;
4947 wxSize temp2 ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 char *kwnames[] = {
4951 (char *) "self",(char *) "size", NULL
4952 };
4953
4954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4956 if (SWIG_arg_fail(1)) SWIG_fail;
4957 {
4958 arg2 = &temp2;
4959 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4960 }
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4964
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 Py_INCREF(Py_None); resultobj = Py_None;
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj;
4977 wxBitmap *arg1 = (wxBitmap *) 0 ;
4978 wxCursor *arg2 = 0 ;
4979 bool result;
4980 PyObject * obj0 = 0 ;
4981 PyObject * obj1 = 0 ;
4982 char *kwnames[] = {
4983 (char *) "self",(char *) "cursor", NULL
4984 };
4985
4986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4988 if (SWIG_arg_fail(1)) SWIG_fail;
4989 {
4990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4991 if (SWIG_arg_fail(2)) SWIG_fail;
4992 if (arg2 == NULL) {
4993 SWIG_null_ref("wxCursor");
4994 }
4995 if (SWIG_arg_fail(2)) SWIG_fail;
4996 }
4997 {
4998 PyThreadState* __tstate = wxPyBeginAllowThreads();
4999 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
5000
5001 wxPyEndAllowThreads(__tstate);
5002 if (PyErr_Occurred()) SWIG_fail;
5003 }
5004 {
5005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5006 }
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj;
5015 wxBitmap *arg1 = (wxBitmap *) 0 ;
5016 wxBitmap *arg2 = (wxBitmap *) 0 ;
5017 bool result;
5018 PyObject * obj0 = 0 ;
5019 PyObject * obj1 = 0 ;
5020 char *kwnames[] = {
5021 (char *) "self",(char *) "other", NULL
5022 };
5023
5024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5026 if (SWIG_arg_fail(1)) SWIG_fail;
5027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5028 if (SWIG_arg_fail(2)) SWIG_fail;
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5032
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 {
5037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5038 }
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj;
5047 wxBitmap *arg1 = (wxBitmap *) 0 ;
5048 wxBitmap *arg2 = (wxBitmap *) 0 ;
5049 bool result;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char *kwnames[] = {
5053 (char *) "self",(char *) "other", NULL
5054 };
5055
5056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5058 if (SWIG_arg_fail(1)) SWIG_fail;
5059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5060 if (SWIG_arg_fail(2)) SWIG_fail;
5061 {
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5064
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 {
5069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5070 }
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5078 PyObject *obj;
5079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5080 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5081 Py_INCREF(obj);
5082 return Py_BuildValue((char *)"");
5083 }
5084 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 wxBitmap *arg1 = 0 ;
5087 wxColour const &arg2_defvalue = wxNullColour ;
5088 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5089 wxMask *result;
5090 wxColour temp2 ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 char *kwnames[] = {
5094 (char *) "bitmap",(char *) "colour", NULL
5095 };
5096
5097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5098 {
5099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5100 if (SWIG_arg_fail(1)) SWIG_fail;
5101 if (arg1 == NULL) {
5102 SWIG_null_ref("wxBitmap");
5103 }
5104 if (SWIG_arg_fail(1)) SWIG_fail;
5105 }
5106 if (obj1) {
5107 {
5108 arg2 = &temp2;
5109 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5110 }
5111 }
5112 {
5113 if (!wxPyCheckForApp()) SWIG_fail;
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5116
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5128 PyObject *obj;
5129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5130 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5131 Py_INCREF(obj);
5132 return Py_BuildValue((char *)"");
5133 }
5134 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj;
5136 wxString *arg1 = 0 ;
5137 wxBitmapType arg2 ;
5138 int arg3 = (int) -1 ;
5139 int arg4 = (int) -1 ;
5140 wxIcon *result;
5141 bool temp1 = false ;
5142 PyObject * obj0 = 0 ;
5143 PyObject * obj1 = 0 ;
5144 PyObject * obj2 = 0 ;
5145 PyObject * obj3 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5151 {
5152 arg1 = wxString_in_helper(obj0);
5153 if (arg1 == NULL) SWIG_fail;
5154 temp1 = true;
5155 }
5156 {
5157 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5158 if (SWIG_arg_fail(2)) SWIG_fail;
5159 }
5160 if (obj2) {
5161 {
5162 arg3 = (int)(SWIG_As_int(obj2));
5163 if (SWIG_arg_fail(3)) SWIG_fail;
5164 }
5165 }
5166 if (obj3) {
5167 {
5168 arg4 = (int)(SWIG_As_int(obj3));
5169 if (SWIG_arg_fail(4)) SWIG_fail;
5170 }
5171 }
5172 {
5173 if (!wxPyCheckForApp()) SWIG_fail;
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5176
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5181 {
5182 if (temp1)
5183 delete arg1;
5184 }
5185 return resultobj;
5186 fail:
5187 {
5188 if (temp1)
5189 delete arg1;
5190 }
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 wxIcon *arg1 = (wxIcon *) 0 ;
5198 PyObject * obj0 = 0 ;
5199 char *kwnames[] = {
5200 (char *) "self", NULL
5201 };
5202
5203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5205 if (SWIG_arg_fail(1)) SWIG_fail;
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 delete arg1;
5209
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 Py_INCREF(Py_None); resultobj = Py_None;
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxIcon *result;
5223 char *kwnames[] = {
5224 NULL
5225 };
5226
5227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5228 {
5229 if (!wxPyCheckForApp()) SWIG_fail;
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 result = (wxIcon *)new wxIcon();
5232
5233 wxPyEndAllowThreads(__tstate);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxIconLocation *arg1 = 0 ;
5246 wxIcon *result;
5247 PyObject * obj0 = 0 ;
5248 char *kwnames[] = {
5249 (char *) "loc", NULL
5250 };
5251
5252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5253 {
5254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5255 if (SWIG_arg_fail(1)) SWIG_fail;
5256 if (arg1 == NULL) {
5257 SWIG_null_ref("wxIconLocation");
5258 }
5259 if (SWIG_arg_fail(1)) SWIG_fail;
5260 }
5261 {
5262 if (!wxPyCheckForApp()) SWIG_fail;
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5265
5266 wxPyEndAllowThreads(__tstate);
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5270 return resultobj;
5271 fail:
5272 return NULL;
5273 }
5274
5275
5276 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5277 PyObject *resultobj;
5278 wxBitmap *arg1 = 0 ;
5279 wxIcon *result;
5280 PyObject * obj0 = 0 ;
5281 char *kwnames[] = {
5282 (char *) "bmp", NULL
5283 };
5284
5285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5286 {
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 if (arg1 == NULL) {
5290 SWIG_null_ref("wxBitmap");
5291 }
5292 if (SWIG_arg_fail(1)) SWIG_fail;
5293 }
5294 {
5295 if (!wxPyCheckForApp()) SWIG_fail;
5296 PyThreadState* __tstate = wxPyBeginAllowThreads();
5297 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5298
5299 wxPyEndAllowThreads(__tstate);
5300 if (PyErr_Occurred()) SWIG_fail;
5301 }
5302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5303 return resultobj;
5304 fail:
5305 return NULL;
5306 }
5307
5308
5309 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5310 PyObject *resultobj;
5311 PyObject *arg1 = (PyObject *) 0 ;
5312 wxIcon *result;
5313 PyObject * obj0 = 0 ;
5314 char *kwnames[] = {
5315 (char *) "listOfStrings", NULL
5316 };
5317
5318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5319 arg1 = obj0;
5320 {
5321 if (!wxPyCheckForApp()) SWIG_fail;
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxIcon *)new_wxIcon(arg1);
5324
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj;
5337 wxIcon *arg1 = (wxIcon *) 0 ;
5338 wxString *arg2 = 0 ;
5339 wxBitmapType arg3 ;
5340 bool result;
5341 bool temp2 = false ;
5342 PyObject * obj0 = 0 ;
5343 PyObject * obj1 = 0 ;
5344 PyObject * obj2 = 0 ;
5345 char *kwnames[] = {
5346 (char *) "self",(char *) "name",(char *) "type", NULL
5347 };
5348
5349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5351 if (SWIG_arg_fail(1)) SWIG_fail;
5352 {
5353 arg2 = wxString_in_helper(obj1);
5354 if (arg2 == NULL) SWIG_fail;
5355 temp2 = true;
5356 }
5357 {
5358 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5359 if (SWIG_arg_fail(3)) SWIG_fail;
5360 }
5361 {
5362 PyThreadState* __tstate = wxPyBeginAllowThreads();
5363 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5364
5365 wxPyEndAllowThreads(__tstate);
5366 if (PyErr_Occurred()) SWIG_fail;
5367 }
5368 {
5369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5370 }
5371 {
5372 if (temp2)
5373 delete arg2;
5374 }
5375 return resultobj;
5376 fail:
5377 {
5378 if (temp2)
5379 delete arg2;
5380 }
5381 return NULL;
5382 }
5383
5384
5385 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj;
5387 wxIcon *arg1 = (wxIcon *) 0 ;
5388 long result;
5389 PyObject * obj0 = 0 ;
5390 char *kwnames[] = {
5391 (char *) "self", NULL
5392 };
5393
5394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5396 if (SWIG_arg_fail(1)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (long)(arg1)->GetHandle();
5400
5401 wxPyEndAllowThreads(__tstate);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 {
5405 resultobj = SWIG_From_long((long)(result));
5406 }
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj;
5415 wxIcon *arg1 = (wxIcon *) 0 ;
5416 long arg2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self",(char *) "handle", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 {
5427 arg2 = (long)(SWIG_As_long(obj1));
5428 if (SWIG_arg_fail(2)) SWIG_fail;
5429 }
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 wxIcon_SetHandle(arg1,arg2);
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 Py_INCREF(Py_None); resultobj = Py_None;
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 wxIcon *arg1 = (wxIcon *) 0 ;
5447 bool result;
5448 PyObject * obj0 = 0 ;
5449 char *kwnames[] = {
5450 (char *) "self", NULL
5451 };
5452
5453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5455 if (SWIG_arg_fail(1)) SWIG_fail;
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 result = (bool)(arg1)->Ok();
5459
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 wxIcon *arg1 = (wxIcon *) 0 ;
5475 int result;
5476 PyObject * obj0 = 0 ;
5477 char *kwnames[] = {
5478 (char *) "self", NULL
5479 };
5480
5481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5483 if (SWIG_arg_fail(1)) SWIG_fail;
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (int)(arg1)->GetWidth();
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = SWIG_From_int((int)(result));
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5501 PyObject *resultobj;
5502 wxIcon *arg1 = (wxIcon *) 0 ;
5503 int result;
5504 PyObject * obj0 = 0 ;
5505 char *kwnames[] = {
5506 (char *) "self", NULL
5507 };
5508
5509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5511 if (SWIG_arg_fail(1)) SWIG_fail;
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (int)(arg1)->GetHeight();
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 {
5520 resultobj = SWIG_From_int((int)(result));
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj;
5530 wxIcon *arg1 = (wxIcon *) 0 ;
5531 int result;
5532 PyObject * obj0 = 0 ;
5533 char *kwnames[] = {
5534 (char *) "self", NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5539 if (SWIG_arg_fail(1)) SWIG_fail;
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 result = (int)(arg1)->GetDepth();
5543
5544 wxPyEndAllowThreads(__tstate);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 {
5548 resultobj = SWIG_From_int((int)(result));
5549 }
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5557 PyObject *resultobj;
5558 wxIcon *arg1 = (wxIcon *) 0 ;
5559 int arg2 ;
5560 PyObject * obj0 = 0 ;
5561 PyObject * obj1 = 0 ;
5562 char *kwnames[] = {
5563 (char *) "self",(char *) "w", NULL
5564 };
5565
5566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5568 if (SWIG_arg_fail(1)) SWIG_fail;
5569 {
5570 arg2 = (int)(SWIG_As_int(obj1));
5571 if (SWIG_arg_fail(2)) SWIG_fail;
5572 }
5573 {
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 (arg1)->SetWidth(arg2);
5576
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 Py_INCREF(Py_None); resultobj = Py_None;
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5588 PyObject *resultobj;
5589 wxIcon *arg1 = (wxIcon *) 0 ;
5590 int arg2 ;
5591 PyObject * obj0 = 0 ;
5592 PyObject * obj1 = 0 ;
5593 char *kwnames[] = {
5594 (char *) "self",(char *) "h", NULL
5595 };
5596
5597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5599 if (SWIG_arg_fail(1)) SWIG_fail;
5600 {
5601 arg2 = (int)(SWIG_As_int(obj1));
5602 if (SWIG_arg_fail(2)) SWIG_fail;
5603 }
5604 {
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 (arg1)->SetHeight(arg2);
5607
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 Py_INCREF(Py_None); resultobj = Py_None;
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5619 PyObject *resultobj;
5620 wxIcon *arg1 = (wxIcon *) 0 ;
5621 int arg2 ;
5622 PyObject * obj0 = 0 ;
5623 PyObject * obj1 = 0 ;
5624 char *kwnames[] = {
5625 (char *) "self",(char *) "d", NULL
5626 };
5627
5628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5630 if (SWIG_arg_fail(1)) SWIG_fail;
5631 {
5632 arg2 = (int)(SWIG_As_int(obj1));
5633 if (SWIG_arg_fail(2)) SWIG_fail;
5634 }
5635 {
5636 PyThreadState* __tstate = wxPyBeginAllowThreads();
5637 (arg1)->SetDepth(arg2);
5638
5639 wxPyEndAllowThreads(__tstate);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 Py_INCREF(Py_None); resultobj = Py_None;
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxIcon *arg1 = (wxIcon *) 0 ;
5652 wxSize *arg2 = 0 ;
5653 wxSize temp2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char *kwnames[] = {
5657 (char *) "self",(char *) "size", NULL
5658 };
5659
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5662 if (SWIG_arg_fail(1)) SWIG_fail;
5663 {
5664 arg2 = &temp2;
5665 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5666 }
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 (arg1)->SetSize((wxSize const &)*arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxIcon *arg1 = (wxIcon *) 0 ;
5684 wxBitmap *arg2 = 0 ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "self",(char *) "bmp", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 {
5695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5696 if (SWIG_arg_fail(2)) SWIG_fail;
5697 if (arg2 == NULL) {
5698 SWIG_null_ref("wxBitmap");
5699 }
5700 if (SWIG_arg_fail(2)) SWIG_fail;
5701 }
5702 {
5703 PyThreadState* __tstate = wxPyBeginAllowThreads();
5704 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5705
5706 wxPyEndAllowThreads(__tstate);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 Py_INCREF(Py_None); resultobj = Py_None;
5710 return resultobj;
5711 fail:
5712 return NULL;
5713 }
5714
5715
5716 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5717 PyObject *obj;
5718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5719 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5720 Py_INCREF(obj);
5721 return Py_BuildValue((char *)"");
5722 }
5723 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj;
5725 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5726 int arg2 = (int) 0 ;
5727 wxIconLocation *result;
5728 bool temp1 = false ;
5729 PyObject * obj0 = 0 ;
5730 PyObject * obj1 = 0 ;
5731 char *kwnames[] = {
5732 (char *) "filename",(char *) "num", NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5736 if (obj0) {
5737 {
5738 arg1 = wxString_in_helper(obj0);
5739 if (arg1 == NULL) SWIG_fail;
5740 temp1 = true;
5741 }
5742 }
5743 if (obj1) {
5744 {
5745 arg2 = (int)(SWIG_As_int(obj1));
5746 if (SWIG_arg_fail(2)) SWIG_fail;
5747 }
5748 }
5749 {
5750 PyThreadState* __tstate = wxPyBeginAllowThreads();
5751 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5752
5753 wxPyEndAllowThreads(__tstate);
5754 if (PyErr_Occurred()) SWIG_fail;
5755 }
5756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5757 {
5758 if (temp1)
5759 delete arg1;
5760 }
5761 return resultobj;
5762 fail:
5763 {
5764 if (temp1)
5765 delete arg1;
5766 }
5767 return NULL;
5768 }
5769
5770
5771 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5772 PyObject *resultobj;
5773 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5774 PyObject * obj0 = 0 ;
5775 char *kwnames[] = {
5776 (char *) "self", NULL
5777 };
5778
5779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5781 if (SWIG_arg_fail(1)) SWIG_fail;
5782 {
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 delete arg1;
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 Py_INCREF(Py_None); resultobj = Py_None;
5790 return resultobj;
5791 fail:
5792 return NULL;
5793 }
5794
5795
5796 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5797 PyObject *resultobj;
5798 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5799 bool result;
5800 PyObject * obj0 = 0 ;
5801 char *kwnames[] = {
5802 (char *) "self", NULL
5803 };
5804
5805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5807 if (SWIG_arg_fail(1)) SWIG_fail;
5808 {
5809 PyThreadState* __tstate = wxPyBeginAllowThreads();
5810 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5811
5812 wxPyEndAllowThreads(__tstate);
5813 if (PyErr_Occurred()) SWIG_fail;
5814 }
5815 {
5816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5817 }
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5825 PyObject *resultobj;
5826 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5827 wxString *arg2 = 0 ;
5828 bool temp2 = false ;
5829 PyObject * obj0 = 0 ;
5830 PyObject * obj1 = 0 ;
5831 char *kwnames[] = {
5832 (char *) "self",(char *) "filename", NULL
5833 };
5834
5835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5837 if (SWIG_arg_fail(1)) SWIG_fail;
5838 {
5839 arg2 = wxString_in_helper(obj1);
5840 if (arg2 == NULL) SWIG_fail;
5841 temp2 = true;
5842 }
5843 {
5844 PyThreadState* __tstate = wxPyBeginAllowThreads();
5845 (arg1)->SetFileName((wxString const &)*arg2);
5846
5847 wxPyEndAllowThreads(__tstate);
5848 if (PyErr_Occurred()) SWIG_fail;
5849 }
5850 Py_INCREF(Py_None); resultobj = Py_None;
5851 {
5852 if (temp2)
5853 delete arg2;
5854 }
5855 return resultobj;
5856 fail:
5857 {
5858 if (temp2)
5859 delete arg2;
5860 }
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5868 wxString *result;
5869 PyObject * obj0 = 0 ;
5870 char *kwnames[] = {
5871 (char *) "self", NULL
5872 };
5873
5874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5876 if (SWIG_arg_fail(1)) SWIG_fail;
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 {
5880 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5881 result = (wxString *) &_result_ref;
5882 }
5883
5884 wxPyEndAllowThreads(__tstate);
5885 if (PyErr_Occurred()) SWIG_fail;
5886 }
5887 {
5888 #if wxUSE_UNICODE
5889 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5890 #else
5891 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5892 #endif
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5903 int arg2 ;
5904 PyObject * obj0 = 0 ;
5905 PyObject * obj1 = 0 ;
5906 char *kwnames[] = {
5907 (char *) "self",(char *) "num", NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5912 if (SWIG_arg_fail(1)) SWIG_fail;
5913 {
5914 arg2 = (int)(SWIG_As_int(obj1));
5915 if (SWIG_arg_fail(2)) SWIG_fail;
5916 }
5917 {
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 wxIconLocation_SetIndex(arg1,arg2);
5920
5921 wxPyEndAllowThreads(__tstate);
5922 if (PyErr_Occurred()) SWIG_fail;
5923 }
5924 Py_INCREF(Py_None); resultobj = Py_None;
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj;
5933 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5934 int result;
5935 PyObject * obj0 = 0 ;
5936 char *kwnames[] = {
5937 (char *) "self", NULL
5938 };
5939
5940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5942 if (SWIG_arg_fail(1)) SWIG_fail;
5943 {
5944 PyThreadState* __tstate = wxPyBeginAllowThreads();
5945 result = (int)wxIconLocation_GetIndex(arg1);
5946
5947 wxPyEndAllowThreads(__tstate);
5948 if (PyErr_Occurred()) SWIG_fail;
5949 }
5950 {
5951 resultobj = SWIG_From_int((int)(result));
5952 }
5953 return resultobj;
5954 fail:
5955 return NULL;
5956 }
5957
5958
5959 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5960 PyObject *obj;
5961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5962 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5963 Py_INCREF(obj);
5964 return Py_BuildValue((char *)"");
5965 }
5966 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj;
5968 wxIconBundle *result;
5969 char *kwnames[] = {
5970 NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5974 {
5975 PyThreadState* __tstate = wxPyBeginAllowThreads();
5976 result = (wxIconBundle *)new wxIconBundle();
5977
5978 wxPyEndAllowThreads(__tstate);
5979 if (PyErr_Occurred()) SWIG_fail;
5980 }
5981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5982 return resultobj;
5983 fail:
5984 return NULL;
5985 }
5986
5987
5988 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5989 PyObject *resultobj;
5990 wxString *arg1 = 0 ;
5991 long arg2 ;
5992 wxIconBundle *result;
5993 bool temp1 = false ;
5994 PyObject * obj0 = 0 ;
5995 PyObject * obj1 = 0 ;
5996 char *kwnames[] = {
5997 (char *) "file",(char *) "type", NULL
5998 };
5999
6000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6001 {
6002 arg1 = wxString_in_helper(obj0);
6003 if (arg1 == NULL) SWIG_fail;
6004 temp1 = true;
6005 }
6006 {
6007 arg2 = (long)(SWIG_As_long(obj1));
6008 if (SWIG_arg_fail(2)) SWIG_fail;
6009 }
6010 {
6011 PyThreadState* __tstate = wxPyBeginAllowThreads();
6012 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6013
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6018 {
6019 if (temp1)
6020 delete arg1;
6021 }
6022 return resultobj;
6023 fail:
6024 {
6025 if (temp1)
6026 delete arg1;
6027 }
6028 return NULL;
6029 }
6030
6031
6032 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6033 PyObject *resultobj;
6034 wxIcon *arg1 = 0 ;
6035 wxIconBundle *result;
6036 PyObject * obj0 = 0 ;
6037 char *kwnames[] = {
6038 (char *) "icon", NULL
6039 };
6040
6041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6042 {
6043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6044 if (SWIG_arg_fail(1)) SWIG_fail;
6045 if (arg1 == NULL) {
6046 SWIG_null_ref("wxIcon");
6047 }
6048 if (SWIG_arg_fail(1)) SWIG_fail;
6049 }
6050 {
6051 PyThreadState* __tstate = wxPyBeginAllowThreads();
6052 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6053
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6058 return resultobj;
6059 fail:
6060 return NULL;
6061 }
6062
6063
6064 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6065 PyObject *resultobj;
6066 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6067 PyObject * obj0 = 0 ;
6068 char *kwnames[] = {
6069 (char *) "self", NULL
6070 };
6071
6072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6074 if (SWIG_arg_fail(1)) SWIG_fail;
6075 {
6076 PyThreadState* __tstate = wxPyBeginAllowThreads();
6077 delete arg1;
6078
6079 wxPyEndAllowThreads(__tstate);
6080 if (PyErr_Occurred()) SWIG_fail;
6081 }
6082 Py_INCREF(Py_None); resultobj = Py_None;
6083 return resultobj;
6084 fail:
6085 return NULL;
6086 }
6087
6088
6089 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6090 PyObject *resultobj;
6091 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6092 wxIcon *arg2 = 0 ;
6093 PyObject * obj0 = 0 ;
6094 PyObject * obj1 = 0 ;
6095 char *kwnames[] = {
6096 (char *) "self",(char *) "icon", NULL
6097 };
6098
6099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6101 if (SWIG_arg_fail(1)) SWIG_fail;
6102 {
6103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6104 if (SWIG_arg_fail(2)) SWIG_fail;
6105 if (arg2 == NULL) {
6106 SWIG_null_ref("wxIcon");
6107 }
6108 if (SWIG_arg_fail(2)) SWIG_fail;
6109 }
6110 {
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 (arg1)->AddIcon((wxIcon const &)*arg2);
6113
6114 wxPyEndAllowThreads(__tstate);
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 Py_INCREF(Py_None); resultobj = Py_None;
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
6124 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj;
6126 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6127 wxString *arg2 = 0 ;
6128 long arg3 ;
6129 bool temp2 = false ;
6130 PyObject * obj0 = 0 ;
6131 PyObject * obj1 = 0 ;
6132 PyObject * obj2 = 0 ;
6133 char *kwnames[] = {
6134 (char *) "self",(char *) "file",(char *) "type", NULL
6135 };
6136
6137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6139 if (SWIG_arg_fail(1)) SWIG_fail;
6140 {
6141 arg2 = wxString_in_helper(obj1);
6142 if (arg2 == NULL) SWIG_fail;
6143 temp2 = true;
6144 }
6145 {
6146 arg3 = (long)(SWIG_As_long(obj2));
6147 if (SWIG_arg_fail(3)) SWIG_fail;
6148 }
6149 {
6150 PyThreadState* __tstate = wxPyBeginAllowThreads();
6151 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6152
6153 wxPyEndAllowThreads(__tstate);
6154 if (PyErr_Occurred()) SWIG_fail;
6155 }
6156 Py_INCREF(Py_None); resultobj = Py_None;
6157 {
6158 if (temp2)
6159 delete arg2;
6160 }
6161 return resultobj;
6162 fail:
6163 {
6164 if (temp2)
6165 delete arg2;
6166 }
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6174 wxSize *arg2 = 0 ;
6175 wxIcon *result;
6176 wxSize temp2 ;
6177 PyObject * obj0 = 0 ;
6178 PyObject * obj1 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self",(char *) "size", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 {
6187 arg2 = &temp2;
6188 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6189 }
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 {
6193 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6194 result = (wxIcon *) &_result_ref;
6195 }
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 {
6201 wxIcon* resultptr = new wxIcon(*result);
6202 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6203 }
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6211 PyObject *obj;
6212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6213 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6214 Py_INCREF(obj);
6215 return Py_BuildValue((char *)"");
6216 }
6217 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6218 PyObject *resultobj;
6219 wxString *arg1 = 0 ;
6220 long arg2 ;
6221 int arg3 = (int) 0 ;
6222 int arg4 = (int) 0 ;
6223 wxCursor *result;
6224 bool temp1 = false ;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 PyObject * obj2 = 0 ;
6228 PyObject * obj3 = 0 ;
6229 char *kwnames[] = {
6230 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6231 };
6232
6233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6234 {
6235 arg1 = wxString_in_helper(obj0);
6236 if (arg1 == NULL) SWIG_fail;
6237 temp1 = true;
6238 }
6239 {
6240 arg2 = (long)(SWIG_As_long(obj1));
6241 if (SWIG_arg_fail(2)) SWIG_fail;
6242 }
6243 if (obj2) {
6244 {
6245 arg3 = (int)(SWIG_As_int(obj2));
6246 if (SWIG_arg_fail(3)) SWIG_fail;
6247 }
6248 }
6249 if (obj3) {
6250 {
6251 arg4 = (int)(SWIG_As_int(obj3));
6252 if (SWIG_arg_fail(4)) SWIG_fail;
6253 }
6254 }
6255 {
6256 if (!wxPyCheckForApp()) SWIG_fail;
6257 PyThreadState* __tstate = wxPyBeginAllowThreads();
6258 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6259
6260 wxPyEndAllowThreads(__tstate);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6264 {
6265 if (temp1)
6266 delete arg1;
6267 }
6268 return resultobj;
6269 fail:
6270 {
6271 if (temp1)
6272 delete arg1;
6273 }
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxCursor *arg1 = (wxCursor *) 0 ;
6281 PyObject * obj0 = 0 ;
6282 char *kwnames[] = {
6283 (char *) "self", NULL
6284 };
6285
6286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6288 if (SWIG_arg_fail(1)) SWIG_fail;
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 delete arg1;
6292
6293 wxPyEndAllowThreads(__tstate);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 Py_INCREF(Py_None); resultobj = Py_None;
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj;
6305 int arg1 ;
6306 wxCursor *result;
6307 PyObject * obj0 = 0 ;
6308 char *kwnames[] = {
6309 (char *) "id", NULL
6310 };
6311
6312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6313 {
6314 arg1 = (int)(SWIG_As_int(obj0));
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 }
6317 {
6318 if (!wxPyCheckForApp()) SWIG_fail;
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 result = (wxCursor *)new wxCursor(arg1);
6321
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxImage *arg1 = 0 ;
6335 wxCursor *result;
6336 PyObject * obj0 = 0 ;
6337 char *kwnames[] = {
6338 (char *) "image", NULL
6339 };
6340
6341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6342 {
6343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6344 if (SWIG_arg_fail(1)) SWIG_fail;
6345 if (arg1 == NULL) {
6346 SWIG_null_ref("wxImage");
6347 }
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 }
6350 {
6351 if (!wxPyCheckForApp()) SWIG_fail;
6352 PyThreadState* __tstate = wxPyBeginAllowThreads();
6353 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6354
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxCursor *arg1 = (wxCursor *) 0 ;
6368 long result;
6369 PyObject * obj0 = 0 ;
6370 char *kwnames[] = {
6371 (char *) "self", NULL
6372 };
6373
6374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6376 if (SWIG_arg_fail(1)) SWIG_fail;
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (long)(arg1)->GetHandle();
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 {
6385 resultobj = SWIG_From_long((long)(result));
6386 }
6387 return resultobj;
6388 fail:
6389 return NULL;
6390 }
6391
6392
6393 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6394 PyObject *resultobj;
6395 wxCursor *arg1 = (wxCursor *) 0 ;
6396 long arg2 ;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self",(char *) "handle", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 arg2 = (long)(SWIG_As_long(obj1));
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 }
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 wxCursor_SetHandle(arg1,arg2);
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 Py_INCREF(Py_None); resultobj = Py_None;
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxCursor *arg1 = (wxCursor *) 0 ;
6427 bool result;
6428 PyObject * obj0 = 0 ;
6429 char *kwnames[] = {
6430 (char *) "self", NULL
6431 };
6432
6433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6435 if (SWIG_arg_fail(1)) SWIG_fail;
6436 {
6437 PyThreadState* __tstate = wxPyBeginAllowThreads();
6438 result = (bool)(arg1)->Ok();
6439
6440 wxPyEndAllowThreads(__tstate);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 {
6444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6445 }
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj;
6454 wxCursor *arg1 = (wxCursor *) 0 ;
6455 int result;
6456 PyObject * obj0 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "self", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 {
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 result = (int)(arg1)->GetWidth();
6467
6468 wxPyEndAllowThreads(__tstate);
6469 if (PyErr_Occurred()) SWIG_fail;
6470 }
6471 {
6472 resultobj = SWIG_From_int((int)(result));
6473 }
6474 return resultobj;
6475 fail:
6476 return NULL;
6477 }
6478
6479
6480 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6481 PyObject *resultobj;
6482 wxCursor *arg1 = (wxCursor *) 0 ;
6483 int result;
6484 PyObject * obj0 = 0 ;
6485 char *kwnames[] = {
6486 (char *) "self", NULL
6487 };
6488
6489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(1)) SWIG_fail;
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (int)(arg1)->GetHeight();
6495
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 {
6500 resultobj = SWIG_From_int((int)(result));
6501 }
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj;
6510 wxCursor *arg1 = (wxCursor *) 0 ;
6511 int result;
6512 PyObject * obj0 = 0 ;
6513 char *kwnames[] = {
6514 (char *) "self", NULL
6515 };
6516
6517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(1)) SWIG_fail;
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)(arg1)->GetDepth();
6523
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 {
6528 resultobj = SWIG_From_int((int)(result));
6529 }
6530 return resultobj;
6531 fail:
6532 return NULL;
6533 }
6534
6535
6536 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6537 PyObject *resultobj;
6538 wxCursor *arg1 = (wxCursor *) 0 ;
6539 int arg2 ;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self",(char *) "w", NULL
6544 };
6545
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6548 if (SWIG_arg_fail(1)) SWIG_fail;
6549 {
6550 arg2 = (int)(SWIG_As_int(obj1));
6551 if (SWIG_arg_fail(2)) SWIG_fail;
6552 }
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 (arg1)->SetWidth(arg2);
6556
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 Py_INCREF(Py_None); resultobj = Py_None;
6561 return resultobj;
6562 fail:
6563 return NULL;
6564 }
6565
6566
6567 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6568 PyObject *resultobj;
6569 wxCursor *arg1 = (wxCursor *) 0 ;
6570 int arg2 ;
6571 PyObject * obj0 = 0 ;
6572 PyObject * obj1 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self",(char *) "h", NULL
6575 };
6576
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 arg2 = (int)(SWIG_As_int(obj1));
6582 if (SWIG_arg_fail(2)) SWIG_fail;
6583 }
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 (arg1)->SetHeight(arg2);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 Py_INCREF(Py_None); resultobj = Py_None;
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxCursor *arg1 = (wxCursor *) 0 ;
6601 int arg2 ;
6602 PyObject * obj0 = 0 ;
6603 PyObject * obj1 = 0 ;
6604 char *kwnames[] = {
6605 (char *) "self",(char *) "d", NULL
6606 };
6607
6608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6610 if (SWIG_arg_fail(1)) SWIG_fail;
6611 {
6612 arg2 = (int)(SWIG_As_int(obj1));
6613 if (SWIG_arg_fail(2)) SWIG_fail;
6614 }
6615 {
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 (arg1)->SetDepth(arg2);
6618
6619 wxPyEndAllowThreads(__tstate);
6620 if (PyErr_Occurred()) SWIG_fail;
6621 }
6622 Py_INCREF(Py_None); resultobj = Py_None;
6623 return resultobj;
6624 fail:
6625 return NULL;
6626 }
6627
6628
6629 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6630 PyObject *resultobj;
6631 wxCursor *arg1 = (wxCursor *) 0 ;
6632 wxSize *arg2 = 0 ;
6633 wxSize temp2 ;
6634 PyObject * obj0 = 0 ;
6635 PyObject * obj1 = 0 ;
6636 char *kwnames[] = {
6637 (char *) "self",(char *) "size", NULL
6638 };
6639
6640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6642 if (SWIG_arg_fail(1)) SWIG_fail;
6643 {
6644 arg2 = &temp2;
6645 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6646 }
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 (arg1)->SetSize((wxSize const &)*arg2);
6650
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 Py_INCREF(Py_None); resultobj = Py_None;
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6662 PyObject *obj;
6663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6664 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6665 Py_INCREF(obj);
6666 return Py_BuildValue((char *)"");
6667 }
6668 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6669 PyObject *resultobj;
6670 int arg1 = (int) 0 ;
6671 int arg2 = (int) 0 ;
6672 int arg3 = (int) 0 ;
6673 int arg4 = (int) 0 ;
6674 wxRegion *result;
6675 PyObject * obj0 = 0 ;
6676 PyObject * obj1 = 0 ;
6677 PyObject * obj2 = 0 ;
6678 PyObject * obj3 = 0 ;
6679 char *kwnames[] = {
6680 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6681 };
6682
6683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6684 if (obj0) {
6685 {
6686 arg1 = (int)(SWIG_As_int(obj0));
6687 if (SWIG_arg_fail(1)) SWIG_fail;
6688 }
6689 }
6690 if (obj1) {
6691 {
6692 arg2 = (int)(SWIG_As_int(obj1));
6693 if (SWIG_arg_fail(2)) SWIG_fail;
6694 }
6695 }
6696 if (obj2) {
6697 {
6698 arg3 = (int)(SWIG_As_int(obj2));
6699 if (SWIG_arg_fail(3)) SWIG_fail;
6700 }
6701 }
6702 if (obj3) {
6703 {
6704 arg4 = (int)(SWIG_As_int(obj3));
6705 if (SWIG_arg_fail(4)) SWIG_fail;
6706 }
6707 }
6708 {
6709 if (!wxPyCheckForApp()) SWIG_fail;
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxBitmap *arg1 = 0 ;
6726 wxRegion *result;
6727 PyObject * obj0 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "bmp", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6733 {
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 if (arg1 == NULL) {
6737 SWIG_null_ref("wxBitmap");
6738 }
6739 if (SWIG_arg_fail(1)) SWIG_fail;
6740 }
6741 {
6742 if (!wxPyCheckForApp()) SWIG_fail;
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6745
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6757 PyObject *resultobj;
6758 wxBitmap *arg1 = 0 ;
6759 wxColour *arg2 = 0 ;
6760 int arg3 = (int) 0 ;
6761 wxRegion *result;
6762 wxColour temp2 ;
6763 PyObject * obj0 = 0 ;
6764 PyObject * obj1 = 0 ;
6765 PyObject * obj2 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6771 {
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 if (arg1 == NULL) {
6775 SWIG_null_ref("wxBitmap");
6776 }
6777 if (SWIG_arg_fail(1)) SWIG_fail;
6778 }
6779 {
6780 arg2 = &temp2;
6781 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6782 }
6783 if (obj2) {
6784 {
6785 arg3 = (int)(SWIG_As_int(obj2));
6786 if (SWIG_arg_fail(3)) SWIG_fail;
6787 }
6788 }
6789 {
6790 if (!wxPyCheckForApp()) SWIG_fail;
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 int arg1 ;
6807 wxPoint *arg2 = (wxPoint *) 0 ;
6808 int arg3 = (int) wxWINDING_RULE ;
6809 wxRegion *result;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "points",(char *) "fillStyle", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6817 {
6818 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6819 if (arg2 == NULL) SWIG_fail;
6820 }
6821 if (obj1) {
6822 {
6823 arg3 = (int)(SWIG_As_int(obj1));
6824 if (SWIG_arg_fail(3)) SWIG_fail;
6825 }
6826 }
6827 {
6828 if (!wxPyCheckForApp()) SWIG_fail;
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6831
6832 wxPyEndAllowThreads(__tstate);
6833 if (PyErr_Occurred()) SWIG_fail;
6834 }
6835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6836 {
6837 if (arg2) delete [] arg2;
6838 }
6839 return resultobj;
6840 fail:
6841 {
6842 if (arg2) delete [] arg2;
6843 }
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 wxRegion *arg1 = (wxRegion *) 0 ;
6851 PyObject * obj0 = 0 ;
6852 char *kwnames[] = {
6853 (char *) "self", NULL
6854 };
6855
6856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6858 if (SWIG_arg_fail(1)) SWIG_fail;
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 delete arg1;
6862
6863 wxPyEndAllowThreads(__tstate);
6864 if (PyErr_Occurred()) SWIG_fail;
6865 }
6866 Py_INCREF(Py_None); resultobj = Py_None;
6867 return resultobj;
6868 fail:
6869 return NULL;
6870 }
6871
6872
6873 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6874 PyObject *resultobj;
6875 wxRegion *arg1 = (wxRegion *) 0 ;
6876 PyObject * obj0 = 0 ;
6877 char *kwnames[] = {
6878 (char *) "self", NULL
6879 };
6880
6881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6883 if (SWIG_arg_fail(1)) SWIG_fail;
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 (arg1)->Clear();
6887
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 Py_INCREF(Py_None); resultobj = Py_None;
6892 return resultobj;
6893 fail:
6894 return NULL;
6895 }
6896
6897
6898 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6899 PyObject *resultobj;
6900 wxRegion *arg1 = (wxRegion *) 0 ;
6901 int arg2 ;
6902 int arg3 ;
6903 bool result;
6904 PyObject * obj0 = 0 ;
6905 PyObject * obj1 = 0 ;
6906 PyObject * obj2 = 0 ;
6907 char *kwnames[] = {
6908 (char *) "self",(char *) "x",(char *) "y", NULL
6909 };
6910
6911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6913 if (SWIG_arg_fail(1)) SWIG_fail;
6914 {
6915 arg2 = (int)(SWIG_As_int(obj1));
6916 if (SWIG_arg_fail(2)) SWIG_fail;
6917 }
6918 {
6919 arg3 = (int)(SWIG_As_int(obj2));
6920 if (SWIG_arg_fail(3)) SWIG_fail;
6921 }
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = (bool)(arg1)->Offset(arg2,arg3);
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 {
6930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6931 }
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj;
6940 wxRegion *arg1 = (wxRegion *) 0 ;
6941 int arg2 ;
6942 int arg3 ;
6943 wxRegionContain result;
6944 PyObject * obj0 = 0 ;
6945 PyObject * obj1 = 0 ;
6946 PyObject * obj2 = 0 ;
6947 char *kwnames[] = {
6948 (char *) "self",(char *) "x",(char *) "y", NULL
6949 };
6950
6951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 {
6955 arg2 = (int)(SWIG_As_int(obj1));
6956 if (SWIG_arg_fail(2)) SWIG_fail;
6957 }
6958 {
6959 arg3 = (int)(SWIG_As_int(obj2));
6960 if (SWIG_arg_fail(3)) SWIG_fail;
6961 }
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6965
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_From_int((result));
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj;
6978 wxRegion *arg1 = (wxRegion *) 0 ;
6979 wxPoint *arg2 = 0 ;
6980 wxRegionContain result;
6981 wxPoint temp2 ;
6982 PyObject * obj0 = 0 ;
6983 PyObject * obj1 = 0 ;
6984 char *kwnames[] = {
6985 (char *) "self",(char *) "pt", NULL
6986 };
6987
6988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6990 if (SWIG_arg_fail(1)) SWIG_fail;
6991 {
6992 arg2 = &temp2;
6993 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6994 }
6995 {
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6998
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_From_int((result));
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj;
7011 wxRegion *arg1 = (wxRegion *) 0 ;
7012 wxRect *arg2 = 0 ;
7013 wxRegionContain result;
7014 wxRect temp2 ;
7015 PyObject * obj0 = 0 ;
7016 PyObject * obj1 = 0 ;
7017 char *kwnames[] = {
7018 (char *) "self",(char *) "rect", NULL
7019 };
7020
7021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7023 if (SWIG_arg_fail(1)) SWIG_fail;
7024 {
7025 arg2 = &temp2;
7026 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7027 }
7028 {
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7031
7032 wxPyEndAllowThreads(__tstate);
7033 if (PyErr_Occurred()) SWIG_fail;
7034 }
7035 resultobj = SWIG_From_int((result));
7036 return resultobj;
7037 fail:
7038 return NULL;
7039 }
7040
7041
7042 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7043 PyObject *resultobj;
7044 wxRegion *arg1 = (wxRegion *) 0 ;
7045 int arg2 ;
7046 int arg3 ;
7047 int arg4 ;
7048 int arg5 ;
7049 wxRegionContain result;
7050 PyObject * obj0 = 0 ;
7051 PyObject * obj1 = 0 ;
7052 PyObject * obj2 = 0 ;
7053 PyObject * obj3 = 0 ;
7054 PyObject * obj4 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 arg2 = (int)(SWIG_As_int(obj1));
7064 if (SWIG_arg_fail(2)) SWIG_fail;
7065 }
7066 {
7067 arg3 = (int)(SWIG_As_int(obj2));
7068 if (SWIG_arg_fail(3)) SWIG_fail;
7069 }
7070 {
7071 arg4 = (int)(SWIG_As_int(obj3));
7072 if (SWIG_arg_fail(4)) SWIG_fail;
7073 }
7074 {
7075 arg5 = (int)(SWIG_As_int(obj4));
7076 if (SWIG_arg_fail(5)) SWIG_fail;
7077 }
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7081
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_From_int((result));
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj;
7094 wxRegion *arg1 = (wxRegion *) 0 ;
7095 wxRect result;
7096 PyObject * obj0 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "self", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (arg1)->GetBox();
7107
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 {
7112 wxRect * resultptr;
7113 resultptr = new wxRect((wxRect &)(result));
7114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7115 }
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxRegion *arg1 = (wxRegion *) 0 ;
7125 int arg2 ;
7126 int arg3 ;
7127 int arg4 ;
7128 int arg5 ;
7129 bool result;
7130 PyObject * obj0 = 0 ;
7131 PyObject * obj1 = 0 ;
7132 PyObject * obj2 = 0 ;
7133 PyObject * obj3 = 0 ;
7134 PyObject * obj4 = 0 ;
7135 char *kwnames[] = {
7136 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7137 };
7138
7139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7141 if (SWIG_arg_fail(1)) SWIG_fail;
7142 {
7143 arg2 = (int)(SWIG_As_int(obj1));
7144 if (SWIG_arg_fail(2)) SWIG_fail;
7145 }
7146 {
7147 arg3 = (int)(SWIG_As_int(obj2));
7148 if (SWIG_arg_fail(3)) SWIG_fail;
7149 }
7150 {
7151 arg4 = (int)(SWIG_As_int(obj3));
7152 if (SWIG_arg_fail(4)) SWIG_fail;
7153 }
7154 {
7155 arg5 = (int)(SWIG_As_int(obj4));
7156 if (SWIG_arg_fail(5)) SWIG_fail;
7157 }
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxRegion *arg1 = (wxRegion *) 0 ;
7177 wxRect *arg2 = 0 ;
7178 bool result;
7179 wxRect temp2 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char *kwnames[] = {
7183 (char *) "self",(char *) "rect", NULL
7184 };
7185
7186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 {
7190 arg2 = &temp2;
7191 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7192 }
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7196
7197 wxPyEndAllowThreads(__tstate);
7198 if (PyErr_Occurred()) SWIG_fail;
7199 }
7200 {
7201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7202 }
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj;
7211 wxRegion *arg1 = (wxRegion *) 0 ;
7212 wxRegion *arg2 = 0 ;
7213 bool result;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char *kwnames[] = {
7217 (char *) "self",(char *) "region", NULL
7218 };
7219
7220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 {
7224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7225 if (SWIG_arg_fail(2)) SWIG_fail;
7226 if (arg2 == NULL) {
7227 SWIG_null_ref("wxRegion");
7228 }
7229 if (SWIG_arg_fail(2)) SWIG_fail;
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 {
7239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7240 }
7241 return resultobj;
7242 fail:
7243 return NULL;
7244 }
7245
7246
7247 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7248 PyObject *resultobj;
7249 wxRegion *arg1 = (wxRegion *) 0 ;
7250 bool result;
7251 PyObject * obj0 = 0 ;
7252 char *kwnames[] = {
7253 (char *) "self", NULL
7254 };
7255
7256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7258 if (SWIG_arg_fail(1)) SWIG_fail;
7259 {
7260 PyThreadState* __tstate = wxPyBeginAllowThreads();
7261 result = (bool)(arg1)->IsEmpty();
7262
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 {
7267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7268 }
7269 return resultobj;
7270 fail:
7271 return NULL;
7272 }
7273
7274
7275 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7276 PyObject *resultobj;
7277 wxRegion *arg1 = (wxRegion *) 0 ;
7278 int arg2 ;
7279 int arg3 ;
7280 int arg4 ;
7281 int arg5 ;
7282 bool result;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 PyObject * obj2 = 0 ;
7286 PyObject * obj3 = 0 ;
7287 PyObject * obj4 = 0 ;
7288 char *kwnames[] = {
7289 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7290 };
7291
7292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7294 if (SWIG_arg_fail(1)) SWIG_fail;
7295 {
7296 arg2 = (int)(SWIG_As_int(obj1));
7297 if (SWIG_arg_fail(2)) SWIG_fail;
7298 }
7299 {
7300 arg3 = (int)(SWIG_As_int(obj2));
7301 if (SWIG_arg_fail(3)) SWIG_fail;
7302 }
7303 {
7304 arg4 = (int)(SWIG_As_int(obj3));
7305 if (SWIG_arg_fail(4)) SWIG_fail;
7306 }
7307 {
7308 arg5 = (int)(SWIG_As_int(obj4));
7309 if (SWIG_arg_fail(5)) SWIG_fail;
7310 }
7311 {
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7314
7315 wxPyEndAllowThreads(__tstate);
7316 if (PyErr_Occurred()) SWIG_fail;
7317 }
7318 {
7319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7320 }
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7328 PyObject *resultobj;
7329 wxRegion *arg1 = (wxRegion *) 0 ;
7330 wxRect *arg2 = 0 ;
7331 bool result;
7332 wxRect temp2 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self",(char *) "rect", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 arg2 = &temp2;
7344 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7345 }
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7349
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 {
7354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7355 }
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj;
7364 wxRegion *arg1 = (wxRegion *) 0 ;
7365 wxRegion *arg2 = 0 ;
7366 bool result;
7367 PyObject * obj0 = 0 ;
7368 PyObject * obj1 = 0 ;
7369 char *kwnames[] = {
7370 (char *) "self",(char *) "region", NULL
7371 };
7372
7373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7375 if (SWIG_arg_fail(1)) SWIG_fail;
7376 {
7377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7378 if (SWIG_arg_fail(2)) SWIG_fail;
7379 if (arg2 == NULL) {
7380 SWIG_null_ref("wxRegion");
7381 }
7382 if (SWIG_arg_fail(2)) SWIG_fail;
7383 }
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7387
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 {
7392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj;
7402 wxRegion *arg1 = (wxRegion *) 0 ;
7403 int arg2 ;
7404 int arg3 ;
7405 int arg4 ;
7406 int arg5 ;
7407 bool result;
7408 PyObject * obj0 = 0 ;
7409 PyObject * obj1 = 0 ;
7410 PyObject * obj2 = 0 ;
7411 PyObject * obj3 = 0 ;
7412 PyObject * obj4 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 {
7421 arg2 = (int)(SWIG_As_int(obj1));
7422 if (SWIG_arg_fail(2)) SWIG_fail;
7423 }
7424 {
7425 arg3 = (int)(SWIG_As_int(obj2));
7426 if (SWIG_arg_fail(3)) SWIG_fail;
7427 }
7428 {
7429 arg4 = (int)(SWIG_As_int(obj3));
7430 if (SWIG_arg_fail(4)) SWIG_fail;
7431 }
7432 {
7433 arg5 = (int)(SWIG_As_int(obj4));
7434 if (SWIG_arg_fail(5)) SWIG_fail;
7435 }
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj;
7454 wxRegion *arg1 = (wxRegion *) 0 ;
7455 wxRect *arg2 = 0 ;
7456 bool result;
7457 wxRect temp2 ;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 char *kwnames[] = {
7461 (char *) "self",(char *) "rect", NULL
7462 };
7463
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 {
7468 arg2 = &temp2;
7469 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7470 }
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj;
7489 wxRegion *arg1 = (wxRegion *) 0 ;
7490 wxRegion *arg2 = 0 ;
7491 bool result;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char *kwnames[] = {
7495 (char *) "self",(char *) "region", NULL
7496 };
7497
7498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7500 if (SWIG_arg_fail(1)) SWIG_fail;
7501 {
7502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(2)) SWIG_fail;
7504 if (arg2 == NULL) {
7505 SWIG_null_ref("wxRegion");
7506 }
7507 if (SWIG_arg_fail(2)) SWIG_fail;
7508 }
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7512
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 {
7517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7518 }
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj;
7527 wxRegion *arg1 = (wxRegion *) 0 ;
7528 int arg2 ;
7529 int arg3 ;
7530 int arg4 ;
7531 int arg5 ;
7532 bool result;
7533 PyObject * obj0 = 0 ;
7534 PyObject * obj1 = 0 ;
7535 PyObject * obj2 = 0 ;
7536 PyObject * obj3 = 0 ;
7537 PyObject * obj4 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 {
7546 arg2 = (int)(SWIG_As_int(obj1));
7547 if (SWIG_arg_fail(2)) SWIG_fail;
7548 }
7549 {
7550 arg3 = (int)(SWIG_As_int(obj2));
7551 if (SWIG_arg_fail(3)) SWIG_fail;
7552 }
7553 {
7554 arg4 = (int)(SWIG_As_int(obj3));
7555 if (SWIG_arg_fail(4)) SWIG_fail;
7556 }
7557 {
7558 arg5 = (int)(SWIG_As_int(obj4));
7559 if (SWIG_arg_fail(5)) SWIG_fail;
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 {
7569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7570 }
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxRegion *arg1 = (wxRegion *) 0 ;
7580 wxRect *arg2 = 0 ;
7581 bool result;
7582 wxRect temp2 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char *kwnames[] = {
7586 (char *) "self",(char *) "rect", NULL
7587 };
7588
7589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7591 if (SWIG_arg_fail(1)) SWIG_fail;
7592 {
7593 arg2 = &temp2;
7594 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7595 }
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7599
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 {
7604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7605 }
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj;
7614 wxRegion *arg1 = (wxRegion *) 0 ;
7615 wxRegion *arg2 = 0 ;
7616 bool result;
7617 PyObject * obj0 = 0 ;
7618 PyObject * obj1 = 0 ;
7619 char *kwnames[] = {
7620 (char *) "self",(char *) "region", NULL
7621 };
7622
7623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7625 if (SWIG_arg_fail(1)) SWIG_fail;
7626 {
7627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7628 if (SWIG_arg_fail(2)) SWIG_fail;
7629 if (arg2 == NULL) {
7630 SWIG_null_ref("wxRegion");
7631 }
7632 if (SWIG_arg_fail(2)) SWIG_fail;
7633 }
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxRegion *arg1 = (wxRegion *) 0 ;
7653 SwigValueWrapper<wxBitmap > result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (arg1)->ConvertToBitmap();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 wxBitmap * resultptr;
7671 resultptr = new wxBitmap((wxBitmap &)(result));
7672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7673 }
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxRegion *arg1 = (wxRegion *) 0 ;
7683 wxBitmap *arg2 = 0 ;
7684 bool result;
7685 PyObject * obj0 = 0 ;
7686 PyObject * obj1 = 0 ;
7687 char *kwnames[] = {
7688 (char *) "self",(char *) "bmp", NULL
7689 };
7690
7691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7693 if (SWIG_arg_fail(1)) SWIG_fail;
7694 {
7695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7696 if (SWIG_arg_fail(2)) SWIG_fail;
7697 if (arg2 == NULL) {
7698 SWIG_null_ref("wxBitmap");
7699 }
7700 if (SWIG_arg_fail(2)) SWIG_fail;
7701 }
7702 {
7703 PyThreadState* __tstate = wxPyBeginAllowThreads();
7704 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7705
7706 wxPyEndAllowThreads(__tstate);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxRegion *arg1 = (wxRegion *) 0 ;
7721 wxBitmap *arg2 = 0 ;
7722 wxColour *arg3 = 0 ;
7723 int arg4 = (int) 0 ;
7724 bool result;
7725 wxColour temp3 ;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 PyObject * obj2 = 0 ;
7729 PyObject * obj3 = 0 ;
7730 char *kwnames[] = {
7731 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7732 };
7733
7734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7736 if (SWIG_arg_fail(1)) SWIG_fail;
7737 {
7738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(2)) SWIG_fail;
7740 if (arg2 == NULL) {
7741 SWIG_null_ref("wxBitmap");
7742 }
7743 if (SWIG_arg_fail(2)) SWIG_fail;
7744 }
7745 {
7746 arg3 = &temp3;
7747 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7748 }
7749 if (obj3) {
7750 {
7751 arg4 = (int)(SWIG_As_int(obj3));
7752 if (SWIG_arg_fail(4)) SWIG_fail;
7753 }
7754 }
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7758
7759 wxPyEndAllowThreads(__tstate);
7760 if (PyErr_Occurred()) SWIG_fail;
7761 }
7762 {
7763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7764 }
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7772 PyObject *obj;
7773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7774 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7775 Py_INCREF(obj);
7776 return Py_BuildValue((char *)"");
7777 }
7778 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxRegion *arg1 = 0 ;
7781 wxRegionIterator *result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "region", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7788 {
7789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7790 if (SWIG_arg_fail(1)) SWIG_fail;
7791 if (arg1 == NULL) {
7792 SWIG_null_ref("wxRegion");
7793 }
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 }
7796 {
7797 if (!wxPyCheckForApp()) SWIG_fail;
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7800
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7814 PyObject * obj0 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 delete arg1;
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 Py_INCREF(Py_None); resultobj = Py_None;
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7837 PyObject *resultobj;
7838 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7839 int result;
7840 PyObject * obj0 = 0 ;
7841 char *kwnames[] = {
7842 (char *) "self", NULL
7843 };
7844
7845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7847 if (SWIG_arg_fail(1)) SWIG_fail;
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 result = (int)(arg1)->GetX();
7851
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 {
7856 resultobj = SWIG_From_int((int)(result));
7857 }
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj;
7866 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7867 int result;
7868 PyObject * obj0 = 0 ;
7869 char *kwnames[] = {
7870 (char *) "self", NULL
7871 };
7872
7873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7875 if (SWIG_arg_fail(1)) SWIG_fail;
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 result = (int)(arg1)->GetY();
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 {
7884 resultobj = SWIG_From_int((int)(result));
7885 }
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7895 int result;
7896 PyObject * obj0 = 0 ;
7897 char *kwnames[] = {
7898 (char *) "self", NULL
7899 };
7900
7901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7903 if (SWIG_arg_fail(1)) SWIG_fail;
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (int)(arg1)->GetW();
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = SWIG_From_int((int)(result));
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7923 int result;
7924 PyObject * obj0 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "self", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(1)) SWIG_fail;
7932 {
7933 PyThreadState* __tstate = wxPyBeginAllowThreads();
7934 result = (int)(arg1)->GetWidth();
7935
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 {
7940 resultobj = SWIG_From_int((int)(result));
7941 }
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj;
7950 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7951 int result;
7952 PyObject * obj0 = 0 ;
7953 char *kwnames[] = {
7954 (char *) "self", NULL
7955 };
7956
7957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7959 if (SWIG_arg_fail(1)) SWIG_fail;
7960 {
7961 PyThreadState* __tstate = wxPyBeginAllowThreads();
7962 result = (int)(arg1)->GetH();
7963
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 {
7968 resultobj = SWIG_From_int((int)(result));
7969 }
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7977 PyObject *resultobj;
7978 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7979 int result;
7980 PyObject * obj0 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "self", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7987 if (SWIG_arg_fail(1)) SWIG_fail;
7988 {
7989 PyThreadState* __tstate = wxPyBeginAllowThreads();
7990 result = (int)(arg1)->GetHeight();
7991
7992 wxPyEndAllowThreads(__tstate);
7993 if (PyErr_Occurred()) SWIG_fail;
7994 }
7995 {
7996 resultobj = SWIG_From_int((int)(result));
7997 }
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8005 PyObject *resultobj;
8006 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8007 wxRect result;
8008 PyObject * obj0 = 0 ;
8009 char *kwnames[] = {
8010 (char *) "self", NULL
8011 };
8012
8013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8015 if (SWIG_arg_fail(1)) SWIG_fail;
8016 {
8017 PyThreadState* __tstate = wxPyBeginAllowThreads();
8018 result = (arg1)->GetRect();
8019
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 {
8024 wxRect * resultptr;
8025 resultptr = new wxRect((wxRect &)(result));
8026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8027 }
8028 return resultobj;
8029 fail:
8030 return NULL;
8031 }
8032
8033
8034 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8035 PyObject *resultobj;
8036 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8037 bool result;
8038 PyObject * obj0 = 0 ;
8039 char *kwnames[] = {
8040 (char *) "self", NULL
8041 };
8042
8043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8045 if (SWIG_arg_fail(1)) SWIG_fail;
8046 {
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 result = (bool)(arg1)->HaveRects();
8049
8050 wxPyEndAllowThreads(__tstate);
8051 if (PyErr_Occurred()) SWIG_fail;
8052 }
8053 {
8054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8055 }
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8063 PyObject *resultobj;
8064 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8065 PyObject * obj0 = 0 ;
8066 char *kwnames[] = {
8067 (char *) "self", NULL
8068 };
8069
8070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8072 if (SWIG_arg_fail(1)) SWIG_fail;
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 (arg1)->Reset();
8076
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 Py_INCREF(Py_None); resultobj = Py_None;
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8088 PyObject *resultobj;
8089 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8090 PyObject * obj0 = 0 ;
8091 char *kwnames[] = {
8092 (char *) "self", NULL
8093 };
8094
8095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8097 if (SWIG_arg_fail(1)) SWIG_fail;
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 wxRegionIterator_Next(arg1);
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 Py_INCREF(Py_None); resultobj = Py_None;
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8115 bool result;
8116 PyObject * obj0 = 0 ;
8117 char *kwnames[] = {
8118 (char *) "self", NULL
8119 };
8120
8121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8123 if (SWIG_arg_fail(1)) SWIG_fail;
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 result = (bool)wxRegionIterator___nonzero__(arg1);
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 {
8132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8133 }
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8141 PyObject *obj;
8142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8143 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8144 Py_INCREF(obj);
8145 return Py_BuildValue((char *)"");
8146 }
8147 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxNativeFontInfo *result;
8150 char *kwnames[] = {
8151 NULL
8152 };
8153
8154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8158
8159 wxPyEndAllowThreads(__tstate);
8160 if (PyErr_Occurred()) SWIG_fail;
8161 }
8162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj;
8171 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8172 PyObject * obj0 = 0 ;
8173 char *kwnames[] = {
8174 (char *) "self", NULL
8175 };
8176
8177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8179 if (SWIG_arg_fail(1)) SWIG_fail;
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 delete arg1;
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 Py_INCREF(Py_None); resultobj = Py_None;
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj;
8196 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8197 PyObject * obj0 = 0 ;
8198 char *kwnames[] = {
8199 (char *) "self", NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8204 if (SWIG_arg_fail(1)) SWIG_fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 (arg1)->Init();
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 Py_INCREF(Py_None); resultobj = Py_None;
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8222 wxFont *arg2 = 0 ;
8223 PyObject * obj0 = 0 ;
8224 PyObject * obj1 = 0 ;
8225 char *kwnames[] = {
8226 (char *) "self",(char *) "font", NULL
8227 };
8228
8229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8231 if (SWIG_arg_fail(1)) SWIG_fail;
8232 {
8233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(2)) SWIG_fail;
8235 if (arg2 == NULL) {
8236 SWIG_null_ref("wxFont");
8237 }
8238 if (SWIG_arg_fail(2)) SWIG_fail;
8239 }
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 (arg1)->InitFromFont((wxFont const &)*arg2);
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 Py_INCREF(Py_None); resultobj = Py_None;
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj;
8256 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8257 int result;
8258 PyObject * obj0 = 0 ;
8259 char *kwnames[] = {
8260 (char *) "self", NULL
8261 };
8262
8263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8265 if (SWIG_arg_fail(1)) SWIG_fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 {
8274 resultobj = SWIG_From_int((int)(result));
8275 }
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8283 PyObject *resultobj;
8284 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8285 wxSize result;
8286 PyObject * obj0 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8297
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 wxSize * resultptr;
8303 resultptr = new wxSize((wxSize &)(result));
8304 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8305 }
8306 return resultobj;
8307 fail:
8308 return NULL;
8309 }
8310
8311
8312 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8313 PyObject *resultobj;
8314 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8315 wxFontStyle result;
8316 PyObject * obj0 = 0 ;
8317 char *kwnames[] = {
8318 (char *) "self", NULL
8319 };
8320
8321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8323 if (SWIG_arg_fail(1)) SWIG_fail;
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8327
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_From_int((result));
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj;
8340 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8341 wxFontWeight result;
8342 PyObject * obj0 = 0 ;
8343 char *kwnames[] = {
8344 (char *) "self", NULL
8345 };
8346
8347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8349 if (SWIG_arg_fail(1)) SWIG_fail;
8350 {
8351 PyThreadState* __tstate = wxPyBeginAllowThreads();
8352 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8353
8354 wxPyEndAllowThreads(__tstate);
8355 if (PyErr_Occurred()) SWIG_fail;
8356 }
8357 resultobj = SWIG_From_int((result));
8358 return resultobj;
8359 fail:
8360 return NULL;
8361 }
8362
8363
8364 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8365 PyObject *resultobj;
8366 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8367 bool result;
8368 PyObject * obj0 = 0 ;
8369 char *kwnames[] = {
8370 (char *) "self", NULL
8371 };
8372
8373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8375 if (SWIG_arg_fail(1)) SWIG_fail;
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8379
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 {
8384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8385 }
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj;
8394 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8395 wxString result;
8396 PyObject * obj0 = 0 ;
8397 char *kwnames[] = {
8398 (char *) "self", NULL
8399 };
8400
8401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(1)) SWIG_fail;
8404 {
8405 PyThreadState* __tstate = wxPyBeginAllowThreads();
8406 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8407
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 {
8412 #if wxUSE_UNICODE
8413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8414 #else
8415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8416 #endif
8417 }
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8425 PyObject *resultobj;
8426 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8427 wxFontFamily result;
8428 PyObject * obj0 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8439
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_From_int((result));
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj;
8452 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8453 wxFontEncoding result;
8454 PyObject * obj0 = 0 ;
8455 char *kwnames[] = {
8456 (char *) "self", NULL
8457 };
8458
8459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8461 if (SWIG_arg_fail(1)) SWIG_fail;
8462 {
8463 PyThreadState* __tstate = wxPyBeginAllowThreads();
8464 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8465
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 resultobj = SWIG_From_int((result));
8470 return resultobj;
8471 fail:
8472 return NULL;
8473 }
8474
8475
8476 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8477 PyObject *resultobj;
8478 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8479 int arg2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char *kwnames[] = {
8483 (char *) "self",(char *) "pointsize", NULL
8484 };
8485
8486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8488 if (SWIG_arg_fail(1)) SWIG_fail;
8489 {
8490 arg2 = (int)(SWIG_As_int(obj1));
8491 if (SWIG_arg_fail(2)) SWIG_fail;
8492 }
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 (arg1)->SetPointSize(arg2);
8496
8497 wxPyEndAllowThreads(__tstate);
8498 if (PyErr_Occurred()) SWIG_fail;
8499 }
8500 Py_INCREF(Py_None); resultobj = Py_None;
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8510 wxSize *arg2 = 0 ;
8511 wxSize temp2 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char *kwnames[] = {
8515 (char *) "self",(char *) "pixelSize", NULL
8516 };
8517
8518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8520 if (SWIG_arg_fail(1)) SWIG_fail;
8521 {
8522 arg2 = &temp2;
8523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8524 }
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 (arg1)->SetPixelSize((wxSize const &)*arg2);
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 Py_INCREF(Py_None); resultobj = Py_None;
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj;
8541 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8542 wxFontStyle arg2 ;
8543 PyObject * obj0 = 0 ;
8544 PyObject * obj1 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "self",(char *) "style", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 {
8553 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8554 if (SWIG_arg_fail(2)) SWIG_fail;
8555 }
8556 {
8557 PyThreadState* __tstate = wxPyBeginAllowThreads();
8558 (arg1)->SetStyle((wxFontStyle )arg2);
8559
8560 wxPyEndAllowThreads(__tstate);
8561 if (PyErr_Occurred()) SWIG_fail;
8562 }
8563 Py_INCREF(Py_None); resultobj = Py_None;
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8571 PyObject *resultobj;
8572 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8573 wxFontWeight arg2 ;
8574 PyObject * obj0 = 0 ;
8575 PyObject * obj1 = 0 ;
8576 char *kwnames[] = {
8577 (char *) "self",(char *) "weight", NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 {
8584 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8585 if (SWIG_arg_fail(2)) SWIG_fail;
8586 }
8587 {
8588 PyThreadState* __tstate = wxPyBeginAllowThreads();
8589 (arg1)->SetWeight((wxFontWeight )arg2);
8590
8591 wxPyEndAllowThreads(__tstate);
8592 if (PyErr_Occurred()) SWIG_fail;
8593 }
8594 Py_INCREF(Py_None); resultobj = Py_None;
8595 return resultobj;
8596 fail:
8597 return NULL;
8598 }
8599
8600
8601 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8602 PyObject *resultobj;
8603 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8604 bool arg2 ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 char *kwnames[] = {
8608 (char *) "self",(char *) "underlined", NULL
8609 };
8610
8611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8613 if (SWIG_arg_fail(1)) SWIG_fail;
8614 {
8615 arg2 = (bool)(SWIG_As_bool(obj1));
8616 if (SWIG_arg_fail(2)) SWIG_fail;
8617 }
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 (arg1)->SetUnderlined(arg2);
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 Py_INCREF(Py_None); resultobj = Py_None;
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj;
8634 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8635 wxString arg2 ;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 char *kwnames[] = {
8639 (char *) "self",(char *) "facename", NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8644 if (SWIG_arg_fail(1)) SWIG_fail;
8645 {
8646 wxString* sptr = wxString_in_helper(obj1);
8647 if (sptr == NULL) SWIG_fail;
8648 arg2 = *sptr;
8649 delete sptr;
8650 }
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 (arg1)->SetFaceName(arg2);
8654
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 Py_INCREF(Py_None); resultobj = Py_None;
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8666 PyObject *resultobj;
8667 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8668 wxFontFamily arg2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char *kwnames[] = {
8672 (char *) "self",(char *) "family", NULL
8673 };
8674
8675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8677 if (SWIG_arg_fail(1)) SWIG_fail;
8678 {
8679 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8680 if (SWIG_arg_fail(2)) SWIG_fail;
8681 }
8682 {
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 (arg1)->SetFamily((wxFontFamily )arg2);
8685
8686 wxPyEndAllowThreads(__tstate);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 Py_INCREF(Py_None); resultobj = Py_None;
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8697 PyObject *resultobj;
8698 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8699 wxFontEncoding arg2 ;
8700 PyObject * obj0 = 0 ;
8701 PyObject * obj1 = 0 ;
8702 char *kwnames[] = {
8703 (char *) "self",(char *) "encoding", NULL
8704 };
8705
8706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8708 if (SWIG_arg_fail(1)) SWIG_fail;
8709 {
8710 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8711 if (SWIG_arg_fail(2)) SWIG_fail;
8712 }
8713 {
8714 PyThreadState* __tstate = wxPyBeginAllowThreads();
8715 (arg1)->SetEncoding((wxFontEncoding )arg2);
8716
8717 wxPyEndAllowThreads(__tstate);
8718 if (PyErr_Occurred()) SWIG_fail;
8719 }
8720 Py_INCREF(Py_None); resultobj = Py_None;
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8728 PyObject *resultobj;
8729 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8730 wxString *arg2 = 0 ;
8731 bool result;
8732 bool temp2 = false ;
8733 PyObject * obj0 = 0 ;
8734 PyObject * obj1 = 0 ;
8735 char *kwnames[] = {
8736 (char *) "self",(char *) "s", NULL
8737 };
8738
8739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8741 if (SWIG_arg_fail(1)) SWIG_fail;
8742 {
8743 arg2 = wxString_in_helper(obj1);
8744 if (arg2 == NULL) SWIG_fail;
8745 temp2 = true;
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 {
8755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8756 }
8757 {
8758 if (temp2)
8759 delete arg2;
8760 }
8761 return resultobj;
8762 fail:
8763 {
8764 if (temp2)
8765 delete arg2;
8766 }
8767 return NULL;
8768 }
8769
8770
8771 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj;
8773 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8774 wxString result;
8775 PyObject * obj0 = 0 ;
8776 char *kwnames[] = {
8777 (char *) "self", NULL
8778 };
8779
8780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8782 if (SWIG_arg_fail(1)) SWIG_fail;
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 result = ((wxNativeFontInfo const *)arg1)->ToString();
8786
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 {
8791 #if wxUSE_UNICODE
8792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8793 #else
8794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8795 #endif
8796 }
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj;
8805 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8806 wxString result;
8807 PyObject * obj0 = 0 ;
8808 char *kwnames[] = {
8809 (char *) "self", NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8814 if (SWIG_arg_fail(1)) SWIG_fail;
8815 {
8816 PyThreadState* __tstate = wxPyBeginAllowThreads();
8817 result = wxNativeFontInfo___str__(arg1);
8818
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 {
8823 #if wxUSE_UNICODE
8824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8825 #else
8826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8827 #endif
8828 }
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8838 wxString *arg2 = 0 ;
8839 bool result;
8840 bool temp2 = false ;
8841 PyObject * obj0 = 0 ;
8842 PyObject * obj1 = 0 ;
8843 char *kwnames[] = {
8844 (char *) "self",(char *) "s", NULL
8845 };
8846
8847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8849 if (SWIG_arg_fail(1)) SWIG_fail;
8850 {
8851 arg2 = wxString_in_helper(obj1);
8852 if (arg2 == NULL) SWIG_fail;
8853 temp2 = true;
8854 }
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8858
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 {
8863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8864 }
8865 {
8866 if (temp2)
8867 delete arg2;
8868 }
8869 return resultobj;
8870 fail:
8871 {
8872 if (temp2)
8873 delete arg2;
8874 }
8875 return NULL;
8876 }
8877
8878
8879 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj;
8881 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8882 wxString result;
8883 PyObject * obj0 = 0 ;
8884 char *kwnames[] = {
8885 (char *) "self", NULL
8886 };
8887
8888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 #if wxUSE_UNICODE
8900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8901 #else
8902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8903 #endif
8904 }
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8912 PyObject *obj;
8913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8914 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8915 Py_INCREF(obj);
8916 return Py_BuildValue((char *)"");
8917 }
8918 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj;
8920 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8921 wxString *arg2 = (wxString *) 0 ;
8922 bool temp2 = false ;
8923 PyObject * obj0 = 0 ;
8924 PyObject * obj1 = 0 ;
8925 char *kwnames[] = {
8926 (char *) "self",(char *) "facename", NULL
8927 };
8928
8929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8931 if (SWIG_arg_fail(1)) SWIG_fail;
8932 {
8933 arg2 = wxString_in_helper(obj1);
8934 if (arg2 == NULL) SWIG_fail;
8935 temp2 = true;
8936 }
8937 if (arg1) (arg1)->facename = *arg2;
8938
8939 Py_INCREF(Py_None); resultobj = Py_None;
8940 {
8941 if (temp2)
8942 delete arg2;
8943 }
8944 return resultobj;
8945 fail:
8946 {
8947 if (temp2)
8948 delete arg2;
8949 }
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8957 wxString *result;
8958 PyObject * obj0 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "self", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 result = (wxString *)& ((arg1)->facename);
8967
8968 {
8969 #if wxUSE_UNICODE
8970 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8971 #else
8972 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8973 #endif
8974 }
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8984 wxFontEncoding arg2 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "self",(char *) "encoding", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8993 if (SWIG_arg_fail(1)) SWIG_fail;
8994 {
8995 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 }
8998 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8999
9000 Py_INCREF(Py_None); resultobj = Py_None;
9001 return resultobj;
9002 fail:
9003 return NULL;
9004 }
9005
9006
9007 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9008 PyObject *resultobj;
9009 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9010 wxFontEncoding result;
9011 PyObject * obj0 = 0 ;
9012 char *kwnames[] = {
9013 (char *) "self", NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9018 if (SWIG_arg_fail(1)) SWIG_fail;
9019 result = (wxFontEncoding) ((arg1)->encoding);
9020
9021 resultobj = SWIG_From_int((result));
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj;
9030 wxNativeEncodingInfo *result;
9031 char *kwnames[] = {
9032 NULL
9033 };
9034
9035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9039
9040 wxPyEndAllowThreads(__tstate);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9044 return resultobj;
9045 fail:
9046 return NULL;
9047 }
9048
9049
9050 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj;
9052 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9053 PyObject * obj0 = 0 ;
9054 char *kwnames[] = {
9055 (char *) "self", NULL
9056 };
9057
9058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9060 if (SWIG_arg_fail(1)) SWIG_fail;
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 delete arg1;
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 Py_INCREF(Py_None); resultobj = Py_None;
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj;
9077 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9078 wxString *arg2 = 0 ;
9079 bool result;
9080 bool temp2 = false ;
9081 PyObject * obj0 = 0 ;
9082 PyObject * obj1 = 0 ;
9083 char *kwnames[] = {
9084 (char *) "self",(char *) "s", NULL
9085 };
9086
9087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9089 if (SWIG_arg_fail(1)) SWIG_fail;
9090 {
9091 arg2 = wxString_in_helper(obj1);
9092 if (arg2 == NULL) SWIG_fail;
9093 temp2 = true;
9094 }
9095 {
9096 PyThreadState* __tstate = wxPyBeginAllowThreads();
9097 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9098
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 {
9103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9104 }
9105 {
9106 if (temp2)
9107 delete arg2;
9108 }
9109 return resultobj;
9110 fail:
9111 {
9112 if (temp2)
9113 delete arg2;
9114 }
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9122 wxString result;
9123 PyObject * obj0 = 0 ;
9124 char *kwnames[] = {
9125 (char *) "self", NULL
9126 };
9127
9128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9134
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 {
9139 #if wxUSE_UNICODE
9140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9141 #else
9142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9143 #endif
9144 }
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9152 PyObject *obj;
9153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9154 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9155 Py_INCREF(obj);
9156 return Py_BuildValue((char *)"");
9157 }
9158 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj;
9160 wxFontEncoding arg1 ;
9161 wxNativeEncodingInfo *result;
9162 PyObject * obj0 = 0 ;
9163 char *kwnames[] = {
9164 (char *) "encoding", NULL
9165 };
9166
9167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9168 {
9169 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9170 if (SWIG_arg_fail(1)) SWIG_fail;
9171 }
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj;
9188 wxNativeEncodingInfo *arg1 = 0 ;
9189 bool result;
9190 PyObject * obj0 = 0 ;
9191 char *kwnames[] = {
9192 (char *) "info", NULL
9193 };
9194
9195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9196 {
9197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9198 if (SWIG_arg_fail(1)) SWIG_fail;
9199 if (arg1 == NULL) {
9200 SWIG_null_ref("wxNativeEncodingInfo");
9201 }
9202 if (SWIG_arg_fail(1)) SWIG_fail;
9203 }
9204 {
9205 PyThreadState* __tstate = wxPyBeginAllowThreads();
9206 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9207
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 {
9212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9213 }
9214 return resultobj;
9215 fail:
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj;
9222 wxFontMapper *result;
9223 char *kwnames[] = {
9224 NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 result = (wxFontMapper *)new wxFontMapper();
9231
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj;
9244 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9245 PyObject * obj0 = 0 ;
9246 char *kwnames[] = {
9247 (char *) "self", NULL
9248 };
9249
9250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9252 if (SWIG_arg_fail(1)) SWIG_fail;
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 delete arg1;
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 Py_INCREF(Py_None); resultobj = Py_None;
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 wxFontMapper *result;
9270 char *kwnames[] = {
9271 NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (wxFontMapper *)wxFontMapper::Get();
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9292 wxFontMapper *result;
9293 PyObject * obj0 = 0 ;
9294 char *kwnames[] = {
9295 (char *) "mapper", NULL
9296 };
9297
9298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9300 if (SWIG_arg_fail(1)) SWIG_fail;
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9304
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj;
9317 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9318 wxString *arg2 = 0 ;
9319 bool arg3 = (bool) true ;
9320 wxFontEncoding result;
9321 bool temp2 = false ;
9322 PyObject * obj0 = 0 ;
9323 PyObject * obj1 = 0 ;
9324 PyObject * obj2 = 0 ;
9325 char *kwnames[] = {
9326 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9327 };
9328
9329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9331 if (SWIG_arg_fail(1)) SWIG_fail;
9332 {
9333 arg2 = wxString_in_helper(obj1);
9334 if (arg2 == NULL) SWIG_fail;
9335 temp2 = true;
9336 }
9337 if (obj2) {
9338 {
9339 arg3 = (bool)(SWIG_As_bool(obj2));
9340 if (SWIG_arg_fail(3)) SWIG_fail;
9341 }
9342 }
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9346
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_int((result));
9351 {
9352 if (temp2)
9353 delete arg2;
9354 }
9355 return resultobj;
9356 fail:
9357 {
9358 if (temp2)
9359 delete arg2;
9360 }
9361 return NULL;
9362 }
9363
9364
9365 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9366 PyObject *resultobj;
9367 size_t result;
9368 char *kwnames[] = {
9369 NULL
9370 };
9371
9372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9376
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 {
9381 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9382 }
9383 return resultobj;
9384 fail:
9385 return NULL;
9386 }
9387
9388
9389 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 size_t arg1 ;
9392 wxFontEncoding result;
9393 PyObject * obj0 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "n", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9399 {
9400 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9401 if (SWIG_arg_fail(1)) SWIG_fail;
9402 }
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_From_int((result));
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9418 PyObject *resultobj;
9419 wxFontEncoding arg1 ;
9420 wxString result;
9421 PyObject * obj0 = 0 ;
9422 char *kwnames[] = {
9423 (char *) "encoding", NULL
9424 };
9425
9426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9427 {
9428 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9429 if (SWIG_arg_fail(1)) SWIG_fail;
9430 }
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9434
9435 wxPyEndAllowThreads(__tstate);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 {
9439 #if wxUSE_UNICODE
9440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9441 #else
9442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9443 #endif
9444 }
9445 return resultobj;
9446 fail:
9447 return NULL;
9448 }
9449
9450
9451 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9452 PyObject *resultobj;
9453 wxFontEncoding arg1 ;
9454 wxString result;
9455 PyObject * obj0 = 0 ;
9456 char *kwnames[] = {
9457 (char *) "encoding", NULL
9458 };
9459
9460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9461 {
9462 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9463 if (SWIG_arg_fail(1)) SWIG_fail;
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9468
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 {
9473 #if wxUSE_UNICODE
9474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9475 #else
9476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9477 #endif
9478 }
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9486 PyObject *resultobj;
9487 wxString *arg1 = 0 ;
9488 wxFontEncoding result;
9489 bool temp1 = false ;
9490 PyObject * obj0 = 0 ;
9491 char *kwnames[] = {
9492 (char *) "name", NULL
9493 };
9494
9495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9496 {
9497 arg1 = wxString_in_helper(obj0);
9498 if (arg1 == NULL) SWIG_fail;
9499 temp1 = true;
9500 }
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9504
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_From_int((result));
9509 {
9510 if (temp1)
9511 delete arg1;
9512 }
9513 return resultobj;
9514 fail:
9515 {
9516 if (temp1)
9517 delete arg1;
9518 }
9519 return NULL;
9520 }
9521
9522
9523 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj;
9525 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9526 wxString *arg2 = 0 ;
9527 bool temp2 = false ;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 char *kwnames[] = {
9531 (char *) "self",(char *) "prefix", NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(1)) SWIG_fail;
9537 {
9538 arg2 = wxString_in_helper(obj1);
9539 if (arg2 == NULL) SWIG_fail;
9540 temp2 = true;
9541 }
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 (arg1)->SetConfigPath((wxString const &)*arg2);
9545
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 Py_INCREF(Py_None); resultobj = Py_None;
9550 {
9551 if (temp2)
9552 delete arg2;
9553 }
9554 return resultobj;
9555 fail:
9556 {
9557 if (temp2)
9558 delete arg2;
9559 }
9560 return NULL;
9561 }
9562
9563
9564 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9565 PyObject *resultobj;
9566 wxString result;
9567 char *kwnames[] = {
9568 NULL
9569 };
9570
9571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9572 {
9573 PyThreadState* __tstate = wxPyBeginAllowThreads();
9574 result = wxFontMapper::GetDefaultConfigPath();
9575
9576 wxPyEndAllowThreads(__tstate);
9577 if (PyErr_Occurred()) SWIG_fail;
9578 }
9579 {
9580 #if wxUSE_UNICODE
9581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9582 #else
9583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9584 #endif
9585 }
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9593 PyObject *resultobj;
9594 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9595 wxFontEncoding arg2 ;
9596 wxString const &arg3_defvalue = wxPyEmptyString ;
9597 wxString *arg3 = (wxString *) &arg3_defvalue ;
9598 bool arg4 = (bool) true ;
9599 PyObject *result;
9600 bool temp3 = false ;
9601 PyObject * obj0 = 0 ;
9602 PyObject * obj1 = 0 ;
9603 PyObject * obj2 = 0 ;
9604 PyObject * obj3 = 0 ;
9605 char *kwnames[] = {
9606 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9607 };
9608
9609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9611 if (SWIG_arg_fail(1)) SWIG_fail;
9612 {
9613 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9614 if (SWIG_arg_fail(2)) SWIG_fail;
9615 }
9616 if (obj2) {
9617 {
9618 arg3 = wxString_in_helper(obj2);
9619 if (arg3 == NULL) SWIG_fail;
9620 temp3 = true;
9621 }
9622 }
9623 if (obj3) {
9624 {
9625 arg4 = (bool)(SWIG_As_bool(obj3));
9626 if (SWIG_arg_fail(4)) SWIG_fail;
9627 }
9628 }
9629 {
9630 PyThreadState* __tstate = wxPyBeginAllowThreads();
9631 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9632
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 resultobj = result;
9637 {
9638 if (temp3)
9639 delete arg3;
9640 }
9641 return resultobj;
9642 fail:
9643 {
9644 if (temp3)
9645 delete arg3;
9646 }
9647 return NULL;
9648 }
9649
9650
9651 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9652 PyObject *resultobj;
9653 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9654 wxFontEncoding arg2 ;
9655 wxString const &arg3_defvalue = wxPyEmptyString ;
9656 wxString *arg3 = (wxString *) &arg3_defvalue ;
9657 bool result;
9658 bool temp3 = false ;
9659 PyObject * obj0 = 0 ;
9660 PyObject * obj1 = 0 ;
9661 PyObject * obj2 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9668 if (SWIG_arg_fail(1)) SWIG_fail;
9669 {
9670 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9671 if (SWIG_arg_fail(2)) SWIG_fail;
9672 }
9673 if (obj2) {
9674 {
9675 arg3 = wxString_in_helper(obj2);
9676 if (arg3 == NULL) SWIG_fail;
9677 temp3 = true;
9678 }
9679 }
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9683
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 {
9688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9689 }
9690 {
9691 if (temp3)
9692 delete arg3;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp3)
9698 delete arg3;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9707 wxWindow *arg2 = (wxWindow *) 0 ;
9708 PyObject * obj0 = 0 ;
9709 PyObject * obj1 = 0 ;
9710 char *kwnames[] = {
9711 (char *) "self",(char *) "parent", NULL
9712 };
9713
9714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9716 if (SWIG_arg_fail(1)) SWIG_fail;
9717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(2)) SWIG_fail;
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 (arg1)->SetDialogParent(arg2);
9722
9723 wxPyEndAllowThreads(__tstate);
9724 if (PyErr_Occurred()) SWIG_fail;
9725 }
9726 Py_INCREF(Py_None); resultobj = Py_None;
9727 return resultobj;
9728 fail:
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj;
9735 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9736 wxString *arg2 = 0 ;
9737 bool temp2 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self",(char *) "title", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 {
9748 arg2 = wxString_in_helper(obj1);
9749 if (arg2 == NULL) SWIG_fail;
9750 temp2 = true;
9751 }
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 (arg1)->SetDialogTitle((wxString const &)*arg2);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 Py_INCREF(Py_None); resultobj = Py_None;
9760 {
9761 if (temp2)
9762 delete arg2;
9763 }
9764 return resultobj;
9765 fail:
9766 {
9767 if (temp2)
9768 delete arg2;
9769 }
9770 return NULL;
9771 }
9772
9773
9774 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9775 PyObject *obj;
9776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9777 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9778 Py_INCREF(obj);
9779 return Py_BuildValue((char *)"");
9780 }
9781 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj;
9783 int arg1 ;
9784 int arg2 ;
9785 int arg3 ;
9786 int arg4 ;
9787 bool arg5 = (bool) false ;
9788 wxString const &arg6_defvalue = wxPyEmptyString ;
9789 wxString *arg6 = (wxString *) &arg6_defvalue ;
9790 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9791 wxFont *result;
9792 bool temp6 = false ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 PyObject * obj2 = 0 ;
9796 PyObject * obj3 = 0 ;
9797 PyObject * obj4 = 0 ;
9798 PyObject * obj5 = 0 ;
9799 PyObject * obj6 = 0 ;
9800 char *kwnames[] = {
9801 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9802 };
9803
9804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9805 {
9806 arg1 = (int)(SWIG_As_int(obj0));
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 }
9809 {
9810 arg2 = (int)(SWIG_As_int(obj1));
9811 if (SWIG_arg_fail(2)) SWIG_fail;
9812 }
9813 {
9814 arg3 = (int)(SWIG_As_int(obj2));
9815 if (SWIG_arg_fail(3)) SWIG_fail;
9816 }
9817 {
9818 arg4 = (int)(SWIG_As_int(obj3));
9819 if (SWIG_arg_fail(4)) SWIG_fail;
9820 }
9821 if (obj4) {
9822 {
9823 arg5 = (bool)(SWIG_As_bool(obj4));
9824 if (SWIG_arg_fail(5)) SWIG_fail;
9825 }
9826 }
9827 if (obj5) {
9828 {
9829 arg6 = wxString_in_helper(obj5);
9830 if (arg6 == NULL) SWIG_fail;
9831 temp6 = true;
9832 }
9833 }
9834 if (obj6) {
9835 {
9836 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9837 if (SWIG_arg_fail(7)) SWIG_fail;
9838 }
9839 }
9840 {
9841 if (!wxPyCheckForApp()) SWIG_fail;
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9849 {
9850 if (temp6)
9851 delete arg6;
9852 }
9853 return resultobj;
9854 fail:
9855 {
9856 if (temp6)
9857 delete arg6;
9858 }
9859 return NULL;
9860 }
9861
9862
9863 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9864 PyObject *resultobj;
9865 wxFont *arg1 = (wxFont *) 0 ;
9866 PyObject * obj0 = 0 ;
9867 char *kwnames[] = {
9868 (char *) "self", NULL
9869 };
9870
9871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9873 if (SWIG_arg_fail(1)) SWIG_fail;
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 delete arg1;
9877
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 Py_INCREF(Py_None); resultobj = Py_None;
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9889 PyObject *resultobj;
9890 wxNativeFontInfo *arg1 = 0 ;
9891 wxFont *result;
9892 PyObject * obj0 = 0 ;
9893 char *kwnames[] = {
9894 (char *) "info", NULL
9895 };
9896
9897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9898 {
9899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(1)) SWIG_fail;
9901 if (arg1 == NULL) {
9902 SWIG_null_ref("wxNativeFontInfo");
9903 }
9904 if (SWIG_arg_fail(1)) SWIG_fail;
9905 }
9906 {
9907 if (!wxPyCheckForApp()) SWIG_fail;
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9922 PyObject *resultobj;
9923 wxString *arg1 = 0 ;
9924 wxFont *result;
9925 bool temp1 = false ;
9926 PyObject * obj0 = 0 ;
9927 char *kwnames[] = {
9928 (char *) "info", NULL
9929 };
9930
9931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9932 {
9933 arg1 = wxString_in_helper(obj0);
9934 if (arg1 == NULL) SWIG_fail;
9935 temp1 = true;
9936 }
9937 {
9938 if (!wxPyCheckForApp()) SWIG_fail;
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9946 {
9947 if (temp1)
9948 delete arg1;
9949 }
9950 return resultobj;
9951 fail:
9952 {
9953 if (temp1)
9954 delete arg1;
9955 }
9956 return NULL;
9957 }
9958
9959
9960 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9961 PyObject *resultobj;
9962 int arg1 ;
9963 wxFontFamily arg2 ;
9964 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9965 wxString const &arg4_defvalue = wxPyEmptyString ;
9966 wxString *arg4 = (wxString *) &arg4_defvalue ;
9967 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9968 wxFont *result;
9969 bool temp4 = false ;
9970 PyObject * obj0 = 0 ;
9971 PyObject * obj1 = 0 ;
9972 PyObject * obj2 = 0 ;
9973 PyObject * obj3 = 0 ;
9974 PyObject * obj4 = 0 ;
9975 char *kwnames[] = {
9976 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9977 };
9978
9979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9980 {
9981 arg1 = (int)(SWIG_As_int(obj0));
9982 if (SWIG_arg_fail(1)) SWIG_fail;
9983 }
9984 {
9985 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9986 if (SWIG_arg_fail(2)) SWIG_fail;
9987 }
9988 if (obj2) {
9989 {
9990 arg3 = (int)(SWIG_As_int(obj2));
9991 if (SWIG_arg_fail(3)) SWIG_fail;
9992 }
9993 }
9994 if (obj3) {
9995 {
9996 arg4 = wxString_in_helper(obj3);
9997 if (arg4 == NULL) SWIG_fail;
9998 temp4 = true;
9999 }
10000 }
10001 if (obj4) {
10002 {
10003 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10004 if (SWIG_arg_fail(5)) SWIG_fail;
10005 }
10006 }
10007 {
10008 if (!wxPyCheckForApp()) SWIG_fail;
10009 PyThreadState* __tstate = wxPyBeginAllowThreads();
10010 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10011
10012 wxPyEndAllowThreads(__tstate);
10013 if (PyErr_Occurred()) SWIG_fail;
10014 }
10015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10016 {
10017 if (temp4)
10018 delete arg4;
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 if (temp4)
10024 delete arg4;
10025 }
10026 return NULL;
10027 }
10028
10029
10030 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj;
10032 wxSize *arg1 = 0 ;
10033 int arg2 ;
10034 int arg3 ;
10035 int arg4 ;
10036 bool arg5 = (bool) false ;
10037 wxString const &arg6_defvalue = wxEmptyString ;
10038 wxString *arg6 = (wxString *) &arg6_defvalue ;
10039 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10040 wxFont *result;
10041 wxSize temp1 ;
10042 bool temp6 = false ;
10043 PyObject * obj0 = 0 ;
10044 PyObject * obj1 = 0 ;
10045 PyObject * obj2 = 0 ;
10046 PyObject * obj3 = 0 ;
10047 PyObject * obj4 = 0 ;
10048 PyObject * obj5 = 0 ;
10049 PyObject * obj6 = 0 ;
10050 char *kwnames[] = {
10051 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10052 };
10053
10054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10055 {
10056 arg1 = &temp1;
10057 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10058 }
10059 {
10060 arg2 = (int)(SWIG_As_int(obj1));
10061 if (SWIG_arg_fail(2)) SWIG_fail;
10062 }
10063 {
10064 arg3 = (int)(SWIG_As_int(obj2));
10065 if (SWIG_arg_fail(3)) SWIG_fail;
10066 }
10067 {
10068 arg4 = (int)(SWIG_As_int(obj3));
10069 if (SWIG_arg_fail(4)) SWIG_fail;
10070 }
10071 if (obj4) {
10072 {
10073 arg5 = (bool)(SWIG_As_bool(obj4));
10074 if (SWIG_arg_fail(5)) SWIG_fail;
10075 }
10076 }
10077 if (obj5) {
10078 {
10079 arg6 = wxString_in_helper(obj5);
10080 if (arg6 == NULL) SWIG_fail;
10081 temp6 = true;
10082 }
10083 }
10084 if (obj6) {
10085 {
10086 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10087 if (SWIG_arg_fail(7)) SWIG_fail;
10088 }
10089 }
10090 {
10091 if (!wxPyCheckForApp()) SWIG_fail;
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10099 {
10100 if (temp6)
10101 delete arg6;
10102 }
10103 return resultobj;
10104 fail:
10105 {
10106 if (temp6)
10107 delete arg6;
10108 }
10109 return NULL;
10110 }
10111
10112
10113 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10114 PyObject *resultobj;
10115 wxSize *arg1 = 0 ;
10116 wxFontFamily arg2 ;
10117 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10118 wxString const &arg4_defvalue = wxEmptyString ;
10119 wxString *arg4 = (wxString *) &arg4_defvalue ;
10120 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10121 wxFont *result;
10122 wxSize temp1 ;
10123 bool temp4 = false ;
10124 PyObject * obj0 = 0 ;
10125 PyObject * obj1 = 0 ;
10126 PyObject * obj2 = 0 ;
10127 PyObject * obj3 = 0 ;
10128 PyObject * obj4 = 0 ;
10129 char *kwnames[] = {
10130 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10131 };
10132
10133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10134 {
10135 arg1 = &temp1;
10136 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10137 }
10138 {
10139 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10140 if (SWIG_arg_fail(2)) SWIG_fail;
10141 }
10142 if (obj2) {
10143 {
10144 arg3 = (int)(SWIG_As_int(obj2));
10145 if (SWIG_arg_fail(3)) SWIG_fail;
10146 }
10147 }
10148 if (obj3) {
10149 {
10150 arg4 = wxString_in_helper(obj3);
10151 if (arg4 == NULL) SWIG_fail;
10152 temp4 = true;
10153 }
10154 }
10155 if (obj4) {
10156 {
10157 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10158 if (SWIG_arg_fail(5)) SWIG_fail;
10159 }
10160 }
10161 {
10162 if (!wxPyCheckForApp()) SWIG_fail;
10163 PyThreadState* __tstate = wxPyBeginAllowThreads();
10164 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10165
10166 wxPyEndAllowThreads(__tstate);
10167 if (PyErr_Occurred()) SWIG_fail;
10168 }
10169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10170 {
10171 if (temp4)
10172 delete arg4;
10173 }
10174 return resultobj;
10175 fail:
10176 {
10177 if (temp4)
10178 delete arg4;
10179 }
10180 return NULL;
10181 }
10182
10183
10184 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10185 PyObject *resultobj;
10186 wxFont *arg1 = (wxFont *) 0 ;
10187 bool result;
10188 PyObject * obj0 = 0 ;
10189 char *kwnames[] = {
10190 (char *) "self", NULL
10191 };
10192
10193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10195 if (SWIG_arg_fail(1)) SWIG_fail;
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 result = (bool)((wxFont const *)arg1)->Ok();
10199
10200 wxPyEndAllowThreads(__tstate);
10201 if (PyErr_Occurred()) SWIG_fail;
10202 }
10203 {
10204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10205 }
10206 return resultobj;
10207 fail:
10208 return NULL;
10209 }
10210
10211
10212 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10213 PyObject *resultobj;
10214 wxFont *arg1 = (wxFont *) 0 ;
10215 wxFont *arg2 = (wxFont *) 0 ;
10216 bool result;
10217 PyObject * obj0 = 0 ;
10218 PyObject * obj1 = 0 ;
10219 char *kwnames[] = {
10220 (char *) "self",(char *) "other", NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10225 if (SWIG_arg_fail(1)) SWIG_fail;
10226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10227 if (SWIG_arg_fail(2)) SWIG_fail;
10228 {
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10231
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 {
10236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10237 }
10238 return resultobj;
10239 fail:
10240 return NULL;
10241 }
10242
10243
10244 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj;
10246 wxFont *arg1 = (wxFont *) 0 ;
10247 wxFont *arg2 = (wxFont *) 0 ;
10248 bool result;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 char *kwnames[] = {
10252 (char *) "self",(char *) "other", NULL
10253 };
10254
10255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10257 if (SWIG_arg_fail(1)) SWIG_fail;
10258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10259 if (SWIG_arg_fail(2)) SWIG_fail;
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 {
10268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10269 }
10270 return resultobj;
10271 fail:
10272 return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10277 PyObject *resultobj;
10278 wxFont *arg1 = (wxFont *) 0 ;
10279 int result;
10280 PyObject * obj0 = 0 ;
10281 char *kwnames[] = {
10282 (char *) "self", NULL
10283 };
10284
10285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10287 if (SWIG_arg_fail(1)) SWIG_fail;
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 result = (int)((wxFont const *)arg1)->GetPointSize();
10291
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 {
10296 resultobj = SWIG_From_int((int)(result));
10297 }
10298 return resultobj;
10299 fail:
10300 return NULL;
10301 }
10302
10303
10304 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj;
10306 wxFont *arg1 = (wxFont *) 0 ;
10307 wxSize result;
10308 PyObject * obj0 = 0 ;
10309 char *kwnames[] = {
10310 (char *) "self", NULL
10311 };
10312
10313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10315 if (SWIG_arg_fail(1)) SWIG_fail;
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 result = ((wxFont const *)arg1)->GetPixelSize();
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 {
10324 wxSize * resultptr;
10325 resultptr = new wxSize((wxSize &)(result));
10326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10327 }
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxFont *arg1 = (wxFont *) 0 ;
10337 bool result;
10338 PyObject * obj0 = 0 ;
10339 char *kwnames[] = {
10340 (char *) "self", NULL
10341 };
10342
10343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10345 if (SWIG_arg_fail(1)) SWIG_fail;
10346 {
10347 PyThreadState* __tstate = wxPyBeginAllowThreads();
10348 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10349
10350 wxPyEndAllowThreads(__tstate);
10351 if (PyErr_Occurred()) SWIG_fail;
10352 }
10353 {
10354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10355 }
10356 return resultobj;
10357 fail:
10358 return NULL;
10359 }
10360
10361
10362 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10363 PyObject *resultobj;
10364 wxFont *arg1 = (wxFont *) 0 ;
10365 int result;
10366 PyObject * obj0 = 0 ;
10367 char *kwnames[] = {
10368 (char *) "self", NULL
10369 };
10370
10371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10373 if (SWIG_arg_fail(1)) SWIG_fail;
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (int)((wxFont const *)arg1)->GetFamily();
10377
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 {
10382 resultobj = SWIG_From_int((int)(result));
10383 }
10384 return resultobj;
10385 fail:
10386 return NULL;
10387 }
10388
10389
10390 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj;
10392 wxFont *arg1 = (wxFont *) 0 ;
10393 int result;
10394 PyObject * obj0 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 PyThreadState* __tstate = wxPyBeginAllowThreads();
10404 result = (int)((wxFont const *)arg1)->GetStyle();
10405
10406 wxPyEndAllowThreads(__tstate);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 {
10410 resultobj = SWIG_From_int((int)(result));
10411 }
10412 return resultobj;
10413 fail:
10414 return NULL;
10415 }
10416
10417
10418 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj;
10420 wxFont *arg1 = (wxFont *) 0 ;
10421 int result;
10422 PyObject * obj0 = 0 ;
10423 char *kwnames[] = {
10424 (char *) "self", NULL
10425 };
10426
10427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10429 if (SWIG_arg_fail(1)) SWIG_fail;
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (int)((wxFont const *)arg1)->GetWeight();
10433
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 resultobj = SWIG_From_int((int)(result));
10439 }
10440 return resultobj;
10441 fail:
10442 return NULL;
10443 }
10444
10445
10446 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj;
10448 wxFont *arg1 = (wxFont *) 0 ;
10449 bool result;
10450 PyObject * obj0 = 0 ;
10451 char *kwnames[] = {
10452 (char *) "self", NULL
10453 };
10454
10455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10457 if (SWIG_arg_fail(1)) SWIG_fail;
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10461
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 {
10466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10467 }
10468 return resultobj;
10469 fail:
10470 return NULL;
10471 }
10472
10473
10474 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj;
10476 wxFont *arg1 = (wxFont *) 0 ;
10477 wxString result;
10478 PyObject * obj0 = 0 ;
10479 char *kwnames[] = {
10480 (char *) "self", NULL
10481 };
10482
10483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10485 if (SWIG_arg_fail(1)) SWIG_fail;
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 result = ((wxFont const *)arg1)->GetFaceName();
10489
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 {
10494 #if wxUSE_UNICODE
10495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10496 #else
10497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10498 #endif
10499 }
10500 return resultobj;
10501 fail:
10502 return NULL;
10503 }
10504
10505
10506 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10507 PyObject *resultobj;
10508 wxFont *arg1 = (wxFont *) 0 ;
10509 wxFontEncoding result;
10510 PyObject * obj0 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "self", NULL
10513 };
10514
10515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10517 if (SWIG_arg_fail(1)) SWIG_fail;
10518 {
10519 PyThreadState* __tstate = wxPyBeginAllowThreads();
10520 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10521
10522 wxPyEndAllowThreads(__tstate);
10523 if (PyErr_Occurred()) SWIG_fail;
10524 }
10525 resultobj = SWIG_From_int((result));
10526 return resultobj;
10527 fail:
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxFont *arg1 = (wxFont *) 0 ;
10535 wxNativeFontInfo *result;
10536 PyObject * obj0 = 0 ;
10537 char *kwnames[] = {
10538 (char *) "self", NULL
10539 };
10540
10541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10543 if (SWIG_arg_fail(1)) SWIG_fail;
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10547
10548 wxPyEndAllowThreads(__tstate);
10549 if (PyErr_Occurred()) SWIG_fail;
10550 }
10551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10552 return resultobj;
10553 fail:
10554 return NULL;
10555 }
10556
10557
10558 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10559 PyObject *resultobj;
10560 wxFont *arg1 = (wxFont *) 0 ;
10561 bool result;
10562 PyObject * obj0 = 0 ;
10563 char *kwnames[] = {
10564 (char *) "self", NULL
10565 };
10566
10567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10569 if (SWIG_arg_fail(1)) SWIG_fail;
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 {
10578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj;
10588 wxFont *arg1 = (wxFont *) 0 ;
10589 wxString result;
10590 PyObject * obj0 = 0 ;
10591 char *kwnames[] = {
10592 (char *) "self", NULL
10593 };
10594
10595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10597 if (SWIG_arg_fail(1)) SWIG_fail;
10598 {
10599 PyThreadState* __tstate = wxPyBeginAllowThreads();
10600 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10601
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 {
10606 #if wxUSE_UNICODE
10607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10608 #else
10609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10610 #endif
10611 }
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj;
10620 wxFont *arg1 = (wxFont *) 0 ;
10621 wxString result;
10622 PyObject * obj0 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "self", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10629 if (SWIG_arg_fail(1)) SWIG_fail;
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10633
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 #if wxUSE_UNICODE
10639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10640 #else
10641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10642 #endif
10643 }
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj;
10652 wxFont *arg1 = (wxFont *) 0 ;
10653 int arg2 ;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 char *kwnames[] = {
10657 (char *) "self",(char *) "pointSize", NULL
10658 };
10659
10660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 {
10664 arg2 = (int)(SWIG_As_int(obj1));
10665 if (SWIG_arg_fail(2)) SWIG_fail;
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 (arg1)->SetPointSize(arg2);
10670
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 Py_INCREF(Py_None); resultobj = Py_None;
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxFont *arg1 = (wxFont *) 0 ;
10684 wxSize *arg2 = 0 ;
10685 wxSize temp2 ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "self",(char *) "pixelSize", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10694 if (SWIG_arg_fail(1)) SWIG_fail;
10695 {
10696 arg2 = &temp2;
10697 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10698 }
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 (arg1)->SetPixelSize((wxSize const &)*arg2);
10702
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 Py_INCREF(Py_None); resultobj = Py_None;
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj;
10715 wxFont *arg1 = (wxFont *) 0 ;
10716 int arg2 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 char *kwnames[] = {
10720 (char *) "self",(char *) "family", NULL
10721 };
10722
10723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(1)) SWIG_fail;
10726 {
10727 arg2 = (int)(SWIG_As_int(obj1));
10728 if (SWIG_arg_fail(2)) SWIG_fail;
10729 }
10730 {
10731 PyThreadState* __tstate = wxPyBeginAllowThreads();
10732 (arg1)->SetFamily(arg2);
10733
10734 wxPyEndAllowThreads(__tstate);
10735 if (PyErr_Occurred()) SWIG_fail;
10736 }
10737 Py_INCREF(Py_None); resultobj = Py_None;
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj;
10746 wxFont *arg1 = (wxFont *) 0 ;
10747 int arg2 ;
10748 PyObject * obj0 = 0 ;
10749 PyObject * obj1 = 0 ;
10750 char *kwnames[] = {
10751 (char *) "self",(char *) "style", NULL
10752 };
10753
10754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(1)) SWIG_fail;
10757 {
10758 arg2 = (int)(SWIG_As_int(obj1));
10759 if (SWIG_arg_fail(2)) SWIG_fail;
10760 }
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 (arg1)->SetStyle(arg2);
10764
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 Py_INCREF(Py_None); resultobj = Py_None;
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj;
10777 wxFont *arg1 = (wxFont *) 0 ;
10778 int arg2 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "self",(char *) "weight", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 {
10789 arg2 = (int)(SWIG_As_int(obj1));
10790 if (SWIG_arg_fail(2)) SWIG_fail;
10791 }
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 (arg1)->SetWeight(arg2);
10795
10796 wxPyEndAllowThreads(__tstate);
10797 if (PyErr_Occurred()) SWIG_fail;
10798 }
10799 Py_INCREF(Py_None); resultobj = Py_None;
10800 return resultobj;
10801 fail:
10802 return NULL;
10803 }
10804
10805
10806 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10807 PyObject *resultobj;
10808 wxFont *arg1 = (wxFont *) 0 ;
10809 wxString *arg2 = 0 ;
10810 bool temp2 = false ;
10811 PyObject * obj0 = 0 ;
10812 PyObject * obj1 = 0 ;
10813 char *kwnames[] = {
10814 (char *) "self",(char *) "faceName", NULL
10815 };
10816
10817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 {
10821 arg2 = wxString_in_helper(obj1);
10822 if (arg2 == NULL) SWIG_fail;
10823 temp2 = true;
10824 }
10825 {
10826 PyThreadState* __tstate = wxPyBeginAllowThreads();
10827 (arg1)->SetFaceName((wxString const &)*arg2);
10828
10829 wxPyEndAllowThreads(__tstate);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 Py_INCREF(Py_None); resultobj = Py_None;
10833 {
10834 if (temp2)
10835 delete arg2;
10836 }
10837 return resultobj;
10838 fail:
10839 {
10840 if (temp2)
10841 delete arg2;
10842 }
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxFont *arg1 = (wxFont *) 0 ;
10850 bool arg2 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 char *kwnames[] = {
10854 (char *) "self",(char *) "underlined", NULL
10855 };
10856
10857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10859 if (SWIG_arg_fail(1)) SWIG_fail;
10860 {
10861 arg2 = (bool)(SWIG_As_bool(obj1));
10862 if (SWIG_arg_fail(2)) SWIG_fail;
10863 }
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 (arg1)->SetUnderlined(arg2);
10867
10868 wxPyEndAllowThreads(__tstate);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 Py_INCREF(Py_None); resultobj = Py_None;
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxFont *arg1 = (wxFont *) 0 ;
10881 wxFontEncoding arg2 ;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 char *kwnames[] = {
10885 (char *) "self",(char *) "encoding", NULL
10886 };
10887
10888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10890 if (SWIG_arg_fail(1)) SWIG_fail;
10891 {
10892 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10893 if (SWIG_arg_fail(2)) SWIG_fail;
10894 }
10895 {
10896 PyThreadState* __tstate = wxPyBeginAllowThreads();
10897 (arg1)->SetEncoding((wxFontEncoding )arg2);
10898
10899 wxPyEndAllowThreads(__tstate);
10900 if (PyErr_Occurred()) SWIG_fail;
10901 }
10902 Py_INCREF(Py_None); resultobj = Py_None;
10903 return resultobj;
10904 fail:
10905 return NULL;
10906 }
10907
10908
10909 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10910 PyObject *resultobj;
10911 wxFont *arg1 = (wxFont *) 0 ;
10912 wxNativeFontInfo *arg2 = 0 ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 char *kwnames[] = {
10916 (char *) "self",(char *) "info", NULL
10917 };
10918
10919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10921 if (SWIG_arg_fail(1)) SWIG_fail;
10922 {
10923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(2)) SWIG_fail;
10925 if (arg2 == NULL) {
10926 SWIG_null_ref("wxNativeFontInfo");
10927 }
10928 if (SWIG_arg_fail(2)) SWIG_fail;
10929 }
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10933
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 Py_INCREF(Py_None); resultobj = Py_None;
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj;
10946 wxFont *arg1 = (wxFont *) 0 ;
10947 wxString *arg2 = 0 ;
10948 bool temp2 = false ;
10949 PyObject * obj0 = 0 ;
10950 PyObject * obj1 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self",(char *) "info", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 arg2 = wxString_in_helper(obj1);
10960 if (arg2 == NULL) SWIG_fail;
10961 temp2 = true;
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 Py_INCREF(Py_None); resultobj = Py_None;
10971 {
10972 if (temp2)
10973 delete arg2;
10974 }
10975 return resultobj;
10976 fail:
10977 {
10978 if (temp2)
10979 delete arg2;
10980 }
10981 return NULL;
10982 }
10983
10984
10985 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj;
10987 wxFont *arg1 = (wxFont *) 0 ;
10988 wxString *arg2 = 0 ;
10989 bool temp2 = false ;
10990 PyObject * obj0 = 0 ;
10991 PyObject * obj1 = 0 ;
10992 char *kwnames[] = {
10993 (char *) "self",(char *) "info", NULL
10994 };
10995
10996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(1)) SWIG_fail;
10999 {
11000 arg2 = wxString_in_helper(obj1);
11001 if (arg2 == NULL) SWIG_fail;
11002 temp2 = true;
11003 }
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 Py_INCREF(Py_None); resultobj = Py_None;
11012 {
11013 if (temp2)
11014 delete arg2;
11015 }
11016 return resultobj;
11017 fail:
11018 {
11019 if (temp2)
11020 delete arg2;
11021 }
11022 return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj;
11028 wxFont *arg1 = (wxFont *) 0 ;
11029 wxString result;
11030 PyObject * obj0 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = ((wxFont const *)arg1)->GetFamilyString();
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 #if wxUSE_UNICODE
11047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11048 #else
11049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11050 #endif
11051 }
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxFont *arg1 = (wxFont *) 0 ;
11061 wxString result;
11062 PyObject * obj0 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 result = ((wxFont const *)arg1)->GetStyleString();
11073
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 {
11078 #if wxUSE_UNICODE
11079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11080 #else
11081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11082 #endif
11083 }
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj;
11092 wxFont *arg1 = (wxFont *) 0 ;
11093 wxString result;
11094 PyObject * obj0 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "self", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11101 if (SWIG_arg_fail(1)) SWIG_fail;
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 result = ((wxFont const *)arg1)->GetWeightString();
11105
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 #if wxUSE_UNICODE
11111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11112 #else
11113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11114 #endif
11115 }
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj;
11124 wxFont *arg1 = (wxFont *) 0 ;
11125 bool arg2 = (bool) true ;
11126 PyObject * obj0 = 0 ;
11127 PyObject * obj1 = 0 ;
11128 char *kwnames[] = {
11129 (char *) "self",(char *) "no", NULL
11130 };
11131
11132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11134 if (SWIG_arg_fail(1)) SWIG_fail;
11135 if (obj1) {
11136 {
11137 arg2 = (bool)(SWIG_As_bool(obj1));
11138 if (SWIG_arg_fail(2)) SWIG_fail;
11139 }
11140 }
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 (arg1)->SetNoAntiAliasing(arg2);
11144
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 Py_INCREF(Py_None); resultobj = Py_None;
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxFont *arg1 = (wxFont *) 0 ;
11158 bool result;
11159 PyObject * obj0 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11176 }
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11184 PyObject *resultobj;
11185 wxFontEncoding result;
11186 char *kwnames[] = {
11187 NULL
11188 };
11189
11190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11191 {
11192 if (!wxPyCheckForApp()) SWIG_fail;
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 resultobj = SWIG_From_int((result));
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj;
11208 wxFontEncoding arg1 ;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "encoding", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11215 {
11216 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11217 if (SWIG_arg_fail(1)) SWIG_fail;
11218 }
11219 {
11220 if (!wxPyCheckForApp()) SWIG_fail;
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11223
11224 wxPyEndAllowThreads(__tstate);
11225 if (PyErr_Occurred()) SWIG_fail;
11226 }
11227 Py_INCREF(Py_None); resultobj = Py_None;
11228 return resultobj;
11229 fail:
11230 return NULL;
11231 }
11232
11233
11234 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11235 PyObject *obj;
11236 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11237 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11238 Py_INCREF(obj);
11239 return Py_BuildValue((char *)"");
11240 }
11241 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj;
11243 wxPyFontEnumerator *result;
11244 char *kwnames[] = {
11245 NULL
11246 };
11247
11248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11249 {
11250 if (!wxPyCheckForApp()) SWIG_fail;
11251 PyThreadState* __tstate = wxPyBeginAllowThreads();
11252 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11253
11254 wxPyEndAllowThreads(__tstate);
11255 if (PyErr_Occurred()) SWIG_fail;
11256 }
11257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj;
11266 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11267 PyObject * obj0 = 0 ;
11268 char *kwnames[] = {
11269 (char *) "self", NULL
11270 };
11271
11272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11274 if (SWIG_arg_fail(1)) SWIG_fail;
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 delete arg1;
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 Py_INCREF(Py_None); resultobj = Py_None;
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj;
11291 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11292 PyObject *arg2 = (PyObject *) 0 ;
11293 PyObject *arg3 = (PyObject *) 0 ;
11294 bool arg4 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 PyObject * obj3 = 0 ;
11299 char *kwnames[] = {
11300 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11301 };
11302
11303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11305 if (SWIG_arg_fail(1)) SWIG_fail;
11306 arg2 = obj1;
11307 arg3 = obj2;
11308 {
11309 arg4 = (bool)(SWIG_As_bool(obj3));
11310 if (SWIG_arg_fail(4)) SWIG_fail;
11311 }
11312 {
11313 PyThreadState* __tstate = wxPyBeginAllowThreads();
11314 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11315
11316 wxPyEndAllowThreads(__tstate);
11317 if (PyErr_Occurred()) SWIG_fail;
11318 }
11319 Py_INCREF(Py_None); resultobj = Py_None;
11320 return resultobj;
11321 fail:
11322 return NULL;
11323 }
11324
11325
11326 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11327 PyObject *resultobj;
11328 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11329 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11330 bool arg3 = (bool) false ;
11331 bool result;
11332 PyObject * obj0 = 0 ;
11333 PyObject * obj1 = 0 ;
11334 PyObject * obj2 = 0 ;
11335 char *kwnames[] = {
11336 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11337 };
11338
11339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11341 if (SWIG_arg_fail(1)) SWIG_fail;
11342 if (obj1) {
11343 {
11344 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 }
11348 if (obj2) {
11349 {
11350 arg3 = (bool)(SWIG_As_bool(obj2));
11351 if (SWIG_arg_fail(3)) SWIG_fail;
11352 }
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11363 }
11364 return resultobj;
11365 fail:
11366 return NULL;
11367 }
11368
11369
11370 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj;
11372 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11373 wxString const &arg2_defvalue = wxPyEmptyString ;
11374 wxString *arg2 = (wxString *) &arg2_defvalue ;
11375 bool result;
11376 bool temp2 = false ;
11377 PyObject * obj0 = 0 ;
11378 PyObject * obj1 = 0 ;
11379 char *kwnames[] = {
11380 (char *) "self",(char *) "facename", NULL
11381 };
11382
11383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11385 if (SWIG_arg_fail(1)) SWIG_fail;
11386 if (obj1) {
11387 {
11388 arg2 = wxString_in_helper(obj1);
11389 if (arg2 == NULL) SWIG_fail;
11390 temp2 = true;
11391 }
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 {
11404 if (temp2)
11405 delete arg2;
11406 }
11407 return resultobj;
11408 fail:
11409 {
11410 if (temp2)
11411 delete arg2;
11412 }
11413 return NULL;
11414 }
11415
11416
11417 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11418 PyObject *resultobj;
11419 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11420 PyObject *result;
11421 PyObject * obj0 = 0 ;
11422 char *kwnames[] = {
11423 (char *) "self", NULL
11424 };
11425
11426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11428 if (SWIG_arg_fail(1)) SWIG_fail;
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11432
11433 wxPyEndAllowThreads(__tstate);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 resultobj = result;
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11444 PyObject *resultobj;
11445 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11446 PyObject *result;
11447 PyObject * obj0 = 0 ;
11448 char *kwnames[] = {
11449 (char *) "self", NULL
11450 };
11451
11452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11454 if (SWIG_arg_fail(1)) SWIG_fail;
11455 {
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11458
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 resultobj = result;
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11470 PyObject *obj;
11471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11472 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11473 Py_INCREF(obj);
11474 return Py_BuildValue((char *)"");
11475 }
11476 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11477 PyObject *resultobj;
11478 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11479 int arg2 ;
11480 PyObject * obj0 = 0 ;
11481 PyObject * obj1 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "self",(char *) "Language", NULL
11484 };
11485
11486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11488 if (SWIG_arg_fail(1)) SWIG_fail;
11489 {
11490 arg2 = (int)(SWIG_As_int(obj1));
11491 if (SWIG_arg_fail(2)) SWIG_fail;
11492 }
11493 if (arg1) (arg1)->Language = arg2;
11494
11495 Py_INCREF(Py_None); resultobj = Py_None;
11496 return resultobj;
11497 fail:
11498 return NULL;
11499 }
11500
11501
11502 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11503 PyObject *resultobj;
11504 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11505 int result;
11506 PyObject * obj0 = 0 ;
11507 char *kwnames[] = {
11508 (char *) "self", NULL
11509 };
11510
11511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11513 if (SWIG_arg_fail(1)) SWIG_fail;
11514 result = (int) ((arg1)->Language);
11515
11516 {
11517 resultobj = SWIG_From_int((int)(result));
11518 }
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11528 wxString *arg2 = (wxString *) 0 ;
11529 bool temp2 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "self",(char *) "CanonicalName", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 {
11540 arg2 = wxString_in_helper(obj1);
11541 if (arg2 == NULL) SWIG_fail;
11542 temp2 = true;
11543 }
11544 if (arg1) (arg1)->CanonicalName = *arg2;
11545
11546 Py_INCREF(Py_None); resultobj = Py_None;
11547 {
11548 if (temp2)
11549 delete arg2;
11550 }
11551 return resultobj;
11552 fail:
11553 {
11554 if (temp2)
11555 delete arg2;
11556 }
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11564 wxString *result;
11565 PyObject * obj0 = 0 ;
11566 char *kwnames[] = {
11567 (char *) "self", NULL
11568 };
11569
11570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11572 if (SWIG_arg_fail(1)) SWIG_fail;
11573 result = (wxString *)& ((arg1)->CanonicalName);
11574
11575 {
11576 #if wxUSE_UNICODE
11577 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11578 #else
11579 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11580 #endif
11581 }
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11589 PyObject *resultobj;
11590 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11591 wxString *arg2 = (wxString *) 0 ;
11592 bool temp2 = false ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 char *kwnames[] = {
11596 (char *) "self",(char *) "Description", NULL
11597 };
11598
11599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11601 if (SWIG_arg_fail(1)) SWIG_fail;
11602 {
11603 arg2 = wxString_in_helper(obj1);
11604 if (arg2 == NULL) SWIG_fail;
11605 temp2 = true;
11606 }
11607 if (arg1) (arg1)->Description = *arg2;
11608
11609 Py_INCREF(Py_None); resultobj = Py_None;
11610 {
11611 if (temp2)
11612 delete arg2;
11613 }
11614 return resultobj;
11615 fail:
11616 {
11617 if (temp2)
11618 delete arg2;
11619 }
11620 return NULL;
11621 }
11622
11623
11624 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj;
11626 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11627 wxString *result;
11628 PyObject * obj0 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "self", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11635 if (SWIG_arg_fail(1)) SWIG_fail;
11636 result = (wxString *)& ((arg1)->Description);
11637
11638 {
11639 #if wxUSE_UNICODE
11640 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11641 #else
11642 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11643 #endif
11644 }
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11652 PyObject *obj;
11653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11654 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11655 Py_INCREF(obj);
11656 return Py_BuildValue((char *)"");
11657 }
11658 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11659 PyObject *resultobj;
11660 int arg1 = (int) -1 ;
11661 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11662 wxLocale *result;
11663 PyObject * obj0 = 0 ;
11664 PyObject * obj1 = 0 ;
11665 char *kwnames[] = {
11666 (char *) "language",(char *) "flags", NULL
11667 };
11668
11669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11670 if (obj0) {
11671 {
11672 arg1 = (int)(SWIG_As_int(obj0));
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 }
11675 }
11676 if (obj1) {
11677 {
11678 arg2 = (int)(SWIG_As_int(obj1));
11679 if (SWIG_arg_fail(2)) SWIG_fail;
11680 }
11681 }
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (wxLocale *)new_wxLocale(arg1,arg2);
11685
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11690 return resultobj;
11691 fail:
11692 return NULL;
11693 }
11694
11695
11696 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11697 PyObject *resultobj;
11698 wxLocale *arg1 = (wxLocale *) 0 ;
11699 PyObject * obj0 = 0 ;
11700 char *kwnames[] = {
11701 (char *) "self", NULL
11702 };
11703
11704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11706 if (SWIG_arg_fail(1)) SWIG_fail;
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 delete arg1;
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 Py_INCREF(Py_None); resultobj = Py_None;
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11722 PyObject *resultobj;
11723 wxLocale *arg1 = (wxLocale *) 0 ;
11724 wxString *arg2 = 0 ;
11725 wxString const &arg3_defvalue = wxPyEmptyString ;
11726 wxString *arg3 = (wxString *) &arg3_defvalue ;
11727 wxString const &arg4_defvalue = wxPyEmptyString ;
11728 wxString *arg4 = (wxString *) &arg4_defvalue ;
11729 bool arg5 = (bool) true ;
11730 bool arg6 = (bool) false ;
11731 bool result;
11732 bool temp2 = false ;
11733 bool temp3 = false ;
11734 bool temp4 = false ;
11735 PyObject * obj0 = 0 ;
11736 PyObject * obj1 = 0 ;
11737 PyObject * obj2 = 0 ;
11738 PyObject * obj3 = 0 ;
11739 PyObject * obj4 = 0 ;
11740 PyObject * obj5 = 0 ;
11741 char *kwnames[] = {
11742 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11743 };
11744
11745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 {
11749 arg2 = wxString_in_helper(obj1);
11750 if (arg2 == NULL) SWIG_fail;
11751 temp2 = true;
11752 }
11753 if (obj2) {
11754 {
11755 arg3 = wxString_in_helper(obj2);
11756 if (arg3 == NULL) SWIG_fail;
11757 temp3 = true;
11758 }
11759 }
11760 if (obj3) {
11761 {
11762 arg4 = wxString_in_helper(obj3);
11763 if (arg4 == NULL) SWIG_fail;
11764 temp4 = true;
11765 }
11766 }
11767 if (obj4) {
11768 {
11769 arg5 = (bool)(SWIG_As_bool(obj4));
11770 if (SWIG_arg_fail(5)) SWIG_fail;
11771 }
11772 }
11773 if (obj5) {
11774 {
11775 arg6 = (bool)(SWIG_As_bool(obj5));
11776 if (SWIG_arg_fail(6)) SWIG_fail;
11777 }
11778 }
11779 {
11780 PyThreadState* __tstate = wxPyBeginAllowThreads();
11781 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11782
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 {
11787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11788 }
11789 {
11790 if (temp2)
11791 delete arg2;
11792 }
11793 {
11794 if (temp3)
11795 delete arg3;
11796 }
11797 {
11798 if (temp4)
11799 delete arg4;
11800 }
11801 return resultobj;
11802 fail:
11803 {
11804 if (temp2)
11805 delete arg2;
11806 }
11807 {
11808 if (temp3)
11809 delete arg3;
11810 }
11811 {
11812 if (temp4)
11813 delete arg4;
11814 }
11815 return NULL;
11816 }
11817
11818
11819 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11820 PyObject *resultobj;
11821 wxLocale *arg1 = (wxLocale *) 0 ;
11822 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11823 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11824 bool result;
11825 PyObject * obj0 = 0 ;
11826 PyObject * obj1 = 0 ;
11827 PyObject * obj2 = 0 ;
11828 char *kwnames[] = {
11829 (char *) "self",(char *) "language",(char *) "flags", NULL
11830 };
11831
11832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11834 if (SWIG_arg_fail(1)) SWIG_fail;
11835 if (obj1) {
11836 {
11837 arg2 = (int)(SWIG_As_int(obj1));
11838 if (SWIG_arg_fail(2)) SWIG_fail;
11839 }
11840 }
11841 if (obj2) {
11842 {
11843 arg3 = (int)(SWIG_As_int(obj2));
11844 if (SWIG_arg_fail(3)) SWIG_fail;
11845 }
11846 }
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11850
11851 wxPyEndAllowThreads(__tstate);
11852 if (PyErr_Occurred()) SWIG_fail;
11853 }
11854 {
11855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11856 }
11857 return resultobj;
11858 fail:
11859 return NULL;
11860 }
11861
11862
11863 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11864 PyObject *resultobj;
11865 int result;
11866 char *kwnames[] = {
11867 NULL
11868 };
11869
11870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (int)wxLocale::GetSystemLanguage();
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = SWIG_From_int((int)(result));
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxFontEncoding result;
11890 char *kwnames[] = {
11891 NULL
11892 };
11893
11894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11898
11899 wxPyEndAllowThreads(__tstate);
11900 if (PyErr_Occurred()) SWIG_fail;
11901 }
11902 resultobj = SWIG_From_int((result));
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj;
11911 wxString result;
11912 char *kwnames[] = {
11913 NULL
11914 };
11915
11916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = wxLocale::GetSystemEncodingName();
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 #if wxUSE_UNICODE
11926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11927 #else
11928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11929 #endif
11930 }
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxLocale *arg1 = (wxLocale *) 0 ;
11940 bool result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (bool)((wxLocale const *)arg1)->IsOk();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxLocale *arg1 = (wxLocale *) 0 ;
11968 wxString result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = ((wxLocale const *)arg1)->GetLocale();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 #if wxUSE_UNICODE
11986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11987 #else
11988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11989 #endif
11990 }
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj;
11999 wxLocale *arg1 = (wxLocale *) 0 ;
12000 int result;
12001 PyObject * obj0 = 0 ;
12002 char *kwnames[] = {
12003 (char *) "self", NULL
12004 };
12005
12006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
12007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12008 if (SWIG_arg_fail(1)) SWIG_fail;
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (int)((wxLocale const *)arg1)->GetLanguage();
12012
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = SWIG_From_int((int)(result));
12018 }
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj;
12027 wxLocale *arg1 = (wxLocale *) 0 ;
12028 wxString result;
12029 PyObject * obj0 = 0 ;
12030 char *kwnames[] = {
12031 (char *) "self", NULL
12032 };
12033
12034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12036 if (SWIG_arg_fail(1)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = ((wxLocale const *)arg1)->GetSysName();
12040
12041 wxPyEndAllowThreads(__tstate);
12042 if (PyErr_Occurred()) SWIG_fail;
12043 }
12044 {
12045 #if wxUSE_UNICODE
12046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12047 #else
12048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12049 #endif
12050 }
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj;
12059 wxLocale *arg1 = (wxLocale *) 0 ;
12060 wxString result;
12061 PyObject * obj0 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = ((wxLocale const *)arg1)->GetCanonicalName();
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 {
12077 #if wxUSE_UNICODE
12078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12079 #else
12080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12081 #endif
12082 }
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12090 PyObject *resultobj;
12091 wxString *arg1 = 0 ;
12092 bool temp1 = false ;
12093 PyObject * obj0 = 0 ;
12094 char *kwnames[] = {
12095 (char *) "prefix", NULL
12096 };
12097
12098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12099 {
12100 arg1 = wxString_in_helper(obj0);
12101 if (arg1 == NULL) SWIG_fail;
12102 temp1 = true;
12103 }
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 Py_INCREF(Py_None); resultobj = Py_None;
12112 {
12113 if (temp1)
12114 delete arg1;
12115 }
12116 return resultobj;
12117 fail:
12118 {
12119 if (temp1)
12120 delete arg1;
12121 }
12122 return NULL;
12123 }
12124
12125
12126 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj;
12128 wxLocale *arg1 = (wxLocale *) 0 ;
12129 wxString *arg2 = 0 ;
12130 bool result;
12131 bool temp2 = false ;
12132 PyObject * obj0 = 0 ;
12133 PyObject * obj1 = 0 ;
12134 char *kwnames[] = {
12135 (char *) "self",(char *) "szDomain", NULL
12136 };
12137
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12140 if (SWIG_arg_fail(1)) SWIG_fail;
12141 {
12142 arg2 = wxString_in_helper(obj1);
12143 if (arg2 == NULL) SWIG_fail;
12144 temp2 = true;
12145 }
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12149
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 {
12154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12155 }
12156 {
12157 if (temp2)
12158 delete arg2;
12159 }
12160 return resultobj;
12161 fail:
12162 {
12163 if (temp2)
12164 delete arg2;
12165 }
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxLocale *arg1 = (wxLocale *) 0 ;
12173 wxString *arg2 = 0 ;
12174 bool result;
12175 bool temp2 = false ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char *kwnames[] = {
12179 (char *) "self",(char *) "szDomain", NULL
12180 };
12181
12182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12184 if (SWIG_arg_fail(1)) SWIG_fail;
12185 {
12186 arg2 = wxString_in_helper(obj1);
12187 if (arg2 == NULL) SWIG_fail;
12188 temp2 = true;
12189 }
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12193
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12199 }
12200 {
12201 if (temp2)
12202 delete arg2;
12203 }
12204 return resultobj;
12205 fail:
12206 {
12207 if (temp2)
12208 delete arg2;
12209 }
12210 return NULL;
12211 }
12212
12213
12214 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12215 PyObject *resultobj;
12216 int arg1 ;
12217 wxLanguageInfo *result;
12218 PyObject * obj0 = 0 ;
12219 char *kwnames[] = {
12220 (char *) "lang", NULL
12221 };
12222
12223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12224 {
12225 arg1 = (int)(SWIG_As_int(obj0));
12226 if (SWIG_arg_fail(1)) SWIG_fail;
12227 }
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12231
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj;
12244 int arg1 ;
12245 wxString result;
12246 PyObject * obj0 = 0 ;
12247 char *kwnames[] = {
12248 (char *) "lang", NULL
12249 };
12250
12251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12252 {
12253 arg1 = (int)(SWIG_As_int(obj0));
12254 if (SWIG_arg_fail(1)) SWIG_fail;
12255 }
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = wxLocale::GetLanguageName(arg1);
12259
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 {
12264 #if wxUSE_UNICODE
12265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12266 #else
12267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12268 #endif
12269 }
12270 return resultobj;
12271 fail:
12272 return NULL;
12273 }
12274
12275
12276 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12277 PyObject *resultobj;
12278 wxString *arg1 = 0 ;
12279 wxLanguageInfo *result;
12280 bool temp1 = false ;
12281 PyObject * obj0 = 0 ;
12282 char *kwnames[] = {
12283 (char *) "locale", NULL
12284 };
12285
12286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12287 {
12288 arg1 = wxString_in_helper(obj0);
12289 if (arg1 == NULL) SWIG_fail;
12290 temp1 = true;
12291 }
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12300 {
12301 if (temp1)
12302 delete arg1;
12303 }
12304 return resultobj;
12305 fail:
12306 {
12307 if (temp1)
12308 delete arg1;
12309 }
12310 return NULL;
12311 }
12312
12313
12314 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj;
12316 wxLanguageInfo *arg1 = 0 ;
12317 PyObject * obj0 = 0 ;
12318 char *kwnames[] = {
12319 (char *) "info", NULL
12320 };
12321
12322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12323 {
12324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12325 if (SWIG_arg_fail(1)) SWIG_fail;
12326 if (arg1 == NULL) {
12327 SWIG_null_ref("wxLanguageInfo");
12328 }
12329 if (SWIG_arg_fail(1)) SWIG_fail;
12330 }
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12334
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 Py_INCREF(Py_None); resultobj = Py_None;
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12346 PyObject *resultobj;
12347 wxLocale *arg1 = (wxLocale *) 0 ;
12348 wxString *arg2 = 0 ;
12349 wxString const &arg3_defvalue = wxPyEmptyString ;
12350 wxString *arg3 = (wxString *) &arg3_defvalue ;
12351 wxString result;
12352 bool temp2 = false ;
12353 bool temp3 = false ;
12354 PyObject * obj0 = 0 ;
12355 PyObject * obj1 = 0 ;
12356 PyObject * obj2 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 {
12365 arg2 = wxString_in_helper(obj1);
12366 if (arg2 == NULL) SWIG_fail;
12367 temp2 = true;
12368 }
12369 if (obj2) {
12370 {
12371 arg3 = wxString_in_helper(obj2);
12372 if (arg3 == NULL) SWIG_fail;
12373 temp3 = true;
12374 }
12375 }
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12379
12380 wxPyEndAllowThreads(__tstate);
12381 if (PyErr_Occurred()) SWIG_fail;
12382 }
12383 {
12384 #if wxUSE_UNICODE
12385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12386 #else
12387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12388 #endif
12389 }
12390 {
12391 if (temp2)
12392 delete arg2;
12393 }
12394 {
12395 if (temp3)
12396 delete arg3;
12397 }
12398 return resultobj;
12399 fail:
12400 {
12401 if (temp2)
12402 delete arg2;
12403 }
12404 {
12405 if (temp3)
12406 delete arg3;
12407 }
12408 return NULL;
12409 }
12410
12411
12412 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj;
12414 wxLocale *arg1 = (wxLocale *) 0 ;
12415 wxString *result;
12416 PyObject * obj0 = 0 ;
12417 char *kwnames[] = {
12418 (char *) "self", NULL
12419 };
12420
12421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12423 if (SWIG_arg_fail(1)) SWIG_fail;
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 {
12427 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12428 result = (wxString *) &_result_ref;
12429 }
12430
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 {
12435 #if wxUSE_UNICODE
12436 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12437 #else
12438 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12439 #endif
12440 }
12441 return resultobj;
12442 fail:
12443 return NULL;
12444 }
12445
12446
12447 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12448 PyObject *obj;
12449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12450 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12451 Py_INCREF(obj);
12452 return Py_BuildValue((char *)"");
12453 }
12454 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj;
12456 wxLocale *result;
12457 char *kwnames[] = {
12458 NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (wxLocale *)wxGetLocale();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12477 PyObject *resultobj;
12478 wxString *arg1 = 0 ;
12479 wxString result;
12480 bool temp1 = false ;
12481 PyObject * obj0 = 0 ;
12482
12483 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12484 {
12485 arg1 = wxString_in_helper(obj0);
12486 if (arg1 == NULL) SWIG_fail;
12487 temp1 = true;
12488 }
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 result = wxGetTranslation((wxString const &)*arg1);
12492
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 #if wxUSE_UNICODE
12498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12499 #else
12500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12501 #endif
12502 }
12503 {
12504 if (temp1)
12505 delete arg1;
12506 }
12507 return resultobj;
12508 fail:
12509 {
12510 if (temp1)
12511 delete arg1;
12512 }
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12518 PyObject *resultobj;
12519 wxString *arg1 = 0 ;
12520 wxString *arg2 = 0 ;
12521 size_t arg3 ;
12522 wxString result;
12523 bool temp1 = false ;
12524 bool temp2 = false ;
12525 PyObject * obj0 = 0 ;
12526 PyObject * obj1 = 0 ;
12527 PyObject * obj2 = 0 ;
12528
12529 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12530 {
12531 arg1 = wxString_in_helper(obj0);
12532 if (arg1 == NULL) SWIG_fail;
12533 temp1 = true;
12534 }
12535 {
12536 arg2 = wxString_in_helper(obj1);
12537 if (arg2 == NULL) SWIG_fail;
12538 temp2 = true;
12539 }
12540 {
12541 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12542 if (SWIG_arg_fail(3)) SWIG_fail;
12543 }
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12547
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 #if wxUSE_UNICODE
12553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12554 #else
12555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12556 #endif
12557 }
12558 {
12559 if (temp1)
12560 delete arg1;
12561 }
12562 {
12563 if (temp2)
12564 delete arg2;
12565 }
12566 return resultobj;
12567 fail:
12568 {
12569 if (temp1)
12570 delete arg1;
12571 }
12572 {
12573 if (temp2)
12574 delete arg2;
12575 }
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12581 int argc;
12582 PyObject *argv[4];
12583 int ii;
12584
12585 argc = PyObject_Length(args);
12586 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12587 argv[ii] = PyTuple_GetItem(args,ii);
12588 }
12589 if (argc == 1) {
12590 int _v;
12591 {
12592 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12593 }
12594 if (_v) {
12595 return _wrap_GetTranslation__SWIG_0(self,args);
12596 }
12597 }
12598 if (argc == 3) {
12599 int _v;
12600 {
12601 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12602 }
12603 if (_v) {
12604 {
12605 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12606 }
12607 if (_v) {
12608 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12609 if (_v) {
12610 return _wrap_GetTranslation__SWIG_1(self,args);
12611 }
12612 }
12613 }
12614 }
12615
12616 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12617 return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj;
12623 wxEncodingConverter *result;
12624 char *kwnames[] = {
12625 NULL
12626 };
12627
12628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12629 {
12630 PyThreadState* __tstate = wxPyBeginAllowThreads();
12631 result = (wxEncodingConverter *)new wxEncodingConverter();
12632
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj;
12645 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12646 PyObject * obj0 = 0 ;
12647 char *kwnames[] = {
12648 (char *) "self", NULL
12649 };
12650
12651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12653 if (SWIG_arg_fail(1)) SWIG_fail;
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 delete arg1;
12657
12658 wxPyEndAllowThreads(__tstate);
12659 if (PyErr_Occurred()) SWIG_fail;
12660 }
12661 Py_INCREF(Py_None); resultobj = Py_None;
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12669 PyObject *resultobj;
12670 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12671 wxFontEncoding arg2 ;
12672 wxFontEncoding arg3 ;
12673 int arg4 = (int) wxCONVERT_STRICT ;
12674 bool result;
12675 PyObject * obj0 = 0 ;
12676 PyObject * obj1 = 0 ;
12677 PyObject * obj2 = 0 ;
12678 PyObject * obj3 = 0 ;
12679 char *kwnames[] = {
12680 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12681 };
12682
12683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12685 if (SWIG_arg_fail(1)) SWIG_fail;
12686 {
12687 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12688 if (SWIG_arg_fail(2)) SWIG_fail;
12689 }
12690 {
12691 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12692 if (SWIG_arg_fail(3)) SWIG_fail;
12693 }
12694 if (obj3) {
12695 {
12696 arg4 = (int)(SWIG_As_int(obj3));
12697 if (SWIG_arg_fail(4)) SWIG_fail;
12698 }
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12703
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 {
12708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12709 }
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12717 PyObject *resultobj;
12718 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12719 wxString *arg2 = 0 ;
12720 wxString result;
12721 bool temp2 = false ;
12722 PyObject * obj0 = 0 ;
12723 PyObject * obj1 = 0 ;
12724 char *kwnames[] = {
12725 (char *) "self",(char *) "input", NULL
12726 };
12727
12728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12730 if (SWIG_arg_fail(1)) SWIG_fail;
12731 {
12732 arg2 = wxString_in_helper(obj1);
12733 if (arg2 == NULL) SWIG_fail;
12734 temp2 = true;
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (arg1)->Convert((wxString const &)*arg2);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 #if wxUSE_UNICODE
12745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12746 #else
12747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12748 #endif
12749 }
12750 {
12751 if (temp2)
12752 delete arg2;
12753 }
12754 return resultobj;
12755 fail:
12756 {
12757 if (temp2)
12758 delete arg2;
12759 }
12760 return NULL;
12761 }
12762
12763
12764 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12765 PyObject *resultobj;
12766 wxFontEncoding arg1 ;
12767 int arg2 = (int) wxPLATFORM_CURRENT ;
12768 wxFontEncodingArray result;
12769 PyObject * obj0 = 0 ;
12770 PyObject * obj1 = 0 ;
12771 char *kwnames[] = {
12772 (char *) "enc",(char *) "platform", NULL
12773 };
12774
12775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12776 {
12777 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 }
12780 if (obj1) {
12781 {
12782 arg2 = (int)(SWIG_As_int(obj1));
12783 if (SWIG_arg_fail(2)) SWIG_fail;
12784 }
12785 }
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 {
12794 resultobj = PyList_New(0);
12795 for (size_t i=0; i < (&result)->GetCount(); i++) {
12796 PyObject* number = PyInt_FromLong((&result)->Item(i));
12797 PyList_Append(resultobj, number);
12798 Py_DECREF(number);
12799 }
12800 }
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj;
12809 wxFontEncoding arg1 ;
12810 wxFontEncodingArray result;
12811 PyObject * obj0 = 0 ;
12812 char *kwnames[] = {
12813 (char *) "enc", NULL
12814 };
12815
12816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12817 {
12818 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12819 if (SWIG_arg_fail(1)) SWIG_fail;
12820 }
12821 {
12822 PyThreadState* __tstate = wxPyBeginAllowThreads();
12823 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12824
12825 wxPyEndAllowThreads(__tstate);
12826 if (PyErr_Occurred()) SWIG_fail;
12827 }
12828 {
12829 resultobj = PyList_New(0);
12830 for (size_t i=0; i < (&result)->GetCount(); i++) {
12831 PyObject* number = PyInt_FromLong((&result)->Item(i));
12832 PyList_Append(resultobj, number);
12833 Py_DECREF(number);
12834 }
12835 }
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj;
12844 wxFontEncoding arg1 ;
12845 wxFontEncoding arg2 ;
12846 bool result;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 char *kwnames[] = {
12850 (char *) "encIn",(char *) "encOut", NULL
12851 };
12852
12853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12854 {
12855 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12856 if (SWIG_arg_fail(1)) SWIG_fail;
12857 }
12858 {
12859 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12860 if (SWIG_arg_fail(2)) SWIG_fail;
12861 }
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12865
12866 wxPyEndAllowThreads(__tstate);
12867 if (PyErr_Occurred()) SWIG_fail;
12868 }
12869 {
12870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12871 }
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12879 PyObject *obj;
12880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12881 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12882 Py_INCREF(obj);
12883 return Py_BuildValue((char *)"");
12884 }
12885 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12886 PyObject *resultobj;
12887 wxDC *arg1 = (wxDC *) 0 ;
12888 PyObject * obj0 = 0 ;
12889 char *kwnames[] = {
12890 (char *) "self", NULL
12891 };
12892
12893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12895 if (SWIG_arg_fail(1)) SWIG_fail;
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 delete arg1;
12899
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 Py_INCREF(Py_None); resultobj = Py_None;
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxDC *arg1 = (wxDC *) 0 ;
12913 PyObject * obj0 = 0 ;
12914 char *kwnames[] = {
12915 (char *) "self", NULL
12916 };
12917
12918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12920 if (SWIG_arg_fail(1)) SWIG_fail;
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 (arg1)->BeginDrawing();
12924
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 Py_INCREF(Py_None); resultobj = Py_None;
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj;
12937 wxDC *arg1 = (wxDC *) 0 ;
12938 PyObject * obj0 = 0 ;
12939 char *kwnames[] = {
12940 (char *) "self", NULL
12941 };
12942
12943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12945 if (SWIG_arg_fail(1)) SWIG_fail;
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 (arg1)->EndDrawing();
12949
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 Py_INCREF(Py_None); resultobj = Py_None;
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12961 PyObject *resultobj;
12962 wxDC *arg1 = (wxDC *) 0 ;
12963 int arg2 ;
12964 int arg3 ;
12965 wxColour *arg4 = 0 ;
12966 int arg5 = (int) wxFLOOD_SURFACE ;
12967 bool result;
12968 wxColour temp4 ;
12969 PyObject * obj0 = 0 ;
12970 PyObject * obj1 = 0 ;
12971 PyObject * obj2 = 0 ;
12972 PyObject * obj3 = 0 ;
12973 PyObject * obj4 = 0 ;
12974 char *kwnames[] = {
12975 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12976 };
12977
12978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12980 if (SWIG_arg_fail(1)) SWIG_fail;
12981 {
12982 arg2 = (int)(SWIG_As_int(obj1));
12983 if (SWIG_arg_fail(2)) SWIG_fail;
12984 }
12985 {
12986 arg3 = (int)(SWIG_As_int(obj2));
12987 if (SWIG_arg_fail(3)) SWIG_fail;
12988 }
12989 {
12990 arg4 = &temp4;
12991 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12992 }
12993 if (obj4) {
12994 {
12995 arg5 = (int)(SWIG_As_int(obj4));
12996 if (SWIG_arg_fail(5)) SWIG_fail;
12997 }
12998 }
12999 {
13000 PyThreadState* __tstate = wxPyBeginAllowThreads();
13001 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
13002
13003 wxPyEndAllowThreads(__tstate);
13004 if (PyErr_Occurred()) SWIG_fail;
13005 }
13006 {
13007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13008 }
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxDC *arg1 = (wxDC *) 0 ;
13018 wxPoint *arg2 = 0 ;
13019 wxColour *arg3 = 0 ;
13020 int arg4 = (int) wxFLOOD_SURFACE ;
13021 bool result;
13022 wxPoint temp2 ;
13023 wxColour temp3 ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 PyObject * obj2 = 0 ;
13027 PyObject * obj3 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 arg2 = &temp2;
13037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13038 }
13039 {
13040 arg3 = &temp3;
13041 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13042 }
13043 if (obj3) {
13044 {
13045 arg4 = (int)(SWIG_As_int(obj3));
13046 if (SWIG_arg_fail(4)) SWIG_fail;
13047 }
13048 }
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13052
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 {
13057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13058 }
13059 return resultobj;
13060 fail:
13061 return NULL;
13062 }
13063
13064
13065 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13066 PyObject *resultobj;
13067 wxDC *arg1 = (wxDC *) 0 ;
13068 int arg2 ;
13069 int arg3 ;
13070 wxColour result;
13071 PyObject * obj0 = 0 ;
13072 PyObject * obj1 = 0 ;
13073 PyObject * obj2 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "x",(char *) "y", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = (int)(SWIG_As_int(obj1));
13083 if (SWIG_arg_fail(2)) SWIG_fail;
13084 }
13085 {
13086 arg3 = (int)(SWIG_As_int(obj2));
13087 if (SWIG_arg_fail(3)) SWIG_fail;
13088 }
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 result = wxDC_GetPixel(arg1,arg2,arg3);
13092
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 {
13097 wxColour * resultptr;
13098 resultptr = new wxColour((wxColour &)(result));
13099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13100 }
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13108 PyObject *resultobj;
13109 wxDC *arg1 = (wxDC *) 0 ;
13110 wxPoint *arg2 = 0 ;
13111 wxColour result;
13112 wxPoint temp2 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "pt", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = &temp2;
13124 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 {
13134 wxColour * resultptr;
13135 resultptr = new wxColour((wxColour &)(result));
13136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13137 }
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj;
13146 wxDC *arg1 = (wxDC *) 0 ;
13147 int arg2 ;
13148 int arg3 ;
13149 int arg4 ;
13150 int arg5 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 PyObject * obj2 = 0 ;
13154 PyObject * obj3 = 0 ;
13155 PyObject * obj4 = 0 ;
13156 char *kwnames[] = {
13157 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13158 };
13159
13160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13162 if (SWIG_arg_fail(1)) SWIG_fail;
13163 {
13164 arg2 = (int)(SWIG_As_int(obj1));
13165 if (SWIG_arg_fail(2)) SWIG_fail;
13166 }
13167 {
13168 arg3 = (int)(SWIG_As_int(obj2));
13169 if (SWIG_arg_fail(3)) SWIG_fail;
13170 }
13171 {
13172 arg4 = (int)(SWIG_As_int(obj3));
13173 if (SWIG_arg_fail(4)) SWIG_fail;
13174 }
13175 {
13176 arg5 = (int)(SWIG_As_int(obj4));
13177 if (SWIG_arg_fail(5)) SWIG_fail;
13178 }
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13182
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 Py_INCREF(Py_None); resultobj = Py_None;
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj;
13195 wxDC *arg1 = (wxDC *) 0 ;
13196 wxPoint *arg2 = 0 ;
13197 wxPoint *arg3 = 0 ;
13198 wxPoint temp2 ;
13199 wxPoint temp3 ;
13200 PyObject * obj0 = 0 ;
13201 PyObject * obj1 = 0 ;
13202 PyObject * obj2 = 0 ;
13203 char *kwnames[] = {
13204 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13205 };
13206
13207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13209 if (SWIG_arg_fail(1)) SWIG_fail;
13210 {
13211 arg2 = &temp2;
13212 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13213 }
13214 {
13215 arg3 = &temp3;
13216 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13217 }
13218 {
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13221
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 Py_INCREF(Py_None); resultobj = Py_None;
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj;
13234 wxDC *arg1 = (wxDC *) 0 ;
13235 int arg2 ;
13236 int arg3 ;
13237 PyObject * obj0 = 0 ;
13238 PyObject * obj1 = 0 ;
13239 PyObject * obj2 = 0 ;
13240 char *kwnames[] = {
13241 (char *) "self",(char *) "x",(char *) "y", NULL
13242 };
13243
13244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13246 if (SWIG_arg_fail(1)) SWIG_fail;
13247 {
13248 arg2 = (int)(SWIG_As_int(obj1));
13249 if (SWIG_arg_fail(2)) SWIG_fail;
13250 }
13251 {
13252 arg3 = (int)(SWIG_As_int(obj2));
13253 if (SWIG_arg_fail(3)) SWIG_fail;
13254 }
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 (arg1)->CrossHair(arg2,arg3);
13258
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 Py_INCREF(Py_None); resultobj = Py_None;
13263 return resultobj;
13264 fail:
13265 return NULL;
13266 }
13267
13268
13269 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13270 PyObject *resultobj;
13271 wxDC *arg1 = (wxDC *) 0 ;
13272 wxPoint *arg2 = 0 ;
13273 wxPoint temp2 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char *kwnames[] = {
13277 (char *) "self",(char *) "pt", NULL
13278 };
13279
13280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13282 if (SWIG_arg_fail(1)) SWIG_fail;
13283 {
13284 arg2 = &temp2;
13285 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 (arg1)->CrossHair((wxPoint const &)*arg2);
13290
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 Py_INCREF(Py_None); resultobj = Py_None;
13295 return resultobj;
13296 fail:
13297 return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj;
13303 wxDC *arg1 = (wxDC *) 0 ;
13304 int arg2 ;
13305 int arg3 ;
13306 int arg4 ;
13307 int arg5 ;
13308 int arg6 ;
13309 int arg7 ;
13310 PyObject * obj0 = 0 ;
13311 PyObject * obj1 = 0 ;
13312 PyObject * obj2 = 0 ;
13313 PyObject * obj3 = 0 ;
13314 PyObject * obj4 = 0 ;
13315 PyObject * obj5 = 0 ;
13316 PyObject * obj6 = 0 ;
13317 char *kwnames[] = {
13318 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13319 };
13320
13321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13323 if (SWIG_arg_fail(1)) SWIG_fail;
13324 {
13325 arg2 = (int)(SWIG_As_int(obj1));
13326 if (SWIG_arg_fail(2)) SWIG_fail;
13327 }
13328 {
13329 arg3 = (int)(SWIG_As_int(obj2));
13330 if (SWIG_arg_fail(3)) SWIG_fail;
13331 }
13332 {
13333 arg4 = (int)(SWIG_As_int(obj3));
13334 if (SWIG_arg_fail(4)) SWIG_fail;
13335 }
13336 {
13337 arg5 = (int)(SWIG_As_int(obj4));
13338 if (SWIG_arg_fail(5)) SWIG_fail;
13339 }
13340 {
13341 arg6 = (int)(SWIG_As_int(obj5));
13342 if (SWIG_arg_fail(6)) SWIG_fail;
13343 }
13344 {
13345 arg7 = (int)(SWIG_As_int(obj6));
13346 if (SWIG_arg_fail(7)) SWIG_fail;
13347 }
13348 {
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13351
13352 wxPyEndAllowThreads(__tstate);
13353 if (PyErr_Occurred()) SWIG_fail;
13354 }
13355 Py_INCREF(Py_None); resultobj = Py_None;
13356 return resultobj;
13357 fail:
13358 return NULL;
13359 }
13360
13361
13362 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13363 PyObject *resultobj;
13364 wxDC *arg1 = (wxDC *) 0 ;
13365 wxPoint *arg2 = 0 ;
13366 wxPoint *arg3 = 0 ;
13367 wxPoint *arg4 = 0 ;
13368 wxPoint temp2 ;
13369 wxPoint temp3 ;
13370 wxPoint temp4 ;
13371 PyObject * obj0 = 0 ;
13372 PyObject * obj1 = 0 ;
13373 PyObject * obj2 = 0 ;
13374 PyObject * obj3 = 0 ;
13375 char *kwnames[] = {
13376 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13377 };
13378
13379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13381 if (SWIG_arg_fail(1)) SWIG_fail;
13382 {
13383 arg2 = &temp2;
13384 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13385 }
13386 {
13387 arg3 = &temp3;
13388 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13389 }
13390 {
13391 arg4 = &temp4;
13392 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13393 }
13394 {
13395 PyThreadState* __tstate = wxPyBeginAllowThreads();
13396 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13397
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 Py_INCREF(Py_None); resultobj = Py_None;
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj;
13410 wxDC *arg1 = (wxDC *) 0 ;
13411 int arg2 ;
13412 int arg3 ;
13413 int arg4 ;
13414 int arg5 ;
13415 PyObject * obj0 = 0 ;
13416 PyObject * obj1 = 0 ;
13417 PyObject * obj2 = 0 ;
13418 PyObject * obj3 = 0 ;
13419 PyObject * obj4 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13426 if (SWIG_arg_fail(1)) SWIG_fail;
13427 {
13428 arg2 = (int)(SWIG_As_int(obj1));
13429 if (SWIG_arg_fail(2)) SWIG_fail;
13430 }
13431 {
13432 arg3 = (int)(SWIG_As_int(obj2));
13433 if (SWIG_arg_fail(3)) SWIG_fail;
13434 }
13435 {
13436 arg4 = (int)(SWIG_As_int(obj3));
13437 if (SWIG_arg_fail(4)) SWIG_fail;
13438 }
13439 {
13440 arg5 = (int)(SWIG_As_int(obj4));
13441 if (SWIG_arg_fail(5)) SWIG_fail;
13442 }
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13446
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 Py_INCREF(Py_None); resultobj = Py_None;
13451 return resultobj;
13452 fail:
13453 return NULL;
13454 }
13455
13456
13457 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13458 PyObject *resultobj;
13459 wxDC *arg1 = (wxDC *) 0 ;
13460 wxRect *arg2 = 0 ;
13461 wxRect temp2 ;
13462 PyObject * obj0 = 0 ;
13463 PyObject * obj1 = 0 ;
13464 char *kwnames[] = {
13465 (char *) "self",(char *) "rect", NULL
13466 };
13467
13468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13470 if (SWIG_arg_fail(1)) SWIG_fail;
13471 {
13472 arg2 = &temp2;
13473 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13474 }
13475 {
13476 PyThreadState* __tstate = wxPyBeginAllowThreads();
13477 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13478
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 Py_INCREF(Py_None); resultobj = Py_None;
13483 return resultobj;
13484 fail:
13485 return NULL;
13486 }
13487
13488
13489 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13490 PyObject *resultobj;
13491 wxDC *arg1 = (wxDC *) 0 ;
13492 int arg2 ;
13493 int arg3 ;
13494 int arg4 ;
13495 int arg5 ;
13496 double arg6 ;
13497 double arg7 ;
13498 PyObject * obj0 = 0 ;
13499 PyObject * obj1 = 0 ;
13500 PyObject * obj2 = 0 ;
13501 PyObject * obj3 = 0 ;
13502 PyObject * obj4 = 0 ;
13503 PyObject * obj5 = 0 ;
13504 PyObject * obj6 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13511 if (SWIG_arg_fail(1)) SWIG_fail;
13512 {
13513 arg2 = (int)(SWIG_As_int(obj1));
13514 if (SWIG_arg_fail(2)) SWIG_fail;
13515 }
13516 {
13517 arg3 = (int)(SWIG_As_int(obj2));
13518 if (SWIG_arg_fail(3)) SWIG_fail;
13519 }
13520 {
13521 arg4 = (int)(SWIG_As_int(obj3));
13522 if (SWIG_arg_fail(4)) SWIG_fail;
13523 }
13524 {
13525 arg5 = (int)(SWIG_As_int(obj4));
13526 if (SWIG_arg_fail(5)) SWIG_fail;
13527 }
13528 {
13529 arg6 = (double)(SWIG_As_double(obj5));
13530 if (SWIG_arg_fail(6)) SWIG_fail;
13531 }
13532 {
13533 arg7 = (double)(SWIG_As_double(obj6));
13534 if (SWIG_arg_fail(7)) SWIG_fail;
13535 }
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 Py_INCREF(Py_None); resultobj = Py_None;
13544 return resultobj;
13545 fail:
13546 return NULL;
13547 }
13548
13549
13550 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13551 PyObject *resultobj;
13552 wxDC *arg1 = (wxDC *) 0 ;
13553 wxPoint *arg2 = 0 ;
13554 wxSize *arg3 = 0 ;
13555 double arg4 ;
13556 double arg5 ;
13557 wxPoint temp2 ;
13558 wxSize temp3 ;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 PyObject * obj2 = 0 ;
13562 PyObject * obj3 = 0 ;
13563 PyObject * obj4 = 0 ;
13564 char *kwnames[] = {
13565 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13566 };
13567
13568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13570 if (SWIG_arg_fail(1)) SWIG_fail;
13571 {
13572 arg2 = &temp2;
13573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13574 }
13575 {
13576 arg3 = &temp3;
13577 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13578 }
13579 {
13580 arg4 = (double)(SWIG_As_double(obj3));
13581 if (SWIG_arg_fail(4)) SWIG_fail;
13582 }
13583 {
13584 arg5 = (double)(SWIG_As_double(obj4));
13585 if (SWIG_arg_fail(5)) SWIG_fail;
13586 }
13587 {
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 Py_INCREF(Py_None); resultobj = Py_None;
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj;
13603 wxDC *arg1 = (wxDC *) 0 ;
13604 int arg2 ;
13605 int arg3 ;
13606 PyObject * obj0 = 0 ;
13607 PyObject * obj1 = 0 ;
13608 PyObject * obj2 = 0 ;
13609 char *kwnames[] = {
13610 (char *) "self",(char *) "x",(char *) "y", NULL
13611 };
13612
13613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13615 if (SWIG_arg_fail(1)) SWIG_fail;
13616 {
13617 arg2 = (int)(SWIG_As_int(obj1));
13618 if (SWIG_arg_fail(2)) SWIG_fail;
13619 }
13620 {
13621 arg3 = (int)(SWIG_As_int(obj2));
13622 if (SWIG_arg_fail(3)) SWIG_fail;
13623 }
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 (arg1)->DrawPoint(arg2,arg3);
13627
13628 wxPyEndAllowThreads(__tstate);
13629 if (PyErr_Occurred()) SWIG_fail;
13630 }
13631 Py_INCREF(Py_None); resultobj = Py_None;
13632 return resultobj;
13633 fail:
13634 return NULL;
13635 }
13636
13637
13638 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13639 PyObject *resultobj;
13640 wxDC *arg1 = (wxDC *) 0 ;
13641 wxPoint *arg2 = 0 ;
13642 wxPoint temp2 ;
13643 PyObject * obj0 = 0 ;
13644 PyObject * obj1 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "self",(char *) "pt", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13651 if (SWIG_arg_fail(1)) SWIG_fail;
13652 {
13653 arg2 = &temp2;
13654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13655 }
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 (arg1)->DrawPoint((wxPoint const &)*arg2);
13659
13660 wxPyEndAllowThreads(__tstate);
13661 if (PyErr_Occurred()) SWIG_fail;
13662 }
13663 Py_INCREF(Py_None); resultobj = Py_None;
13664 return resultobj;
13665 fail:
13666 return NULL;
13667 }
13668
13669
13670 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13671 PyObject *resultobj;
13672 wxDC *arg1 = (wxDC *) 0 ;
13673 int arg2 ;
13674 int arg3 ;
13675 int arg4 ;
13676 int arg5 ;
13677 PyObject * obj0 = 0 ;
13678 PyObject * obj1 = 0 ;
13679 PyObject * obj2 = 0 ;
13680 PyObject * obj3 = 0 ;
13681 PyObject * obj4 = 0 ;
13682 char *kwnames[] = {
13683 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13684 };
13685
13686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13688 if (SWIG_arg_fail(1)) SWIG_fail;
13689 {
13690 arg2 = (int)(SWIG_As_int(obj1));
13691 if (SWIG_arg_fail(2)) SWIG_fail;
13692 }
13693 {
13694 arg3 = (int)(SWIG_As_int(obj2));
13695 if (SWIG_arg_fail(3)) SWIG_fail;
13696 }
13697 {
13698 arg4 = (int)(SWIG_As_int(obj3));
13699 if (SWIG_arg_fail(4)) SWIG_fail;
13700 }
13701 {
13702 arg5 = (int)(SWIG_As_int(obj4));
13703 if (SWIG_arg_fail(5)) SWIG_fail;
13704 }
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13708
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 Py_INCREF(Py_None); resultobj = Py_None;
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj;
13721 wxDC *arg1 = (wxDC *) 0 ;
13722 wxRect *arg2 = 0 ;
13723 wxRect temp2 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 char *kwnames[] = {
13727 (char *) "self",(char *) "rect", NULL
13728 };
13729
13730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13732 if (SWIG_arg_fail(1)) SWIG_fail;
13733 {
13734 arg2 = &temp2;
13735 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->DrawRectangle((wxRect const &)*arg2);
13740
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 Py_INCREF(Py_None); resultobj = Py_None;
13745 return resultobj;
13746 fail:
13747 return NULL;
13748 }
13749
13750
13751 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13752 PyObject *resultobj;
13753 wxDC *arg1 = (wxDC *) 0 ;
13754 wxPoint *arg2 = 0 ;
13755 wxSize *arg3 = 0 ;
13756 wxPoint temp2 ;
13757 wxSize temp3 ;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 char *kwnames[] = {
13762 (char *) "self",(char *) "pt",(char *) "sz", NULL
13763 };
13764
13765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13767 if (SWIG_arg_fail(1)) SWIG_fail;
13768 {
13769 arg2 = &temp2;
13770 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13771 }
13772 {
13773 arg3 = &temp3;
13774 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13775 }
13776 {
13777 PyThreadState* __tstate = wxPyBeginAllowThreads();
13778 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13779
13780 wxPyEndAllowThreads(__tstate);
13781 if (PyErr_Occurred()) SWIG_fail;
13782 }
13783 Py_INCREF(Py_None); resultobj = Py_None;
13784 return resultobj;
13785 fail:
13786 return NULL;
13787 }
13788
13789
13790 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13791 PyObject *resultobj;
13792 wxDC *arg1 = (wxDC *) 0 ;
13793 int arg2 ;
13794 int arg3 ;
13795 int arg4 ;
13796 int arg5 ;
13797 double arg6 ;
13798 PyObject * obj0 = 0 ;
13799 PyObject * obj1 = 0 ;
13800 PyObject * obj2 = 0 ;
13801 PyObject * obj3 = 0 ;
13802 PyObject * obj4 = 0 ;
13803 PyObject * obj5 = 0 ;
13804 char *kwnames[] = {
13805 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13806 };
13807
13808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13810 if (SWIG_arg_fail(1)) SWIG_fail;
13811 {
13812 arg2 = (int)(SWIG_As_int(obj1));
13813 if (SWIG_arg_fail(2)) SWIG_fail;
13814 }
13815 {
13816 arg3 = (int)(SWIG_As_int(obj2));
13817 if (SWIG_arg_fail(3)) SWIG_fail;
13818 }
13819 {
13820 arg4 = (int)(SWIG_As_int(obj3));
13821 if (SWIG_arg_fail(4)) SWIG_fail;
13822 }
13823 {
13824 arg5 = (int)(SWIG_As_int(obj4));
13825 if (SWIG_arg_fail(5)) SWIG_fail;
13826 }
13827 {
13828 arg6 = (double)(SWIG_As_double(obj5));
13829 if (SWIG_arg_fail(6)) SWIG_fail;
13830 }
13831 {
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13834
13835 wxPyEndAllowThreads(__tstate);
13836 if (PyErr_Occurred()) SWIG_fail;
13837 }
13838 Py_INCREF(Py_None); resultobj = Py_None;
13839 return resultobj;
13840 fail:
13841 return NULL;
13842 }
13843
13844
13845 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13846 PyObject *resultobj;
13847 wxDC *arg1 = (wxDC *) 0 ;
13848 wxRect *arg2 = 0 ;
13849 double arg3 ;
13850 wxRect temp2 ;
13851 PyObject * obj0 = 0 ;
13852 PyObject * obj1 = 0 ;
13853 PyObject * obj2 = 0 ;
13854 char *kwnames[] = {
13855 (char *) "self",(char *) "r",(char *) "radius", NULL
13856 };
13857
13858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13860 if (SWIG_arg_fail(1)) SWIG_fail;
13861 {
13862 arg2 = &temp2;
13863 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13864 }
13865 {
13866 arg3 = (double)(SWIG_As_double(obj2));
13867 if (SWIG_arg_fail(3)) SWIG_fail;
13868 }
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13872
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 Py_INCREF(Py_None); resultobj = Py_None;
13877 return resultobj;
13878 fail:
13879 return NULL;
13880 }
13881
13882
13883 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13884 PyObject *resultobj;
13885 wxDC *arg1 = (wxDC *) 0 ;
13886 wxPoint *arg2 = 0 ;
13887 wxSize *arg3 = 0 ;
13888 double arg4 ;
13889 wxPoint temp2 ;
13890 wxSize temp3 ;
13891 PyObject * obj0 = 0 ;
13892 PyObject * obj1 = 0 ;
13893 PyObject * obj2 = 0 ;
13894 PyObject * obj3 = 0 ;
13895 char *kwnames[] = {
13896 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13897 };
13898
13899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13901 if (SWIG_arg_fail(1)) SWIG_fail;
13902 {
13903 arg2 = &temp2;
13904 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13905 }
13906 {
13907 arg3 = &temp3;
13908 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13909 }
13910 {
13911 arg4 = (double)(SWIG_As_double(obj3));
13912 if (SWIG_arg_fail(4)) SWIG_fail;
13913 }
13914 {
13915 PyThreadState* __tstate = wxPyBeginAllowThreads();
13916 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13917
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 Py_INCREF(Py_None); resultobj = Py_None;
13922 return resultobj;
13923 fail:
13924 return NULL;
13925 }
13926
13927
13928 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13929 PyObject *resultobj;
13930 wxDC *arg1 = (wxDC *) 0 ;
13931 int arg2 ;
13932 int arg3 ;
13933 int arg4 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 PyObject * obj3 = 0 ;
13938 char *kwnames[] = {
13939 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13940 };
13941
13942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13944 if (SWIG_arg_fail(1)) SWIG_fail;
13945 {
13946 arg2 = (int)(SWIG_As_int(obj1));
13947 if (SWIG_arg_fail(2)) SWIG_fail;
13948 }
13949 {
13950 arg3 = (int)(SWIG_As_int(obj2));
13951 if (SWIG_arg_fail(3)) SWIG_fail;
13952 }
13953 {
13954 arg4 = (int)(SWIG_As_int(obj3));
13955 if (SWIG_arg_fail(4)) SWIG_fail;
13956 }
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 (arg1)->DrawCircle(arg2,arg3,arg4);
13960
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 Py_INCREF(Py_None); resultobj = Py_None;
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13972 PyObject *resultobj;
13973 wxDC *arg1 = (wxDC *) 0 ;
13974 wxPoint *arg2 = 0 ;
13975 int arg3 ;
13976 wxPoint temp2 ;
13977 PyObject * obj0 = 0 ;
13978 PyObject * obj1 = 0 ;
13979 PyObject * obj2 = 0 ;
13980 char *kwnames[] = {
13981 (char *) "self",(char *) "pt",(char *) "radius", NULL
13982 };
13983
13984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(1)) SWIG_fail;
13987 {
13988 arg2 = &temp2;
13989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13990 }
13991 {
13992 arg3 = (int)(SWIG_As_int(obj2));
13993 if (SWIG_arg_fail(3)) SWIG_fail;
13994 }
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13998
13999 wxPyEndAllowThreads(__tstate);
14000 if (PyErr_Occurred()) SWIG_fail;
14001 }
14002 Py_INCREF(Py_None); resultobj = Py_None;
14003 return resultobj;
14004 fail:
14005 return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
14010 PyObject *resultobj;
14011 wxDC *arg1 = (wxDC *) 0 ;
14012 int arg2 ;
14013 int arg3 ;
14014 int arg4 ;
14015 int arg5 ;
14016 PyObject * obj0 = 0 ;
14017 PyObject * obj1 = 0 ;
14018 PyObject * obj2 = 0 ;
14019 PyObject * obj3 = 0 ;
14020 PyObject * obj4 = 0 ;
14021 char *kwnames[] = {
14022 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14023 };
14024
14025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14027 if (SWIG_arg_fail(1)) SWIG_fail;
14028 {
14029 arg2 = (int)(SWIG_As_int(obj1));
14030 if (SWIG_arg_fail(2)) SWIG_fail;
14031 }
14032 {
14033 arg3 = (int)(SWIG_As_int(obj2));
14034 if (SWIG_arg_fail(3)) SWIG_fail;
14035 }
14036 {
14037 arg4 = (int)(SWIG_As_int(obj3));
14038 if (SWIG_arg_fail(4)) SWIG_fail;
14039 }
14040 {
14041 arg5 = (int)(SWIG_As_int(obj4));
14042 if (SWIG_arg_fail(5)) SWIG_fail;
14043 }
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14047
14048 wxPyEndAllowThreads(__tstate);
14049 if (PyErr_Occurred()) SWIG_fail;
14050 }
14051 Py_INCREF(Py_None); resultobj = Py_None;
14052 return resultobj;
14053 fail:
14054 return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14059 PyObject *resultobj;
14060 wxDC *arg1 = (wxDC *) 0 ;
14061 wxRect *arg2 = 0 ;
14062 wxRect temp2 ;
14063 PyObject * obj0 = 0 ;
14064 PyObject * obj1 = 0 ;
14065 char *kwnames[] = {
14066 (char *) "self",(char *) "rect", NULL
14067 };
14068
14069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14071 if (SWIG_arg_fail(1)) SWIG_fail;
14072 {
14073 arg2 = &temp2;
14074 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14075 }
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 (arg1)->DrawEllipse((wxRect const &)*arg2);
14079
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 Py_INCREF(Py_None); resultobj = Py_None;
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj;
14092 wxDC *arg1 = (wxDC *) 0 ;
14093 wxPoint *arg2 = 0 ;
14094 wxSize *arg3 = 0 ;
14095 wxPoint temp2 ;
14096 wxSize temp3 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 char *kwnames[] = {
14101 (char *) "self",(char *) "pt",(char *) "sz", NULL
14102 };
14103
14104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14106 if (SWIG_arg_fail(1)) SWIG_fail;
14107 {
14108 arg2 = &temp2;
14109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14110 }
14111 {
14112 arg3 = &temp3;
14113 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14114 }
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj;
14131 wxDC *arg1 = (wxDC *) 0 ;
14132 wxIcon *arg2 = 0 ;
14133 int arg3 ;
14134 int arg4 ;
14135 PyObject * obj0 = 0 ;
14136 PyObject * obj1 = 0 ;
14137 PyObject * obj2 = 0 ;
14138 PyObject * obj3 = 0 ;
14139 char *kwnames[] = {
14140 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14141 };
14142
14143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14145 if (SWIG_arg_fail(1)) SWIG_fail;
14146 {
14147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14148 if (SWIG_arg_fail(2)) SWIG_fail;
14149 if (arg2 == NULL) {
14150 SWIG_null_ref("wxIcon");
14151 }
14152 if (SWIG_arg_fail(2)) SWIG_fail;
14153 }
14154 {
14155 arg3 = (int)(SWIG_As_int(obj2));
14156 if (SWIG_arg_fail(3)) SWIG_fail;
14157 }
14158 {
14159 arg4 = (int)(SWIG_As_int(obj3));
14160 if (SWIG_arg_fail(4)) SWIG_fail;
14161 }
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14165
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 Py_INCREF(Py_None); resultobj = Py_None;
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxDC *arg1 = (wxDC *) 0 ;
14179 wxIcon *arg2 = 0 ;
14180 wxPoint *arg3 = 0 ;
14181 wxPoint temp3 ;
14182 PyObject * obj0 = 0 ;
14183 PyObject * obj1 = 0 ;
14184 PyObject * obj2 = 0 ;
14185 char *kwnames[] = {
14186 (char *) "self",(char *) "icon",(char *) "pt", NULL
14187 };
14188
14189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14191 if (SWIG_arg_fail(1)) SWIG_fail;
14192 {
14193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14194 if (SWIG_arg_fail(2)) SWIG_fail;
14195 if (arg2 == NULL) {
14196 SWIG_null_ref("wxIcon");
14197 }
14198 if (SWIG_arg_fail(2)) SWIG_fail;
14199 }
14200 {
14201 arg3 = &temp3;
14202 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14203 }
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 Py_INCREF(Py_None); resultobj = Py_None;
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj;
14220 wxDC *arg1 = (wxDC *) 0 ;
14221 wxBitmap *arg2 = 0 ;
14222 int arg3 ;
14223 int arg4 ;
14224 bool arg5 = (bool) false ;
14225 PyObject * obj0 = 0 ;
14226 PyObject * obj1 = 0 ;
14227 PyObject * obj2 = 0 ;
14228 PyObject * obj3 = 0 ;
14229 PyObject * obj4 = 0 ;
14230 char *kwnames[] = {
14231 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14232 };
14233
14234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14236 if (SWIG_arg_fail(1)) SWIG_fail;
14237 {
14238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(2)) SWIG_fail;
14240 if (arg2 == NULL) {
14241 SWIG_null_ref("wxBitmap");
14242 }
14243 if (SWIG_arg_fail(2)) SWIG_fail;
14244 }
14245 {
14246 arg3 = (int)(SWIG_As_int(obj2));
14247 if (SWIG_arg_fail(3)) SWIG_fail;
14248 }
14249 {
14250 arg4 = (int)(SWIG_As_int(obj3));
14251 if (SWIG_arg_fail(4)) SWIG_fail;
14252 }
14253 if (obj4) {
14254 {
14255 arg5 = (bool)(SWIG_As_bool(obj4));
14256 if (SWIG_arg_fail(5)) SWIG_fail;
14257 }
14258 }
14259 {
14260 PyThreadState* __tstate = wxPyBeginAllowThreads();
14261 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14262
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 Py_INCREF(Py_None); resultobj = Py_None;
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxDC *arg1 = (wxDC *) 0 ;
14276 wxBitmap *arg2 = 0 ;
14277 wxPoint *arg3 = 0 ;
14278 bool arg4 = (bool) false ;
14279 wxPoint temp3 ;
14280 PyObject * obj0 = 0 ;
14281 PyObject * obj1 = 0 ;
14282 PyObject * obj2 = 0 ;
14283 PyObject * obj3 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14293 if (SWIG_arg_fail(2)) SWIG_fail;
14294 if (arg2 == NULL) {
14295 SWIG_null_ref("wxBitmap");
14296 }
14297 if (SWIG_arg_fail(2)) SWIG_fail;
14298 }
14299 {
14300 arg3 = &temp3;
14301 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14302 }
14303 if (obj3) {
14304 {
14305 arg4 = (bool)(SWIG_As_bool(obj3));
14306 if (SWIG_arg_fail(4)) SWIG_fail;
14307 }
14308 }
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14312
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 Py_INCREF(Py_None); resultobj = Py_None;
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14324 PyObject *resultobj;
14325 wxDC *arg1 = (wxDC *) 0 ;
14326 wxString *arg2 = 0 ;
14327 int arg3 ;
14328 int arg4 ;
14329 bool temp2 = false ;
14330 PyObject * obj0 = 0 ;
14331 PyObject * obj1 = 0 ;
14332 PyObject * obj2 = 0 ;
14333 PyObject * obj3 = 0 ;
14334 char *kwnames[] = {
14335 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14336 };
14337
14338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14340 if (SWIG_arg_fail(1)) SWIG_fail;
14341 {
14342 arg2 = wxString_in_helper(obj1);
14343 if (arg2 == NULL) SWIG_fail;
14344 temp2 = true;
14345 }
14346 {
14347 arg3 = (int)(SWIG_As_int(obj2));
14348 if (SWIG_arg_fail(3)) SWIG_fail;
14349 }
14350 {
14351 arg4 = (int)(SWIG_As_int(obj3));
14352 if (SWIG_arg_fail(4)) SWIG_fail;
14353 }
14354 {
14355 PyThreadState* __tstate = wxPyBeginAllowThreads();
14356 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14357
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 Py_INCREF(Py_None); resultobj = Py_None;
14362 {
14363 if (temp2)
14364 delete arg2;
14365 }
14366 return resultobj;
14367 fail:
14368 {
14369 if (temp2)
14370 delete arg2;
14371 }
14372 return NULL;
14373 }
14374
14375
14376 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14377 PyObject *resultobj;
14378 wxDC *arg1 = (wxDC *) 0 ;
14379 wxString *arg2 = 0 ;
14380 wxPoint *arg3 = 0 ;
14381 bool temp2 = false ;
14382 wxPoint temp3 ;
14383 PyObject * obj0 = 0 ;
14384 PyObject * obj1 = 0 ;
14385 PyObject * obj2 = 0 ;
14386 char *kwnames[] = {
14387 (char *) "self",(char *) "text",(char *) "pt", NULL
14388 };
14389
14390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14392 if (SWIG_arg_fail(1)) SWIG_fail;
14393 {
14394 arg2 = wxString_in_helper(obj1);
14395 if (arg2 == NULL) SWIG_fail;
14396 temp2 = true;
14397 }
14398 {
14399 arg3 = &temp3;
14400 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14401 }
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14405
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 Py_INCREF(Py_None); resultobj = Py_None;
14410 {
14411 if (temp2)
14412 delete arg2;
14413 }
14414 return resultobj;
14415 fail:
14416 {
14417 if (temp2)
14418 delete arg2;
14419 }
14420 return NULL;
14421 }
14422
14423
14424 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14425 PyObject *resultobj;
14426 wxDC *arg1 = (wxDC *) 0 ;
14427 wxString *arg2 = 0 ;
14428 int arg3 ;
14429 int arg4 ;
14430 double arg5 ;
14431 bool temp2 = false ;
14432 PyObject * obj0 = 0 ;
14433 PyObject * obj1 = 0 ;
14434 PyObject * obj2 = 0 ;
14435 PyObject * obj3 = 0 ;
14436 PyObject * obj4 = 0 ;
14437 char *kwnames[] = {
14438 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14439 };
14440
14441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14443 if (SWIG_arg_fail(1)) SWIG_fail;
14444 {
14445 arg2 = wxString_in_helper(obj1);
14446 if (arg2 == NULL) SWIG_fail;
14447 temp2 = true;
14448 }
14449 {
14450 arg3 = (int)(SWIG_As_int(obj2));
14451 if (SWIG_arg_fail(3)) SWIG_fail;
14452 }
14453 {
14454 arg4 = (int)(SWIG_As_int(obj3));
14455 if (SWIG_arg_fail(4)) SWIG_fail;
14456 }
14457 {
14458 arg5 = (double)(SWIG_As_double(obj4));
14459 if (SWIG_arg_fail(5)) SWIG_fail;
14460 }
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 Py_INCREF(Py_None); resultobj = Py_None;
14469 {
14470 if (temp2)
14471 delete arg2;
14472 }
14473 return resultobj;
14474 fail:
14475 {
14476 if (temp2)
14477 delete arg2;
14478 }
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxDC *arg1 = (wxDC *) 0 ;
14486 wxString *arg2 = 0 ;
14487 wxPoint *arg3 = 0 ;
14488 double arg4 ;
14489 bool temp2 = false ;
14490 wxPoint temp3 ;
14491 PyObject * obj0 = 0 ;
14492 PyObject * obj1 = 0 ;
14493 PyObject * obj2 = 0 ;
14494 PyObject * obj3 = 0 ;
14495 char *kwnames[] = {
14496 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14497 };
14498
14499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14501 if (SWIG_arg_fail(1)) SWIG_fail;
14502 {
14503 arg2 = wxString_in_helper(obj1);
14504 if (arg2 == NULL) SWIG_fail;
14505 temp2 = true;
14506 }
14507 {
14508 arg3 = &temp3;
14509 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14510 }
14511 {
14512 arg4 = (double)(SWIG_As_double(obj3));
14513 if (SWIG_arg_fail(4)) SWIG_fail;
14514 }
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14518
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 Py_INCREF(Py_None); resultobj = Py_None;
14523 {
14524 if (temp2)
14525 delete arg2;
14526 }
14527 return resultobj;
14528 fail:
14529 {
14530 if (temp2)
14531 delete arg2;
14532 }
14533 return NULL;
14534 }
14535
14536
14537 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj;
14539 wxDC *arg1 = (wxDC *) 0 ;
14540 int arg2 ;
14541 int arg3 ;
14542 int arg4 ;
14543 int arg5 ;
14544 wxDC *arg6 = (wxDC *) 0 ;
14545 int arg7 ;
14546 int arg8 ;
14547 int arg9 = (int) wxCOPY ;
14548 bool arg10 = (bool) false ;
14549 int arg11 = (int) -1 ;
14550 int arg12 = (int) -1 ;
14551 bool result;
14552 PyObject * obj0 = 0 ;
14553 PyObject * obj1 = 0 ;
14554 PyObject * obj2 = 0 ;
14555 PyObject * obj3 = 0 ;
14556 PyObject * obj4 = 0 ;
14557 PyObject * obj5 = 0 ;
14558 PyObject * obj6 = 0 ;
14559 PyObject * obj7 = 0 ;
14560 PyObject * obj8 = 0 ;
14561 PyObject * obj9 = 0 ;
14562 PyObject * obj10 = 0 ;
14563 PyObject * obj11 = 0 ;
14564 char *kwnames[] = {
14565 (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
14566 };
14567
14568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO|OOOO:DC_Blit",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) goto fail;
14569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14570 if (SWIG_arg_fail(1)) SWIG_fail;
14571 {
14572 arg2 = (int)(SWIG_As_int(obj1));
14573 if (SWIG_arg_fail(2)) SWIG_fail;
14574 }
14575 {
14576 arg3 = (int)(SWIG_As_int(obj2));
14577 if (SWIG_arg_fail(3)) SWIG_fail;
14578 }
14579 {
14580 arg4 = (int)(SWIG_As_int(obj3));
14581 if (SWIG_arg_fail(4)) SWIG_fail;
14582 }
14583 {
14584 arg5 = (int)(SWIG_As_int(obj4));
14585 if (SWIG_arg_fail(5)) SWIG_fail;
14586 }
14587 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14588 if (SWIG_arg_fail(6)) SWIG_fail;
14589 {
14590 arg7 = (int)(SWIG_As_int(obj6));
14591 if (SWIG_arg_fail(7)) SWIG_fail;
14592 }
14593 {
14594 arg8 = (int)(SWIG_As_int(obj7));
14595 if (SWIG_arg_fail(8)) SWIG_fail;
14596 }
14597 if (obj8) {
14598 {
14599 arg9 = (int)(SWIG_As_int(obj8));
14600 if (SWIG_arg_fail(9)) SWIG_fail;
14601 }
14602 }
14603 if (obj9) {
14604 {
14605 arg10 = (bool)(SWIG_As_bool(obj9));
14606 if (SWIG_arg_fail(10)) SWIG_fail;
14607 }
14608 }
14609 if (obj10) {
14610 {
14611 arg11 = (int)(SWIG_As_int(obj10));
14612 if (SWIG_arg_fail(11)) SWIG_fail;
14613 }
14614 }
14615 if (obj11) {
14616 {
14617 arg12 = (int)(SWIG_As_int(obj11));
14618 if (SWIG_arg_fail(12)) SWIG_fail;
14619 }
14620 }
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14624
14625 wxPyEndAllowThreads(__tstate);
14626 if (PyErr_Occurred()) SWIG_fail;
14627 }
14628 {
14629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14630 }
14631 return resultobj;
14632 fail:
14633 return NULL;
14634 }
14635
14636
14637 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14638 PyObject *resultobj;
14639 wxDC *arg1 = (wxDC *) 0 ;
14640 wxPoint *arg2 = 0 ;
14641 wxSize *arg3 = 0 ;
14642 wxDC *arg4 = (wxDC *) 0 ;
14643 wxPoint *arg5 = 0 ;
14644 int arg6 = (int) wxCOPY ;
14645 bool arg7 = (bool) false ;
14646 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14647 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14648 bool result;
14649 wxPoint temp2 ;
14650 wxSize temp3 ;
14651 wxPoint temp5 ;
14652 wxPoint temp8 ;
14653 PyObject * obj0 = 0 ;
14654 PyObject * obj1 = 0 ;
14655 PyObject * obj2 = 0 ;
14656 PyObject * obj3 = 0 ;
14657 PyObject * obj4 = 0 ;
14658 PyObject * obj5 = 0 ;
14659 PyObject * obj6 = 0 ;
14660 PyObject * obj7 = 0 ;
14661 char *kwnames[] = {
14662 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14663 };
14664
14665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14667 if (SWIG_arg_fail(1)) SWIG_fail;
14668 {
14669 arg2 = &temp2;
14670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14671 }
14672 {
14673 arg3 = &temp3;
14674 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14675 }
14676 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14677 if (SWIG_arg_fail(4)) SWIG_fail;
14678 {
14679 arg5 = &temp5;
14680 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14681 }
14682 if (obj5) {
14683 {
14684 arg6 = (int)(SWIG_As_int(obj5));
14685 if (SWIG_arg_fail(6)) SWIG_fail;
14686 }
14687 }
14688 if (obj6) {
14689 {
14690 arg7 = (bool)(SWIG_As_bool(obj6));
14691 if (SWIG_arg_fail(7)) SWIG_fail;
14692 }
14693 }
14694 if (obj7) {
14695 {
14696 arg8 = &temp8;
14697 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14698 }
14699 }
14700 {
14701 PyThreadState* __tstate = wxPyBeginAllowThreads();
14702 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14703
14704 wxPyEndAllowThreads(__tstate);
14705 if (PyErr_Occurred()) SWIG_fail;
14706 }
14707 {
14708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14709 }
14710 return resultobj;
14711 fail:
14712 return NULL;
14713 }
14714
14715
14716 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14717 PyObject *resultobj;
14718 wxDC *arg1 = (wxDC *) 0 ;
14719 int arg2 ;
14720 int arg3 ;
14721 int arg4 ;
14722 int arg5 ;
14723 PyObject * obj0 = 0 ;
14724 PyObject * obj1 = 0 ;
14725 PyObject * obj2 = 0 ;
14726 PyObject * obj3 = 0 ;
14727 PyObject * obj4 = 0 ;
14728 char *kwnames[] = {
14729 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14730 };
14731
14732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14734 if (SWIG_arg_fail(1)) SWIG_fail;
14735 {
14736 arg2 = (int)(SWIG_As_int(obj1));
14737 if (SWIG_arg_fail(2)) SWIG_fail;
14738 }
14739 {
14740 arg3 = (int)(SWIG_As_int(obj2));
14741 if (SWIG_arg_fail(3)) SWIG_fail;
14742 }
14743 {
14744 arg4 = (int)(SWIG_As_int(obj3));
14745 if (SWIG_arg_fail(4)) SWIG_fail;
14746 }
14747 {
14748 arg5 = (int)(SWIG_As_int(obj4));
14749 if (SWIG_arg_fail(5)) SWIG_fail;
14750 }
14751 {
14752 PyThreadState* __tstate = wxPyBeginAllowThreads();
14753 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14754
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 Py_INCREF(Py_None); resultobj = Py_None;
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj;
14767 wxDC *arg1 = (wxDC *) 0 ;
14768 wxPoint *arg2 = 0 ;
14769 wxSize *arg3 = 0 ;
14770 wxPoint temp2 ;
14771 wxSize temp3 ;
14772 PyObject * obj0 = 0 ;
14773 PyObject * obj1 = 0 ;
14774 PyObject * obj2 = 0 ;
14775 char *kwnames[] = {
14776 (char *) "self",(char *) "pt",(char *) "sz", NULL
14777 };
14778
14779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14781 if (SWIG_arg_fail(1)) SWIG_fail;
14782 {
14783 arg2 = &temp2;
14784 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14785 }
14786 {
14787 arg3 = &temp3;
14788 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14793
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 Py_INCREF(Py_None); resultobj = Py_None;
14798 return resultobj;
14799 fail:
14800 return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj;
14806 wxDC *arg1 = (wxDC *) 0 ;
14807 wxRegion *arg2 = 0 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 char *kwnames[] = {
14811 (char *) "self",(char *) "region", NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(1)) SWIG_fail;
14817 {
14818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(2)) SWIG_fail;
14820 if (arg2 == NULL) {
14821 SWIG_null_ref("wxRegion");
14822 }
14823 if (SWIG_arg_fail(2)) SWIG_fail;
14824 }
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14828
14829 wxPyEndAllowThreads(__tstate);
14830 if (PyErr_Occurred()) SWIG_fail;
14831 }
14832 Py_INCREF(Py_None); resultobj = Py_None;
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14840 PyObject *resultobj;
14841 wxDC *arg1 = (wxDC *) 0 ;
14842 wxRect *arg2 = 0 ;
14843 wxRect temp2 ;
14844 PyObject * obj0 = 0 ;
14845 PyObject * obj1 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self",(char *) "rect", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 arg2 = &temp2;
14855 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14856 }
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14860
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 Py_INCREF(Py_None); resultobj = Py_None;
14865 return resultobj;
14866 fail:
14867 return NULL;
14868 }
14869
14870
14871 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj;
14873 wxDC *arg1 = (wxDC *) 0 ;
14874 int arg2 ;
14875 wxPoint *arg3 = (wxPoint *) 0 ;
14876 int arg4 = (int) 0 ;
14877 int arg5 = (int) 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 PyObject * obj3 = 0 ;
14882 char *kwnames[] = {
14883 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14884 };
14885
14886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14888 if (SWIG_arg_fail(1)) SWIG_fail;
14889 {
14890 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14891 if (arg3 == NULL) SWIG_fail;
14892 }
14893 if (obj2) {
14894 {
14895 arg4 = (int)(SWIG_As_int(obj2));
14896 if (SWIG_arg_fail(4)) SWIG_fail;
14897 }
14898 }
14899 if (obj3) {
14900 {
14901 arg5 = (int)(SWIG_As_int(obj3));
14902 if (SWIG_arg_fail(5)) SWIG_fail;
14903 }
14904 }
14905 {
14906 PyThreadState* __tstate = wxPyBeginAllowThreads();
14907 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14908
14909 wxPyEndAllowThreads(__tstate);
14910 if (PyErr_Occurred()) SWIG_fail;
14911 }
14912 Py_INCREF(Py_None); resultobj = Py_None;
14913 {
14914 if (arg3) delete [] arg3;
14915 }
14916 return resultobj;
14917 fail:
14918 {
14919 if (arg3) delete [] arg3;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxDC *arg1 = (wxDC *) 0 ;
14928 int arg2 ;
14929 wxPoint *arg3 = (wxPoint *) 0 ;
14930 int arg4 = (int) 0 ;
14931 int arg5 = (int) 0 ;
14932 int arg6 = (int) wxODDEVEN_RULE ;
14933 PyObject * obj0 = 0 ;
14934 PyObject * obj1 = 0 ;
14935 PyObject * obj2 = 0 ;
14936 PyObject * obj3 = 0 ;
14937 PyObject * obj4 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14947 if (arg3 == NULL) SWIG_fail;
14948 }
14949 if (obj2) {
14950 {
14951 arg4 = (int)(SWIG_As_int(obj2));
14952 if (SWIG_arg_fail(4)) SWIG_fail;
14953 }
14954 }
14955 if (obj3) {
14956 {
14957 arg5 = (int)(SWIG_As_int(obj3));
14958 if (SWIG_arg_fail(5)) SWIG_fail;
14959 }
14960 }
14961 if (obj4) {
14962 {
14963 arg6 = (int)(SWIG_As_int(obj4));
14964 if (SWIG_arg_fail(6)) SWIG_fail;
14965 }
14966 }
14967 {
14968 PyThreadState* __tstate = wxPyBeginAllowThreads();
14969 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14970
14971 wxPyEndAllowThreads(__tstate);
14972 if (PyErr_Occurred()) SWIG_fail;
14973 }
14974 Py_INCREF(Py_None); resultobj = Py_None;
14975 {
14976 if (arg3) delete [] arg3;
14977 }
14978 return resultobj;
14979 fail:
14980 {
14981 if (arg3) delete [] arg3;
14982 }
14983 return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxDC *arg1 = (wxDC *) 0 ;
14990 wxString *arg2 = 0 ;
14991 wxRect *arg3 = 0 ;
14992 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14993 int arg5 = (int) -1 ;
14994 bool temp2 = false ;
14995 wxRect temp3 ;
14996 PyObject * obj0 = 0 ;
14997 PyObject * obj1 = 0 ;
14998 PyObject * obj2 = 0 ;
14999 PyObject * obj3 = 0 ;
15000 PyObject * obj4 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 arg2 = wxString_in_helper(obj1);
15010 if (arg2 == NULL) SWIG_fail;
15011 temp2 = true;
15012 }
15013 {
15014 arg3 = &temp3;
15015 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
15016 }
15017 if (obj3) {
15018 {
15019 arg4 = (int)(SWIG_As_int(obj3));
15020 if (SWIG_arg_fail(4)) SWIG_fail;
15021 }
15022 }
15023 if (obj4) {
15024 {
15025 arg5 = (int)(SWIG_As_int(obj4));
15026 if (SWIG_arg_fail(5)) SWIG_fail;
15027 }
15028 }
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
15032
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 Py_INCREF(Py_None); resultobj = Py_None;
15037 {
15038 if (temp2)
15039 delete arg2;
15040 }
15041 return resultobj;
15042 fail:
15043 {
15044 if (temp2)
15045 delete arg2;
15046 }
15047 return NULL;
15048 }
15049
15050
15051 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15052 PyObject *resultobj;
15053 wxDC *arg1 = (wxDC *) 0 ;
15054 wxString *arg2 = 0 ;
15055 wxBitmap *arg3 = 0 ;
15056 wxRect *arg4 = 0 ;
15057 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15058 int arg6 = (int) -1 ;
15059 wxRect result;
15060 bool temp2 = false ;
15061 wxRect temp4 ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 PyObject * obj2 = 0 ;
15065 PyObject * obj3 = 0 ;
15066 PyObject * obj4 = 0 ;
15067 PyObject * obj5 = 0 ;
15068 char *kwnames[] = {
15069 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15070 };
15071
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15074 if (SWIG_arg_fail(1)) SWIG_fail;
15075 {
15076 arg2 = wxString_in_helper(obj1);
15077 if (arg2 == NULL) SWIG_fail;
15078 temp2 = true;
15079 }
15080 {
15081 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15082 if (SWIG_arg_fail(3)) SWIG_fail;
15083 if (arg3 == NULL) {
15084 SWIG_null_ref("wxBitmap");
15085 }
15086 if (SWIG_arg_fail(3)) SWIG_fail;
15087 }
15088 {
15089 arg4 = &temp4;
15090 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15091 }
15092 if (obj4) {
15093 {
15094 arg5 = (int)(SWIG_As_int(obj4));
15095 if (SWIG_arg_fail(5)) SWIG_fail;
15096 }
15097 }
15098 if (obj5) {
15099 {
15100 arg6 = (int)(SWIG_As_int(obj5));
15101 if (SWIG_arg_fail(6)) SWIG_fail;
15102 }
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15107
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 {
15112 wxRect * resultptr;
15113 resultptr = new wxRect((wxRect &)(result));
15114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15115 }
15116 {
15117 if (temp2)
15118 delete arg2;
15119 }
15120 return resultobj;
15121 fail:
15122 {
15123 if (temp2)
15124 delete arg2;
15125 }
15126 return NULL;
15127 }
15128
15129
15130 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15131 PyObject *resultobj;
15132 wxDC *arg1 = (wxDC *) 0 ;
15133 int arg2 ;
15134 wxPoint *arg3 = (wxPoint *) 0 ;
15135 PyObject * obj0 = 0 ;
15136 PyObject * obj1 = 0 ;
15137 char *kwnames[] = {
15138 (char *) "self",(char *) "points", NULL
15139 };
15140
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 {
15145 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15146 if (arg3 == NULL) SWIG_fail;
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 (arg1)->DrawSpline(arg2,arg3);
15151
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 Py_INCREF(Py_None); resultobj = Py_None;
15156 {
15157 if (arg3) delete [] arg3;
15158 }
15159 return resultobj;
15160 fail:
15161 {
15162 if (arg3) delete [] arg3;
15163 }
15164 return NULL;
15165 }
15166
15167
15168 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15169 PyObject *resultobj;
15170 wxDC *arg1 = (wxDC *) 0 ;
15171 PyObject * obj0 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 (arg1)->Clear();
15182
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 Py_INCREF(Py_None); resultobj = Py_None;
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj;
15195 wxDC *arg1 = (wxDC *) 0 ;
15196 wxString *arg2 = 0 ;
15197 bool result;
15198 bool temp2 = false ;
15199 PyObject * obj0 = 0 ;
15200 PyObject * obj1 = 0 ;
15201 char *kwnames[] = {
15202 (char *) "self",(char *) "message", NULL
15203 };
15204
15205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15207 if (SWIG_arg_fail(1)) SWIG_fail;
15208 {
15209 arg2 = wxString_in_helper(obj1);
15210 if (arg2 == NULL) SWIG_fail;
15211 temp2 = true;
15212 }
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15216
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 {
15221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15222 }
15223 {
15224 if (temp2)
15225 delete arg2;
15226 }
15227 return resultobj;
15228 fail:
15229 {
15230 if (temp2)
15231 delete arg2;
15232 }
15233 return NULL;
15234 }
15235
15236
15237 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15238 PyObject *resultobj;
15239 wxDC *arg1 = (wxDC *) 0 ;
15240 PyObject * obj0 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "self", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15247 if (SWIG_arg_fail(1)) SWIG_fail;
15248 {
15249 PyThreadState* __tstate = wxPyBeginAllowThreads();
15250 (arg1)->EndDoc();
15251
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 Py_INCREF(Py_None); resultobj = Py_None;
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj;
15264 wxDC *arg1 = (wxDC *) 0 ;
15265 PyObject * obj0 = 0 ;
15266 char *kwnames[] = {
15267 (char *) "self", NULL
15268 };
15269
15270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15272 if (SWIG_arg_fail(1)) SWIG_fail;
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 (arg1)->StartPage();
15276
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 Py_INCREF(Py_None); resultobj = Py_None;
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15288 PyObject *resultobj;
15289 wxDC *arg1 = (wxDC *) 0 ;
15290 PyObject * obj0 = 0 ;
15291 char *kwnames[] = {
15292 (char *) "self", NULL
15293 };
15294
15295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15297 if (SWIG_arg_fail(1)) SWIG_fail;
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 (arg1)->EndPage();
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 Py_INCREF(Py_None); resultobj = Py_None;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj;
15314 wxDC *arg1 = (wxDC *) 0 ;
15315 wxFont *arg2 = 0 ;
15316 PyObject * obj0 = 0 ;
15317 PyObject * obj1 = 0 ;
15318 char *kwnames[] = {
15319 (char *) "self",(char *) "font", NULL
15320 };
15321
15322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15324 if (SWIG_arg_fail(1)) SWIG_fail;
15325 {
15326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15327 if (SWIG_arg_fail(2)) SWIG_fail;
15328 if (arg2 == NULL) {
15329 SWIG_null_ref("wxFont");
15330 }
15331 if (SWIG_arg_fail(2)) SWIG_fail;
15332 }
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 (arg1)->SetFont((wxFont const &)*arg2);
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 Py_INCREF(Py_None); resultobj = Py_None;
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxDC *arg1 = (wxDC *) 0 ;
15350 wxPen *arg2 = 0 ;
15351 PyObject * obj0 = 0 ;
15352 PyObject * obj1 = 0 ;
15353 char *kwnames[] = {
15354 (char *) "self",(char *) "pen", NULL
15355 };
15356
15357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15359 if (SWIG_arg_fail(1)) SWIG_fail;
15360 {
15361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(2)) SWIG_fail;
15363 if (arg2 == NULL) {
15364 SWIG_null_ref("wxPen");
15365 }
15366 if (SWIG_arg_fail(2)) SWIG_fail;
15367 }
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 (arg1)->SetPen((wxPen const &)*arg2);
15371
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 Py_INCREF(Py_None); resultobj = Py_None;
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj;
15384 wxDC *arg1 = (wxDC *) 0 ;
15385 wxBrush *arg2 = 0 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "self",(char *) "brush", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 {
15396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15397 if (SWIG_arg_fail(2)) SWIG_fail;
15398 if (arg2 == NULL) {
15399 SWIG_null_ref("wxBrush");
15400 }
15401 if (SWIG_arg_fail(2)) SWIG_fail;
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 (arg1)->SetBrush((wxBrush const &)*arg2);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 Py_INCREF(Py_None); resultobj = Py_None;
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxDC *arg1 = (wxDC *) 0 ;
15420 wxBrush *arg2 = 0 ;
15421 PyObject * obj0 = 0 ;
15422 PyObject * obj1 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self",(char *) "brush", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15429 if (SWIG_arg_fail(1)) SWIG_fail;
15430 {
15431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(2)) SWIG_fail;
15433 if (arg2 == NULL) {
15434 SWIG_null_ref("wxBrush");
15435 }
15436 if (SWIG_arg_fail(2)) SWIG_fail;
15437 }
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 (arg1)->SetBackground((wxBrush const &)*arg2);
15441
15442 wxPyEndAllowThreads(__tstate);
15443 if (PyErr_Occurred()) SWIG_fail;
15444 }
15445 Py_INCREF(Py_None); resultobj = Py_None;
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15453 PyObject *resultobj;
15454 wxDC *arg1 = (wxDC *) 0 ;
15455 int arg2 ;
15456 PyObject * obj0 = 0 ;
15457 PyObject * obj1 = 0 ;
15458 char *kwnames[] = {
15459 (char *) "self",(char *) "mode", NULL
15460 };
15461
15462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15464 if (SWIG_arg_fail(1)) SWIG_fail;
15465 {
15466 arg2 = (int)(SWIG_As_int(obj1));
15467 if (SWIG_arg_fail(2)) SWIG_fail;
15468 }
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 (arg1)->SetBackgroundMode(arg2);
15472
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 Py_INCREF(Py_None); resultobj = Py_None;
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15484 PyObject *resultobj;
15485 wxDC *arg1 = (wxDC *) 0 ;
15486 wxPalette *arg2 = 0 ;
15487 PyObject * obj0 = 0 ;
15488 PyObject * obj1 = 0 ;
15489 char *kwnames[] = {
15490 (char *) "self",(char *) "palette", NULL
15491 };
15492
15493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15495 if (SWIG_arg_fail(1)) SWIG_fail;
15496 {
15497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15498 if (SWIG_arg_fail(2)) SWIG_fail;
15499 if (arg2 == NULL) {
15500 SWIG_null_ref("wxPalette");
15501 }
15502 if (SWIG_arg_fail(2)) SWIG_fail;
15503 }
15504 {
15505 PyThreadState* __tstate = wxPyBeginAllowThreads();
15506 (arg1)->SetPalette((wxPalette const &)*arg2);
15507
15508 wxPyEndAllowThreads(__tstate);
15509 if (PyErr_Occurred()) SWIG_fail;
15510 }
15511 Py_INCREF(Py_None); resultobj = Py_None;
15512 return resultobj;
15513 fail:
15514 return NULL;
15515 }
15516
15517
15518 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj;
15520 wxDC *arg1 = (wxDC *) 0 ;
15521 PyObject * obj0 = 0 ;
15522 char *kwnames[] = {
15523 (char *) "self", NULL
15524 };
15525
15526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15528 if (SWIG_arg_fail(1)) SWIG_fail;
15529 {
15530 PyThreadState* __tstate = wxPyBeginAllowThreads();
15531 (arg1)->DestroyClippingRegion();
15532
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 Py_INCREF(Py_None); resultobj = Py_None;
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj;
15545 wxDC *arg1 = (wxDC *) 0 ;
15546 int *arg2 = (int *) 0 ;
15547 int *arg3 = (int *) 0 ;
15548 int *arg4 = (int *) 0 ;
15549 int *arg5 = (int *) 0 ;
15550 int temp2 ;
15551 int res2 = 0 ;
15552 int temp3 ;
15553 int res3 = 0 ;
15554 int temp4 ;
15555 int res4 = 0 ;
15556 int temp5 ;
15557 int res5 = 0 ;
15558 PyObject * obj0 = 0 ;
15559 char *kwnames[] = {
15560 (char *) "self", NULL
15561 };
15562
15563 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15564 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15565 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15566 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 {
15571 PyThreadState* __tstate = wxPyBeginAllowThreads();
15572 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15573
15574 wxPyEndAllowThreads(__tstate);
15575 if (PyErr_Occurred()) SWIG_fail;
15576 }
15577 Py_INCREF(Py_None); resultobj = Py_None;
15578 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15579 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15580 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15581 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15582 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15583 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15584 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15585 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15593 PyObject *resultobj;
15594 wxDC *arg1 = (wxDC *) 0 ;
15595 wxRect result;
15596 PyObject * obj0 = 0 ;
15597 char *kwnames[] = {
15598 (char *) "self", NULL
15599 };
15600
15601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15603 if (SWIG_arg_fail(1)) SWIG_fail;
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = wxDC_GetClippingRect(arg1);
15607
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 {
15612 wxRect * resultptr;
15613 resultptr = new wxRect((wxRect &)(result));
15614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15615 }
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15623 PyObject *resultobj;
15624 wxDC *arg1 = (wxDC *) 0 ;
15625 int result;
15626 PyObject * obj0 = 0 ;
15627 char *kwnames[] = {
15628 (char *) "self", NULL
15629 };
15630
15631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15633 if (SWIG_arg_fail(1)) SWIG_fail;
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)((wxDC const *)arg1)->GetCharHeight();
15637
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = SWIG_From_int((int)(result));
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15651 PyObject *resultobj;
15652 wxDC *arg1 = (wxDC *) 0 ;
15653 int result;
15654 PyObject * obj0 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (int)((wxDC const *)arg1)->GetCharWidth();
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = SWIG_From_int((int)(result));
15671 }
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj;
15680 wxDC *arg1 = (wxDC *) 0 ;
15681 wxString *arg2 = 0 ;
15682 int *arg3 = (int *) 0 ;
15683 int *arg4 = (int *) 0 ;
15684 bool temp2 = false ;
15685 int temp3 ;
15686 int res3 = 0 ;
15687 int temp4 ;
15688 int res4 = 0 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char *kwnames[] = {
15692 (char *) "self",(char *) "string", NULL
15693 };
15694
15695 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15696 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15699 if (SWIG_arg_fail(1)) SWIG_fail;
15700 {
15701 arg2 = wxString_in_helper(obj1);
15702 if (arg2 == NULL) SWIG_fail;
15703 temp2 = true;
15704 }
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15708
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 Py_INCREF(Py_None); resultobj = Py_None;
15713 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15714 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15715 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15716 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15717 {
15718 if (temp2)
15719 delete arg2;
15720 }
15721 return resultobj;
15722 fail:
15723 {
15724 if (temp2)
15725 delete arg2;
15726 }
15727 return NULL;
15728 }
15729
15730
15731 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15732 PyObject *resultobj;
15733 wxDC *arg1 = (wxDC *) 0 ;
15734 wxString *arg2 = 0 ;
15735 int *arg3 = (int *) 0 ;
15736 int *arg4 = (int *) 0 ;
15737 int *arg5 = (int *) 0 ;
15738 int *arg6 = (int *) 0 ;
15739 wxFont *arg7 = (wxFont *) NULL ;
15740 bool temp2 = false ;
15741 int temp3 ;
15742 int res3 = 0 ;
15743 int temp4 ;
15744 int res4 = 0 ;
15745 int temp5 ;
15746 int res5 = 0 ;
15747 int temp6 ;
15748 int res6 = 0 ;
15749 PyObject * obj0 = 0 ;
15750 PyObject * obj1 = 0 ;
15751 PyObject * obj2 = 0 ;
15752 char *kwnames[] = {
15753 (char *) "self",(char *) "string",(char *) "font", NULL
15754 };
15755
15756 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15757 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15758 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15759 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15762 if (SWIG_arg_fail(1)) SWIG_fail;
15763 {
15764 arg2 = wxString_in_helper(obj1);
15765 if (arg2 == NULL) SWIG_fail;
15766 temp2 = true;
15767 }
15768 if (obj2) {
15769 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15770 if (SWIG_arg_fail(7)) SWIG_fail;
15771 }
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15775
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 Py_INCREF(Py_None); resultobj = Py_None;
15780 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15781 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15782 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15783 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15784 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15785 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15786 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15787 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15788 {
15789 if (temp2)
15790 delete arg2;
15791 }
15792 return resultobj;
15793 fail:
15794 {
15795 if (temp2)
15796 delete arg2;
15797 }
15798 return NULL;
15799 }
15800
15801
15802 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15803 PyObject *resultobj;
15804 wxDC *arg1 = (wxDC *) 0 ;
15805 wxString *arg2 = 0 ;
15806 int *arg3 = (int *) 0 ;
15807 int *arg4 = (int *) 0 ;
15808 int *arg5 = (int *) 0 ;
15809 wxFont *arg6 = (wxFont *) NULL ;
15810 bool temp2 = false ;
15811 int temp3 ;
15812 int res3 = 0 ;
15813 int temp4 ;
15814 int res4 = 0 ;
15815 int temp5 ;
15816 int res5 = 0 ;
15817 PyObject * obj0 = 0 ;
15818 PyObject * obj1 = 0 ;
15819 PyObject * obj2 = 0 ;
15820 char *kwnames[] = {
15821 (char *) "self",(char *) "text",(char *) "font", NULL
15822 };
15823
15824 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15825 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15826 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15829 if (SWIG_arg_fail(1)) SWIG_fail;
15830 {
15831 arg2 = wxString_in_helper(obj1);
15832 if (arg2 == NULL) SWIG_fail;
15833 temp2 = true;
15834 }
15835 if (obj2) {
15836 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15837 if (SWIG_arg_fail(6)) SWIG_fail;
15838 }
15839 {
15840 PyThreadState* __tstate = wxPyBeginAllowThreads();
15841 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15842
15843 wxPyEndAllowThreads(__tstate);
15844 if (PyErr_Occurred()) SWIG_fail;
15845 }
15846 Py_INCREF(Py_None); resultobj = Py_None;
15847 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15848 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15849 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15850 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15851 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15852 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15853 {
15854 if (temp2)
15855 delete arg2;
15856 }
15857 return resultobj;
15858 fail:
15859 {
15860 if (temp2)
15861 delete arg2;
15862 }
15863 return NULL;
15864 }
15865
15866
15867 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj;
15869 wxDC *arg1 = (wxDC *) 0 ;
15870 wxString *arg2 = 0 ;
15871 wxArrayInt result;
15872 bool temp2 = false ;
15873 PyObject * obj0 = 0 ;
15874 PyObject * obj1 = 0 ;
15875 char *kwnames[] = {
15876 (char *) "self",(char *) "text", NULL
15877 };
15878
15879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15881 if (SWIG_arg_fail(1)) SWIG_fail;
15882 {
15883 arg2 = wxString_in_helper(obj1);
15884 if (arg2 == NULL) SWIG_fail;
15885 temp2 = true;
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15890
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 {
15895 resultobj = PyList_New(0);
15896 size_t idx;
15897 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15898 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15899 PyList_Append(resultobj, val);
15900 Py_DECREF(val);
15901 }
15902 }
15903 {
15904 if (temp2)
15905 delete arg2;
15906 }
15907 return resultobj;
15908 fail:
15909 {
15910 if (temp2)
15911 delete arg2;
15912 }
15913 return NULL;
15914 }
15915
15916
15917 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15918 PyObject *resultobj;
15919 wxDC *arg1 = (wxDC *) 0 ;
15920 wxSize result;
15921 PyObject * obj0 = 0 ;
15922 char *kwnames[] = {
15923 (char *) "self", NULL
15924 };
15925
15926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15928 if (SWIG_arg_fail(1)) SWIG_fail;
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (arg1)->GetSize();
15932
15933 wxPyEndAllowThreads(__tstate);
15934 if (PyErr_Occurred()) SWIG_fail;
15935 }
15936 {
15937 wxSize * resultptr;
15938 resultptr = new wxSize((wxSize &)(result));
15939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15940 }
15941 return resultobj;
15942 fail:
15943 return NULL;
15944 }
15945
15946
15947 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxDC *arg1 = (wxDC *) 0 ;
15950 int *arg2 = (int *) 0 ;
15951 int *arg3 = (int *) 0 ;
15952 int temp2 ;
15953 int res2 = 0 ;
15954 int temp3 ;
15955 int res3 = 0 ;
15956 PyObject * obj0 = 0 ;
15957 char *kwnames[] = {
15958 (char *) "self", NULL
15959 };
15960
15961 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15962 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15965 if (SWIG_arg_fail(1)) SWIG_fail;
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 (arg1)->GetSize(arg2,arg3);
15969
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 Py_INCREF(Py_None); resultobj = Py_None;
15974 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15975 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15976 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15977 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15978 return resultobj;
15979 fail:
15980 return NULL;
15981 }
15982
15983
15984 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15985 PyObject *resultobj;
15986 wxDC *arg1 = (wxDC *) 0 ;
15987 wxSize result;
15988 PyObject * obj0 = 0 ;
15989 char *kwnames[] = {
15990 (char *) "self", NULL
15991 };
15992
15993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15995 if (SWIG_arg_fail(1)) SWIG_fail;
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = ((wxDC const *)arg1)->GetSizeMM();
15999
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 {
16004 wxSize * resultptr;
16005 resultptr = new wxSize((wxSize &)(result));
16006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16007 }
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16015 PyObject *resultobj;
16016 wxDC *arg1 = (wxDC *) 0 ;
16017 int *arg2 = (int *) 0 ;
16018 int *arg3 = (int *) 0 ;
16019 int temp2 ;
16020 int res2 = 0 ;
16021 int temp3 ;
16022 int res3 = 0 ;
16023 PyObject * obj0 = 0 ;
16024 char *kwnames[] = {
16025 (char *) "self", NULL
16026 };
16027
16028 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16029 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
16031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16032 if (SWIG_arg_fail(1)) SWIG_fail;
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16036
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 Py_INCREF(Py_None); resultobj = Py_None;
16041 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16042 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16043 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16044 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj;
16053 wxDC *arg1 = (wxDC *) 0 ;
16054 int arg2 ;
16055 int result;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 char *kwnames[] = {
16059 (char *) "self",(char *) "x", NULL
16060 };
16061
16062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16064 if (SWIG_arg_fail(1)) SWIG_fail;
16065 {
16066 arg2 = (int)(SWIG_As_int(obj1));
16067 if (SWIG_arg_fail(2)) SWIG_fail;
16068 }
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 {
16077 resultobj = SWIG_From_int((int)(result));
16078 }
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj;
16087 wxDC *arg1 = (wxDC *) 0 ;
16088 int arg2 ;
16089 int result;
16090 PyObject * obj0 = 0 ;
16091 PyObject * obj1 = 0 ;
16092 char *kwnames[] = {
16093 (char *) "self",(char *) "y", NULL
16094 };
16095
16096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16098 if (SWIG_arg_fail(1)) SWIG_fail;
16099 {
16100 arg2 = (int)(SWIG_As_int(obj1));
16101 if (SWIG_arg_fail(2)) SWIG_fail;
16102 }
16103 {
16104 PyThreadState* __tstate = wxPyBeginAllowThreads();
16105 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16106
16107 wxPyEndAllowThreads(__tstate);
16108 if (PyErr_Occurred()) SWIG_fail;
16109 }
16110 {
16111 resultobj = SWIG_From_int((int)(result));
16112 }
16113 return resultobj;
16114 fail:
16115 return NULL;
16116 }
16117
16118
16119 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16120 PyObject *resultobj;
16121 wxDC *arg1 = (wxDC *) 0 ;
16122 int arg2 ;
16123 int result;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 char *kwnames[] = {
16127 (char *) "self",(char *) "x", NULL
16128 };
16129
16130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16132 if (SWIG_arg_fail(1)) SWIG_fail;
16133 {
16134 arg2 = (int)(SWIG_As_int(obj1));
16135 if (SWIG_arg_fail(2)) SWIG_fail;
16136 }
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16140
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 {
16145 resultobj = SWIG_From_int((int)(result));
16146 }
16147 return resultobj;
16148 fail:
16149 return NULL;
16150 }
16151
16152
16153 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16154 PyObject *resultobj;
16155 wxDC *arg1 = (wxDC *) 0 ;
16156 int arg2 ;
16157 int result;
16158 PyObject * obj0 = 0 ;
16159 PyObject * obj1 = 0 ;
16160 char *kwnames[] = {
16161 (char *) "self",(char *) "y", NULL
16162 };
16163
16164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16166 if (SWIG_arg_fail(1)) SWIG_fail;
16167 {
16168 arg2 = (int)(SWIG_As_int(obj1));
16169 if (SWIG_arg_fail(2)) SWIG_fail;
16170 }
16171 {
16172 PyThreadState* __tstate = wxPyBeginAllowThreads();
16173 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16174
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 {
16179 resultobj = SWIG_From_int((int)(result));
16180 }
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 int arg2 ;
16191 int result;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self",(char *) "x", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 arg2 = (int)(SWIG_As_int(obj1));
16203 if (SWIG_arg_fail(2)) SWIG_fail;
16204 }
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16208
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 {
16213 resultobj = SWIG_From_int((int)(result));
16214 }
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj;
16223 wxDC *arg1 = (wxDC *) 0 ;
16224 int arg2 ;
16225 int result;
16226 PyObject * obj0 = 0 ;
16227 PyObject * obj1 = 0 ;
16228 char *kwnames[] = {
16229 (char *) "self",(char *) "y", NULL
16230 };
16231
16232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 {
16236 arg2 = (int)(SWIG_As_int(obj1));
16237 if (SWIG_arg_fail(2)) SWIG_fail;
16238 }
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = SWIG_From_int((int)(result));
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxDC *arg1 = (wxDC *) 0 ;
16258 int arg2 ;
16259 int result;
16260 PyObject * obj0 = 0 ;
16261 PyObject * obj1 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self",(char *) "x", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 arg2 = (int)(SWIG_As_int(obj1));
16271 if (SWIG_arg_fail(2)) SWIG_fail;
16272 }
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = SWIG_From_int((int)(result));
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxDC *arg1 = (wxDC *) 0 ;
16292 int arg2 ;
16293 int result;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 char *kwnames[] = {
16297 (char *) "self",(char *) "y", NULL
16298 };
16299
16300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16302 if (SWIG_arg_fail(1)) SWIG_fail;
16303 {
16304 arg2 = (int)(SWIG_As_int(obj1));
16305 if (SWIG_arg_fail(2)) SWIG_fail;
16306 }
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16310
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 resultobj = SWIG_From_int((int)(result));
16316 }
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj;
16325 wxDC *arg1 = (wxDC *) 0 ;
16326 bool result;
16327 PyObject * obj0 = 0 ;
16328 char *kwnames[] = {
16329 (char *) "self", NULL
16330 };
16331
16332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16334 if (SWIG_arg_fail(1)) SWIG_fail;
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16338
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj;
16353 wxDC *arg1 = (wxDC *) 0 ;
16354 bool result;
16355 PyObject * obj0 = 0 ;
16356 char *kwnames[] = {
16357 (char *) "self", NULL
16358 };
16359
16360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16362 if (SWIG_arg_fail(1)) SWIG_fail;
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16366
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16372 }
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxDC *arg1 = (wxDC *) 0 ;
16382 int result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = (int)((wxDC const *)arg1)->GetDepth();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 resultobj = SWIG_From_int((int)(result));
16400 }
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxDC *arg1 = (wxDC *) 0 ;
16410 wxSize result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = ((wxDC const *)arg1)->GetPPI();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 wxSize * resultptr;
16428 resultptr = new wxSize((wxSize &)(result));
16429 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16430 }
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj;
16439 wxDC *arg1 = (wxDC *) 0 ;
16440 bool result;
16441 PyObject * obj0 = 0 ;
16442 char *kwnames[] = {
16443 (char *) "self", NULL
16444 };
16445
16446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16448 if (SWIG_arg_fail(1)) SWIG_fail;
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = (bool)((wxDC const *)arg1)->Ok();
16452
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 {
16457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16458 }
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxDC *arg1 = (wxDC *) 0 ;
16468 int result;
16469 PyObject * obj0 = 0 ;
16470 char *kwnames[] = {
16471 (char *) "self", NULL
16472 };
16473
16474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16476 if (SWIG_arg_fail(1)) SWIG_fail;
16477 {
16478 PyThreadState* __tstate = wxPyBeginAllowThreads();
16479 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16480
16481 wxPyEndAllowThreads(__tstate);
16482 if (PyErr_Occurred()) SWIG_fail;
16483 }
16484 {
16485 resultobj = SWIG_From_int((int)(result));
16486 }
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16494 PyObject *resultobj;
16495 wxDC *arg1 = (wxDC *) 0 ;
16496 wxBrush *result;
16497 PyObject * obj0 = 0 ;
16498 char *kwnames[] = {
16499 (char *) "self", NULL
16500 };
16501
16502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16504 if (SWIG_arg_fail(1)) SWIG_fail;
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 {
16508 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16509 result = (wxBrush *) &_result_ref;
16510 }
16511
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 wxBrush* resultptr = new wxBrush(*result);
16517 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj;
16527 wxDC *arg1 = (wxDC *) 0 ;
16528 wxBrush *result;
16529 PyObject * obj0 = 0 ;
16530 char *kwnames[] = {
16531 (char *) "self", NULL
16532 };
16533
16534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16536 if (SWIG_arg_fail(1)) SWIG_fail;
16537 {
16538 PyThreadState* __tstate = wxPyBeginAllowThreads();
16539 {
16540 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16541 result = (wxBrush *) &_result_ref;
16542 }
16543
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 {
16548 wxBrush* resultptr = new wxBrush(*result);
16549 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16550 }
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj;
16559 wxDC *arg1 = (wxDC *) 0 ;
16560 wxFont *result;
16561 PyObject * obj0 = 0 ;
16562 char *kwnames[] = {
16563 (char *) "self", NULL
16564 };
16565
16566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16568 if (SWIG_arg_fail(1)) SWIG_fail;
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 {
16572 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16573 result = (wxFont *) &_result_ref;
16574 }
16575
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 {
16580 wxFont* resultptr = new wxFont(*result);
16581 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16582 }
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj;
16591 wxDC *arg1 = (wxDC *) 0 ;
16592 wxPen *result;
16593 PyObject * obj0 = 0 ;
16594 char *kwnames[] = {
16595 (char *) "self", NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16600 if (SWIG_arg_fail(1)) SWIG_fail;
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 {
16604 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16605 result = (wxPen *) &_result_ref;
16606 }
16607
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 {
16612 wxPen* resultptr = new wxPen(*result);
16613 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16614 }
16615 return resultobj;
16616 fail:
16617 return NULL;
16618 }
16619
16620
16621 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj;
16623 wxDC *arg1 = (wxDC *) 0 ;
16624 wxColour *result;
16625 PyObject * obj0 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "self", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16632 if (SWIG_arg_fail(1)) SWIG_fail;
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 {
16636 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16637 result = (wxColour *) &_result_ref;
16638 }
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxDC *arg1 = (wxDC *) 0 ;
16653 wxColour *result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "self", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 {
16665 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16666 result = (wxColour *) &_result_ref;
16667 }
16668
16669 wxPyEndAllowThreads(__tstate);
16670 if (PyErr_Occurred()) SWIG_fail;
16671 }
16672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16680 PyObject *resultobj;
16681 wxDC *arg1 = (wxDC *) 0 ;
16682 wxColour *arg2 = 0 ;
16683 wxColour temp2 ;
16684 PyObject * obj0 = 0 ;
16685 PyObject * obj1 = 0 ;
16686 char *kwnames[] = {
16687 (char *) "self",(char *) "colour", NULL
16688 };
16689
16690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16692 if (SWIG_arg_fail(1)) SWIG_fail;
16693 {
16694 arg2 = &temp2;
16695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16696 }
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 (arg1)->SetTextForeground((wxColour const &)*arg2);
16700
16701 wxPyEndAllowThreads(__tstate);
16702 if (PyErr_Occurred()) SWIG_fail;
16703 }
16704 Py_INCREF(Py_None); resultobj = Py_None;
16705 return resultobj;
16706 fail:
16707 return NULL;
16708 }
16709
16710
16711 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16712 PyObject *resultobj;
16713 wxDC *arg1 = (wxDC *) 0 ;
16714 wxColour *arg2 = 0 ;
16715 wxColour temp2 ;
16716 PyObject * obj0 = 0 ;
16717 PyObject * obj1 = 0 ;
16718 char *kwnames[] = {
16719 (char *) "self",(char *) "colour", NULL
16720 };
16721
16722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16724 if (SWIG_arg_fail(1)) SWIG_fail;
16725 {
16726 arg2 = &temp2;
16727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16728 }
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 (arg1)->SetTextBackground((wxColour const &)*arg2);
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 Py_INCREF(Py_None); resultobj = Py_None;
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxDC *arg1 = (wxDC *) 0 ;
16746 int result;
16747 PyObject * obj0 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "self", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16754 if (SWIG_arg_fail(1)) SWIG_fail;
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = (int)((wxDC const *)arg1)->GetMapMode();
16758
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 {
16763 resultobj = SWIG_From_int((int)(result));
16764 }
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj;
16773 wxDC *arg1 = (wxDC *) 0 ;
16774 int arg2 ;
16775 PyObject * obj0 = 0 ;
16776 PyObject * obj1 = 0 ;
16777 char *kwnames[] = {
16778 (char *) "self",(char *) "mode", NULL
16779 };
16780
16781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16783 if (SWIG_arg_fail(1)) SWIG_fail;
16784 {
16785 arg2 = (int)(SWIG_As_int(obj1));
16786 if (SWIG_arg_fail(2)) SWIG_fail;
16787 }
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 (arg1)->SetMapMode(arg2);
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 Py_INCREF(Py_None); resultobj = Py_None;
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16803 PyObject *resultobj;
16804 wxDC *arg1 = (wxDC *) 0 ;
16805 double *arg2 = (double *) 0 ;
16806 double *arg3 = (double *) 0 ;
16807 double temp2 ;
16808 int res2 = 0 ;
16809 double temp3 ;
16810 int res3 = 0 ;
16811 PyObject * obj0 = 0 ;
16812 char *kwnames[] = {
16813 (char *) "self", NULL
16814 };
16815
16816 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16817 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16820 if (SWIG_arg_fail(1)) SWIG_fail;
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16824
16825 wxPyEndAllowThreads(__tstate);
16826 if (PyErr_Occurred()) SWIG_fail;
16827 }
16828 Py_INCREF(Py_None); resultobj = Py_None;
16829 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16830 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16831 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16832 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj;
16841 wxDC *arg1 = (wxDC *) 0 ;
16842 double arg2 ;
16843 double arg3 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 PyObject * obj2 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "self",(char *) "x",(char *) "y", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16853 if (SWIG_arg_fail(1)) SWIG_fail;
16854 {
16855 arg2 = (double)(SWIG_As_double(obj1));
16856 if (SWIG_arg_fail(2)) SWIG_fail;
16857 }
16858 {
16859 arg3 = (double)(SWIG_As_double(obj2));
16860 if (SWIG_arg_fail(3)) SWIG_fail;
16861 }
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 (arg1)->SetUserScale(arg2,arg3);
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 Py_INCREF(Py_None); resultobj = Py_None;
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 wxDC *arg1 = (wxDC *) 0 ;
16879 double *arg2 = (double *) 0 ;
16880 double *arg3 = (double *) 0 ;
16881 double temp2 ;
16882 int res2 = 0 ;
16883 double temp3 ;
16884 int res3 = 0 ;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16891 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 (arg1)->GetLogicalScale(arg2,arg3);
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 Py_INCREF(Py_None); resultobj = Py_None;
16903 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16904 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16905 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16906 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxDC *arg1 = (wxDC *) 0 ;
16916 double arg2 ;
16917 double arg3 ;
16918 PyObject * obj0 = 0 ;
16919 PyObject * obj1 = 0 ;
16920 PyObject * obj2 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self",(char *) "x",(char *) "y", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16927 if (SWIG_arg_fail(1)) SWIG_fail;
16928 {
16929 arg2 = (double)(SWIG_As_double(obj1));
16930 if (SWIG_arg_fail(2)) SWIG_fail;
16931 }
16932 {
16933 arg3 = (double)(SWIG_As_double(obj2));
16934 if (SWIG_arg_fail(3)) SWIG_fail;
16935 }
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 (arg1)->SetLogicalScale(arg2,arg3);
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 Py_INCREF(Py_None); resultobj = Py_None;
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxDC *arg1 = (wxDC *) 0 ;
16953 wxPoint result;
16954 PyObject * obj0 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16965
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 wxPoint * resultptr;
16971 resultptr = new wxPoint((wxPoint &)(result));
16972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16973 }
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 wxDC *arg1 = (wxDC *) 0 ;
16983 int *arg2 = (int *) 0 ;
16984 int *arg3 = (int *) 0 ;
16985 int temp2 ;
16986 int res2 = 0 ;
16987 int temp3 ;
16988 int res3 = 0 ;
16989 PyObject * obj0 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self", NULL
16992 };
16993
16994 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16995 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16998 if (SWIG_arg_fail(1)) SWIG_fail;
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
17002
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 Py_INCREF(Py_None); resultobj = Py_None;
17007 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17008 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17009 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17010 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj;
17019 wxDC *arg1 = (wxDC *) 0 ;
17020 int arg2 ;
17021 int arg3 ;
17022 PyObject * obj0 = 0 ;
17023 PyObject * obj1 = 0 ;
17024 PyObject * obj2 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self",(char *) "x",(char *) "y", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 {
17033 arg2 = (int)(SWIG_As_int(obj1));
17034 if (SWIG_arg_fail(2)) SWIG_fail;
17035 }
17036 {
17037 arg3 = (int)(SWIG_As_int(obj2));
17038 if (SWIG_arg_fail(3)) SWIG_fail;
17039 }
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 (arg1)->SetLogicalOrigin(arg2,arg3);
17043
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 Py_INCREF(Py_None); resultobj = Py_None;
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj;
17056 wxDC *arg1 = (wxDC *) 0 ;
17057 wxPoint *arg2 = 0 ;
17058 wxPoint temp2 ;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 char *kwnames[] = {
17062 (char *) "self",(char *) "point", NULL
17063 };
17064
17065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17067 if (SWIG_arg_fail(1)) SWIG_fail;
17068 {
17069 arg2 = &temp2;
17070 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17071 }
17072 {
17073 PyThreadState* __tstate = wxPyBeginAllowThreads();
17074 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17075
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 Py_INCREF(Py_None); resultobj = Py_None;
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxDC *arg1 = (wxDC *) 0 ;
17089 wxPoint result;
17090 PyObject * obj0 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 wxPoint * resultptr;
17107 resultptr = new wxPoint((wxPoint &)(result));
17108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17109 }
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxDC *arg1 = (wxDC *) 0 ;
17119 int *arg2 = (int *) 0 ;
17120 int *arg3 = (int *) 0 ;
17121 int temp2 ;
17122 int res2 = 0 ;
17123 int temp3 ;
17124 int res3 = 0 ;
17125 PyObject * obj0 = 0 ;
17126 char *kwnames[] = {
17127 (char *) "self", NULL
17128 };
17129
17130 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17131 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17134 if (SWIG_arg_fail(1)) SWIG_fail;
17135 {
17136 PyThreadState* __tstate = wxPyBeginAllowThreads();
17137 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17138
17139 wxPyEndAllowThreads(__tstate);
17140 if (PyErr_Occurred()) SWIG_fail;
17141 }
17142 Py_INCREF(Py_None); resultobj = Py_None;
17143 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17144 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17145 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17146 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 wxDC *arg1 = (wxDC *) 0 ;
17156 int arg2 ;
17157 int arg3 ;
17158 PyObject * obj0 = 0 ;
17159 PyObject * obj1 = 0 ;
17160 PyObject * obj2 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self",(char *) "x",(char *) "y", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 {
17169 arg2 = (int)(SWIG_As_int(obj1));
17170 if (SWIG_arg_fail(2)) SWIG_fail;
17171 }
17172 {
17173 arg3 = (int)(SWIG_As_int(obj2));
17174 if (SWIG_arg_fail(3)) SWIG_fail;
17175 }
17176 {
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 (arg1)->SetDeviceOrigin(arg2,arg3);
17179
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 Py_INCREF(Py_None); resultobj = Py_None;
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj;
17192 wxDC *arg1 = (wxDC *) 0 ;
17193 wxPoint *arg2 = 0 ;
17194 wxPoint temp2 ;
17195 PyObject * obj0 = 0 ;
17196 PyObject * obj1 = 0 ;
17197 char *kwnames[] = {
17198 (char *) "self",(char *) "point", NULL
17199 };
17200
17201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17203 if (SWIG_arg_fail(1)) SWIG_fail;
17204 {
17205 arg2 = &temp2;
17206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17207 }
17208 {
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17211
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 Py_INCREF(Py_None); resultobj = Py_None;
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj;
17224 wxDC *arg1 = (wxDC *) 0 ;
17225 bool arg2 ;
17226 bool arg3 ;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 PyObject * obj2 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 {
17238 arg2 = (bool)(SWIG_As_bool(obj1));
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 }
17241 {
17242 arg3 = (bool)(SWIG_As_bool(obj2));
17243 if (SWIG_arg_fail(3)) SWIG_fail;
17244 }
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 (arg1)->SetAxisOrientation(arg2,arg3);
17248
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 Py_INCREF(Py_None); resultobj = Py_None;
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj;
17261 wxDC *arg1 = (wxDC *) 0 ;
17262 int result;
17263 PyObject * obj0 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17274
17275 wxPyEndAllowThreads(__tstate);
17276 if (PyErr_Occurred()) SWIG_fail;
17277 }
17278 {
17279 resultobj = SWIG_From_int((int)(result));
17280 }
17281 return resultobj;
17282 fail:
17283 return NULL;
17284 }
17285
17286
17287 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17288 PyObject *resultobj;
17289 wxDC *arg1 = (wxDC *) 0 ;
17290 int arg2 ;
17291 PyObject * obj0 = 0 ;
17292 PyObject * obj1 = 0 ;
17293 char *kwnames[] = {
17294 (char *) "self",(char *) "function", NULL
17295 };
17296
17297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17299 if (SWIG_arg_fail(1)) SWIG_fail;
17300 {
17301 arg2 = (int)(SWIG_As_int(obj1));
17302 if (SWIG_arg_fail(2)) SWIG_fail;
17303 }
17304 {
17305 PyThreadState* __tstate = wxPyBeginAllowThreads();
17306 (arg1)->SetLogicalFunction(arg2);
17307
17308 wxPyEndAllowThreads(__tstate);
17309 if (PyErr_Occurred()) SWIG_fail;
17310 }
17311 Py_INCREF(Py_None); resultobj = Py_None;
17312 return resultobj;
17313 fail:
17314 return NULL;
17315 }
17316
17317
17318 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17319 PyObject *resultobj;
17320 wxDC *arg1 = (wxDC *) 0 ;
17321 PyObject * obj0 = 0 ;
17322 char *kwnames[] = {
17323 (char *) "self", NULL
17324 };
17325
17326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17328 if (SWIG_arg_fail(1)) SWIG_fail;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 (arg1)->ComputeScaleAndOrigin();
17332
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 Py_INCREF(Py_None); resultobj = Py_None;
17337 return resultobj;
17338 fail:
17339 return NULL;
17340 }
17341
17342
17343 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17344 PyObject *resultobj;
17345 wxDC *arg1 = (wxDC *) 0 ;
17346 int arg2 ;
17347 int arg3 ;
17348 PyObject * obj0 = 0 ;
17349 PyObject * obj1 = 0 ;
17350 PyObject * obj2 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self",(char *) "x",(char *) "y", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 arg2 = (int)(SWIG_As_int(obj1));
17360 if (SWIG_arg_fail(2)) SWIG_fail;
17361 }
17362 {
17363 arg3 = (int)(SWIG_As_int(obj2));
17364 if (SWIG_arg_fail(3)) SWIG_fail;
17365 }
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 (arg1)->CalcBoundingBox(arg2,arg3);
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 Py_INCREF(Py_None); resultobj = Py_None;
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxDC *arg1 = (wxDC *) 0 ;
17383 wxPoint *arg2 = 0 ;
17384 wxPoint temp2 ;
17385 PyObject * obj0 = 0 ;
17386 PyObject * obj1 = 0 ;
17387 char *kwnames[] = {
17388 (char *) "self",(char *) "point", NULL
17389 };
17390
17391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17393 if (SWIG_arg_fail(1)) SWIG_fail;
17394 {
17395 arg2 = &temp2;
17396 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17397 }
17398 {
17399 PyThreadState* __tstate = wxPyBeginAllowThreads();
17400 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17401
17402 wxPyEndAllowThreads(__tstate);
17403 if (PyErr_Occurred()) SWIG_fail;
17404 }
17405 Py_INCREF(Py_None); resultobj = Py_None;
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj;
17414 wxDC *arg1 = (wxDC *) 0 ;
17415 PyObject * obj0 = 0 ;
17416 char *kwnames[] = {
17417 (char *) "self", NULL
17418 };
17419
17420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17422 if (SWIG_arg_fail(1)) SWIG_fail;
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 (arg1)->ResetBoundingBox();
17426
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 Py_INCREF(Py_None); resultobj = Py_None;
17431 return resultobj;
17432 fail:
17433 return NULL;
17434 }
17435
17436
17437 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17438 PyObject *resultobj;
17439 wxDC *arg1 = (wxDC *) 0 ;
17440 int result;
17441 PyObject * obj0 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "self", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 {
17450 PyThreadState* __tstate = wxPyBeginAllowThreads();
17451 result = (int)((wxDC const *)arg1)->MinX();
17452
17453 wxPyEndAllowThreads(__tstate);
17454 if (PyErr_Occurred()) SWIG_fail;
17455 }
17456 {
17457 resultobj = SWIG_From_int((int)(result));
17458 }
17459 return resultobj;
17460 fail:
17461 return NULL;
17462 }
17463
17464
17465 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17466 PyObject *resultobj;
17467 wxDC *arg1 = (wxDC *) 0 ;
17468 int result;
17469 PyObject * obj0 = 0 ;
17470 char *kwnames[] = {
17471 (char *) "self", NULL
17472 };
17473
17474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17476 if (SWIG_arg_fail(1)) SWIG_fail;
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (int)((wxDC const *)arg1)->MaxX();
17480
17481 wxPyEndAllowThreads(__tstate);
17482 if (PyErr_Occurred()) SWIG_fail;
17483 }
17484 {
17485 resultobj = SWIG_From_int((int)(result));
17486 }
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj;
17495 wxDC *arg1 = (wxDC *) 0 ;
17496 int result;
17497 PyObject * obj0 = 0 ;
17498 char *kwnames[] = {
17499 (char *) "self", NULL
17500 };
17501
17502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17504 if (SWIG_arg_fail(1)) SWIG_fail;
17505 {
17506 PyThreadState* __tstate = wxPyBeginAllowThreads();
17507 result = (int)((wxDC const *)arg1)->MinY();
17508
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 {
17513 resultobj = SWIG_From_int((int)(result));
17514 }
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17522 PyObject *resultobj;
17523 wxDC *arg1 = (wxDC *) 0 ;
17524 int result;
17525 PyObject * obj0 = 0 ;
17526 char *kwnames[] = {
17527 (char *) "self", NULL
17528 };
17529
17530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17532 if (SWIG_arg_fail(1)) SWIG_fail;
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (int)((wxDC const *)arg1)->MaxY();
17536
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = SWIG_From_int((int)(result));
17542 }
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj;
17551 wxDC *arg1 = (wxDC *) 0 ;
17552 int *arg2 = (int *) 0 ;
17553 int *arg3 = (int *) 0 ;
17554 int *arg4 = (int *) 0 ;
17555 int *arg5 = (int *) 0 ;
17556 int temp2 ;
17557 int res2 = 0 ;
17558 int temp3 ;
17559 int res3 = 0 ;
17560 int temp4 ;
17561 int res4 = 0 ;
17562 int temp5 ;
17563 int res5 = 0 ;
17564 PyObject * obj0 = 0 ;
17565 char *kwnames[] = {
17566 (char *) "self", NULL
17567 };
17568
17569 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17570 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17571 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17572 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 Py_INCREF(Py_None); resultobj = Py_None;
17584 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17585 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17586 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17587 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17588 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17589 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17590 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17591 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17599 PyObject *resultobj;
17600 wxDC *arg1 = (wxDC *) 0 ;
17601 long result;
17602 PyObject * obj0 = 0 ;
17603 char *kwnames[] = {
17604 (char *) "self", NULL
17605 };
17606
17607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17609 if (SWIG_arg_fail(1)) SWIG_fail;
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (long)(arg1)->GetHDC();
17613
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 {
17618 resultobj = SWIG_From_long((long)(result));
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxDC *arg1 = (wxDC *) 0 ;
17629 PyObject *arg2 = (PyObject *) 0 ;
17630 PyObject *arg3 = (PyObject *) 0 ;
17631 PyObject *arg4 = (PyObject *) 0 ;
17632 PyObject *result;
17633 PyObject * obj0 = 0 ;
17634 PyObject * obj1 = 0 ;
17635 PyObject * obj2 = 0 ;
17636 PyObject * obj3 = 0 ;
17637 char *kwnames[] = {
17638 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17639 };
17640
17641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17643 if (SWIG_arg_fail(1)) SWIG_fail;
17644 arg2 = obj1;
17645 arg3 = obj2;
17646 arg4 = obj3;
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17650
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 resultobj = result;
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj;
17663 wxDC *arg1 = (wxDC *) 0 ;
17664 PyObject *arg2 = (PyObject *) 0 ;
17665 PyObject *arg3 = (PyObject *) 0 ;
17666 PyObject *arg4 = (PyObject *) 0 ;
17667 PyObject *result;
17668 PyObject * obj0 = 0 ;
17669 PyObject * obj1 = 0 ;
17670 PyObject * obj2 = 0 ;
17671 PyObject * obj3 = 0 ;
17672 char *kwnames[] = {
17673 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17674 };
17675
17676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17678 if (SWIG_arg_fail(1)) SWIG_fail;
17679 arg2 = obj1;
17680 arg3 = obj2;
17681 arg4 = obj3;
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17685
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 resultobj = result;
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17697 PyObject *resultobj;
17698 wxDC *arg1 = (wxDC *) 0 ;
17699 PyObject *arg2 = (PyObject *) 0 ;
17700 PyObject *arg3 = (PyObject *) 0 ;
17701 PyObject *arg4 = (PyObject *) 0 ;
17702 PyObject *result;
17703 PyObject * obj0 = 0 ;
17704 PyObject * obj1 = 0 ;
17705 PyObject * obj2 = 0 ;
17706 PyObject * obj3 = 0 ;
17707 char *kwnames[] = {
17708 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17709 };
17710
17711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17713 if (SWIG_arg_fail(1)) SWIG_fail;
17714 arg2 = obj1;
17715 arg3 = obj2;
17716 arg4 = obj3;
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17720
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 resultobj = result;
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj;
17733 wxDC *arg1 = (wxDC *) 0 ;
17734 PyObject *arg2 = (PyObject *) 0 ;
17735 PyObject *arg3 = (PyObject *) 0 ;
17736 PyObject *arg4 = (PyObject *) 0 ;
17737 PyObject *result;
17738 PyObject * obj0 = 0 ;
17739 PyObject * obj1 = 0 ;
17740 PyObject * obj2 = 0 ;
17741 PyObject * obj3 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 arg2 = obj1;
17750 arg3 = obj2;
17751 arg4 = obj3;
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 resultobj = result;
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj;
17768 wxDC *arg1 = (wxDC *) 0 ;
17769 PyObject *arg2 = (PyObject *) 0 ;
17770 PyObject *arg3 = (PyObject *) 0 ;
17771 PyObject *arg4 = (PyObject *) 0 ;
17772 PyObject *result;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 PyObject * obj2 = 0 ;
17776 PyObject * obj3 = 0 ;
17777 char *kwnames[] = {
17778 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17779 };
17780
17781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17783 if (SWIG_arg_fail(1)) SWIG_fail;
17784 arg2 = obj1;
17785 arg3 = obj2;
17786 arg4 = obj3;
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17790
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 resultobj = result;
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxDC *arg1 = (wxDC *) 0 ;
17804 PyObject *arg2 = (PyObject *) 0 ;
17805 PyObject *arg3 = (PyObject *) 0 ;
17806 PyObject *arg4 = (PyObject *) 0 ;
17807 PyObject *arg5 = (PyObject *) 0 ;
17808 PyObject *result;
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 *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17816 };
17817
17818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17820 if (SWIG_arg_fail(1)) SWIG_fail;
17821 arg2 = obj1;
17822 arg3 = obj2;
17823 arg4 = obj3;
17824 arg5 = obj4;
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17828
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 resultobj = result;
17833 return resultobj;
17834 fail:
17835 return NULL;
17836 }
17837
17838
17839 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17840 PyObject *obj;
17841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17842 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17843 Py_INCREF(obj);
17844 return Py_BuildValue((char *)"");
17845 }
17846 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17847 PyObject *resultobj;
17848 wxMemoryDC *result;
17849 char *kwnames[] = {
17850 NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17854 {
17855 if (!wxPyCheckForApp()) SWIG_fail;
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (wxMemoryDC *)new wxMemoryDC();
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17870 PyObject *resultobj;
17871 wxDC *arg1 = (wxDC *) 0 ;
17872 wxMemoryDC *result;
17873 PyObject * obj0 = 0 ;
17874 char *kwnames[] = {
17875 (char *) "oldDC", NULL
17876 };
17877
17878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 {
17882 if (!wxPyCheckForApp()) SWIG_fail;
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17890 return resultobj;
17891 fail:
17892 return NULL;
17893 }
17894
17895
17896 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17897 PyObject *resultobj;
17898 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17899 wxBitmap *arg2 = 0 ;
17900 PyObject * obj0 = 0 ;
17901 PyObject * obj1 = 0 ;
17902 char *kwnames[] = {
17903 (char *) "self",(char *) "bitmap", NULL
17904 };
17905
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17908 if (SWIG_arg_fail(1)) SWIG_fail;
17909 {
17910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17911 if (SWIG_arg_fail(2)) SWIG_fail;
17912 if (arg2 == NULL) {
17913 SWIG_null_ref("wxBitmap");
17914 }
17915 if (SWIG_arg_fail(2)) SWIG_fail;
17916 }
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 (arg1)->SelectObject((wxBitmap const &)*arg2);
17920
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 Py_INCREF(Py_None); resultobj = Py_None;
17925 return resultobj;
17926 fail:
17927 return NULL;
17928 }
17929
17930
17931 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17932 PyObject *obj;
17933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17934 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17935 Py_INCREF(obj);
17936 return Py_BuildValue((char *)"");
17937 }
17938 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17939 PyObject *resultobj;
17940 wxDC *arg1 = (wxDC *) 0 ;
17941 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17942 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17943 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17944 wxBufferedDC *result;
17945 PyObject * obj0 = 0 ;
17946 PyObject * obj1 = 0 ;
17947 PyObject * obj2 = 0 ;
17948
17949 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17951 if (SWIG_arg_fail(1)) SWIG_fail;
17952 if (obj1) {
17953 {
17954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17955 if (SWIG_arg_fail(2)) SWIG_fail;
17956 if (arg2 == NULL) {
17957 SWIG_null_ref("wxBitmap");
17958 }
17959 if (SWIG_arg_fail(2)) SWIG_fail;
17960 }
17961 }
17962 if (obj2) {
17963 {
17964 arg3 = (int)(SWIG_As_int(obj2));
17965 if (SWIG_arg_fail(3)) SWIG_fail;
17966 }
17967 }
17968 {
17969 if (!wxPyCheckForApp()) SWIG_fail;
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17972
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17977 return resultobj;
17978 fail:
17979 return NULL;
17980 }
17981
17982
17983 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17984 PyObject *resultobj;
17985 wxDC *arg1 = (wxDC *) 0 ;
17986 wxSize *arg2 = 0 ;
17987 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17988 wxBufferedDC *result;
17989 wxSize temp2 ;
17990 PyObject * obj0 = 0 ;
17991 PyObject * obj1 = 0 ;
17992 PyObject * obj2 = 0 ;
17993
17994 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 arg2 = &temp2;
17999 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18000 }
18001 if (obj2) {
18002 {
18003 arg3 = (int)(SWIG_As_int(obj2));
18004 if (SWIG_arg_fail(3)) SWIG_fail;
18005 }
18006 }
18007 {
18008 if (!wxPyCheckForApp()) SWIG_fail;
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
18023 int argc;
18024 PyObject *argv[4];
18025 int ii;
18026
18027 argc = PyObject_Length(args);
18028 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18029 argv[ii] = PyTuple_GetItem(args,ii);
18030 }
18031 if ((argc >= 1) && (argc <= 3)) {
18032 int _v;
18033 {
18034 void *ptr;
18035 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18036 _v = 0;
18037 PyErr_Clear();
18038 } else {
18039 _v = 1;
18040 }
18041 }
18042 if (_v) {
18043 if (argc <= 1) {
18044 return _wrap_new_BufferedDC__SWIG_0(self,args);
18045 }
18046 {
18047 void *ptr = 0;
18048 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18049 _v = 0;
18050 PyErr_Clear();
18051 } else {
18052 _v = (ptr != 0);
18053 }
18054 }
18055 if (_v) {
18056 if (argc <= 2) {
18057 return _wrap_new_BufferedDC__SWIG_0(self,args);
18058 }
18059 _v = SWIG_Check_int(argv[2]);
18060 if (_v) {
18061 return _wrap_new_BufferedDC__SWIG_0(self,args);
18062 }
18063 }
18064 }
18065 }
18066 if ((argc >= 2) && (argc <= 3)) {
18067 int _v;
18068 {
18069 void *ptr;
18070 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18071 _v = 0;
18072 PyErr_Clear();
18073 } else {
18074 _v = 1;
18075 }
18076 }
18077 if (_v) {
18078 {
18079 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18080 }
18081 if (_v) {
18082 if (argc <= 2) {
18083 return _wrap_new_BufferedDC__SWIG_1(self,args);
18084 }
18085 _v = SWIG_Check_int(argv[2]);
18086 if (_v) {
18087 return _wrap_new_BufferedDC__SWIG_1(self,args);
18088 }
18089 }
18090 }
18091 }
18092
18093 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18094 return NULL;
18095 }
18096
18097
18098 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18099 PyObject *resultobj;
18100 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18101 PyObject * obj0 = 0 ;
18102 char *kwnames[] = {
18103 (char *) "self", NULL
18104 };
18105
18106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18108 if (SWIG_arg_fail(1)) SWIG_fail;
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 delete arg1;
18112
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 Py_INCREF(Py_None); resultobj = Py_None;
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj;
18125 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18126 PyObject * obj0 = 0 ;
18127 char *kwnames[] = {
18128 (char *) "self", NULL
18129 };
18130
18131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18133 if (SWIG_arg_fail(1)) SWIG_fail;
18134 {
18135 PyThreadState* __tstate = wxPyBeginAllowThreads();
18136 (arg1)->UnMask();
18137
18138 wxPyEndAllowThreads(__tstate);
18139 if (PyErr_Occurred()) SWIG_fail;
18140 }
18141 Py_INCREF(Py_None); resultobj = Py_None;
18142 return resultobj;
18143 fail:
18144 return NULL;
18145 }
18146
18147
18148 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18149 PyObject *obj;
18150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18151 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18152 Py_INCREF(obj);
18153 return Py_BuildValue((char *)"");
18154 }
18155 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18156 PyObject *resultobj;
18157 wxWindow *arg1 = (wxWindow *) 0 ;
18158 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18159 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18160 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18161 wxBufferedPaintDC *result;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 PyObject * obj2 = 0 ;
18165 char *kwnames[] = {
18166 (char *) "window",(char *) "buffer",(char *) "style", NULL
18167 };
18168
18169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18171 if (SWIG_arg_fail(1)) SWIG_fail;
18172 if (obj1) {
18173 {
18174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18175 if (SWIG_arg_fail(2)) SWIG_fail;
18176 if (arg2 == NULL) {
18177 SWIG_null_ref("wxBitmap");
18178 }
18179 if (SWIG_arg_fail(2)) SWIG_fail;
18180 }
18181 }
18182 if (obj2) {
18183 {
18184 arg3 = (int)(SWIG_As_int(obj2));
18185 if (SWIG_arg_fail(3)) SWIG_fail;
18186 }
18187 }
18188 {
18189 if (!wxPyCheckForApp()) SWIG_fail;
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18192
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18204 PyObject *obj;
18205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18206 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18207 Py_INCREF(obj);
18208 return Py_BuildValue((char *)"");
18209 }
18210 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj;
18212 wxScreenDC *result;
18213 char *kwnames[] = {
18214 NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18218 {
18219 if (!wxPyCheckForApp()) SWIG_fail;
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = (wxScreenDC *)new wxScreenDC();
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18236 wxWindow *arg2 = (wxWindow *) 0 ;
18237 bool result;
18238 PyObject * obj0 = 0 ;
18239 PyObject * obj1 = 0 ;
18240 char *kwnames[] = {
18241 (char *) "self",(char *) "window", NULL
18242 };
18243
18244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18246 if (SWIG_arg_fail(1)) SWIG_fail;
18247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(2)) SWIG_fail;
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18252
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 {
18257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18258 }
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18268 wxRect *arg2 = (wxRect *) NULL ;
18269 bool result;
18270 PyObject * obj0 = 0 ;
18271 PyObject * obj1 = 0 ;
18272 char *kwnames[] = {
18273 (char *) "self",(char *) "rect", NULL
18274 };
18275
18276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 if (obj1) {
18280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18281 if (SWIG_arg_fail(2)) SWIG_fail;
18282 }
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18286
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 {
18291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18302 bool result;
18303 PyObject * obj0 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (bool)(arg1)->EndDrawingOnTop();
18314
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 {
18319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18320 }
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18328 PyObject *obj;
18329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18330 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18331 Py_INCREF(obj);
18332 return Py_BuildValue((char *)"");
18333 }
18334 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18335 PyObject *resultobj;
18336 wxWindow *arg1 = (wxWindow *) 0 ;
18337 wxClientDC *result;
18338 PyObject * obj0 = 0 ;
18339 char *kwnames[] = {
18340 (char *) "win", NULL
18341 };
18342
18343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 {
18347 if (!wxPyCheckForApp()) SWIG_fail;
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (wxClientDC *)new wxClientDC(arg1);
18350
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18362 PyObject *obj;
18363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18364 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18365 Py_INCREF(obj);
18366 return Py_BuildValue((char *)"");
18367 }
18368 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18369 PyObject *resultobj;
18370 wxWindow *arg1 = (wxWindow *) 0 ;
18371 wxPaintDC *result;
18372 PyObject * obj0 = 0 ;
18373 char *kwnames[] = {
18374 (char *) "win", NULL
18375 };
18376
18377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18379 if (SWIG_arg_fail(1)) SWIG_fail;
18380 {
18381 if (!wxPyCheckForApp()) SWIG_fail;
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 result = (wxPaintDC *)new wxPaintDC(arg1);
18384
18385 wxPyEndAllowThreads(__tstate);
18386 if (PyErr_Occurred()) SWIG_fail;
18387 }
18388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18389 return resultobj;
18390 fail:
18391 return NULL;
18392 }
18393
18394
18395 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18396 PyObject *obj;
18397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18398 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18399 Py_INCREF(obj);
18400 return Py_BuildValue((char *)"");
18401 }
18402 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18403 PyObject *resultobj;
18404 wxWindow *arg1 = (wxWindow *) 0 ;
18405 wxWindowDC *result;
18406 PyObject * obj0 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "win", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 if (!wxPyCheckForApp()) SWIG_fail;
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 result = (wxWindowDC *)new wxWindowDC(arg1);
18418
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18430 PyObject *obj;
18431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18432 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18433 Py_INCREF(obj);
18434 return Py_BuildValue((char *)"");
18435 }
18436 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18437 PyObject *resultobj;
18438 wxDC *arg1 = 0 ;
18439 bool arg2 ;
18440 wxMirrorDC *result;
18441 PyObject * obj0 = 0 ;
18442 PyObject * obj1 = 0 ;
18443 char *kwnames[] = {
18444 (char *) "dc",(char *) "mirror", NULL
18445 };
18446
18447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18448 {
18449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18450 if (SWIG_arg_fail(1)) SWIG_fail;
18451 if (arg1 == NULL) {
18452 SWIG_null_ref("wxDC");
18453 }
18454 if (SWIG_arg_fail(1)) SWIG_fail;
18455 }
18456 {
18457 arg2 = (bool)(SWIG_As_bool(obj1));
18458 if (SWIG_arg_fail(2)) SWIG_fail;
18459 }
18460 {
18461 if (!wxPyCheckForApp()) SWIG_fail;
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18464
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18476 PyObject *obj;
18477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18478 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18479 Py_INCREF(obj);
18480 return Py_BuildValue((char *)"");
18481 }
18482 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj;
18484 wxPrintData *arg1 = 0 ;
18485 wxPostScriptDC *result;
18486 PyObject * obj0 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "printData", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18492 {
18493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18494 if (SWIG_arg_fail(1)) SWIG_fail;
18495 if (arg1 == NULL) {
18496 SWIG_null_ref("wxPrintData");
18497 }
18498 if (SWIG_arg_fail(1)) SWIG_fail;
18499 }
18500 {
18501 if (!wxPyCheckForApp()) SWIG_fail;
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18504
18505 wxPyEndAllowThreads(__tstate);
18506 if (PyErr_Occurred()) SWIG_fail;
18507 }
18508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18509 return resultobj;
18510 fail:
18511 return NULL;
18512 }
18513
18514
18515 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18516 PyObject *resultobj;
18517 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18518 wxPrintData *result;
18519 PyObject * obj0 = 0 ;
18520 char *kwnames[] = {
18521 (char *) "self", NULL
18522 };
18523
18524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18526 if (SWIG_arg_fail(1)) SWIG_fail;
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 {
18530 wxPrintData &_result_ref = (arg1)->GetPrintData();
18531 result = (wxPrintData *) &_result_ref;
18532 }
18533
18534 wxPyEndAllowThreads(__tstate);
18535 if (PyErr_Occurred()) SWIG_fail;
18536 }
18537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18538 return resultobj;
18539 fail:
18540 return NULL;
18541 }
18542
18543
18544 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18545 PyObject *resultobj;
18546 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18547 wxPrintData *arg2 = 0 ;
18548 PyObject * obj0 = 0 ;
18549 PyObject * obj1 = 0 ;
18550 char *kwnames[] = {
18551 (char *) "self",(char *) "data", NULL
18552 };
18553
18554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18556 if (SWIG_arg_fail(1)) SWIG_fail;
18557 {
18558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18559 if (SWIG_arg_fail(2)) SWIG_fail;
18560 if (arg2 == NULL) {
18561 SWIG_null_ref("wxPrintData");
18562 }
18563 if (SWIG_arg_fail(2)) SWIG_fail;
18564 }
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18568
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 Py_INCREF(Py_None); resultobj = Py_None;
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18580 PyObject *resultobj;
18581 int arg1 ;
18582 PyObject * obj0 = 0 ;
18583 char *kwnames[] = {
18584 (char *) "ppi", NULL
18585 };
18586
18587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18588 {
18589 arg1 = (int)(SWIG_As_int(obj0));
18590 if (SWIG_arg_fail(1)) SWIG_fail;
18591 }
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 wxPostScriptDC::SetResolution(arg1);
18595
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 Py_INCREF(Py_None); resultobj = Py_None;
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj;
18608 int result;
18609 char *kwnames[] = {
18610 NULL
18611 };
18612
18613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 result = (int)wxPostScriptDC::GetResolution();
18617
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 {
18622 resultobj = SWIG_From_int((int)(result));
18623 }
18624 return resultobj;
18625 fail:
18626 return NULL;
18627 }
18628
18629
18630 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18631 PyObject *obj;
18632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18633 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18634 Py_INCREF(obj);
18635 return Py_BuildValue((char *)"");
18636 }
18637 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18638 PyObject *resultobj;
18639 wxString const &arg1_defvalue = wxPyEmptyString ;
18640 wxString *arg1 = (wxString *) &arg1_defvalue ;
18641 wxMetaFile *result;
18642 bool temp1 = false ;
18643 PyObject * obj0 = 0 ;
18644 char *kwnames[] = {
18645 (char *) "filename", NULL
18646 };
18647
18648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18649 if (obj0) {
18650 {
18651 arg1 = wxString_in_helper(obj0);
18652 if (arg1 == NULL) SWIG_fail;
18653 temp1 = true;
18654 }
18655 }
18656 {
18657 if (!wxPyCheckForApp()) SWIG_fail;
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18665 {
18666 if (temp1)
18667 delete arg1;
18668 }
18669 return resultobj;
18670 fail:
18671 {
18672 if (temp1)
18673 delete arg1;
18674 }
18675 return NULL;
18676 }
18677
18678
18679 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18680 PyObject *resultobj;
18681 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18682 PyObject * obj0 = 0 ;
18683 char *kwnames[] = {
18684 (char *) "self", NULL
18685 };
18686
18687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18689 if (SWIG_arg_fail(1)) SWIG_fail;
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 delete arg1;
18693
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 Py_INCREF(Py_None); resultobj = Py_None;
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj;
18706 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18707 bool result;
18708 PyObject * obj0 = 0 ;
18709 char *kwnames[] = {
18710 (char *) "self", NULL
18711 };
18712
18713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18715 if (SWIG_arg_fail(1)) SWIG_fail;
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 result = (bool)(arg1)->Ok();
18719
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 {
18724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18725 }
18726 return resultobj;
18727 fail:
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18735 int arg2 = (int) 0 ;
18736 int arg3 = (int) 0 ;
18737 bool result;
18738 PyObject * obj0 = 0 ;
18739 PyObject * obj1 = 0 ;
18740 PyObject * obj2 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "width",(char *) "height", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 if (obj1) {
18749 {
18750 arg2 = (int)(SWIG_As_int(obj1));
18751 if (SWIG_arg_fail(2)) SWIG_fail;
18752 }
18753 }
18754 if (obj2) {
18755 {
18756 arg3 = (int)(SWIG_As_int(obj2));
18757 if (SWIG_arg_fail(3)) SWIG_fail;
18758 }
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18763
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 {
18768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18769 }
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18779 wxSize result;
18780 PyObject * obj0 = 0 ;
18781 char *kwnames[] = {
18782 (char *) "self", NULL
18783 };
18784
18785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18787 if (SWIG_arg_fail(1)) SWIG_fail;
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (arg1)->GetSize();
18791
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 {
18796 wxSize * resultptr;
18797 resultptr = new wxSize((wxSize &)(result));
18798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18809 int result;
18810 PyObject * obj0 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "self", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = (int)(arg1)->GetWidth();
18821
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 {
18826 resultobj = SWIG_From_int((int)(result));
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18835 PyObject *resultobj;
18836 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18837 int result;
18838 PyObject * obj0 = 0 ;
18839 char *kwnames[] = {
18840 (char *) "self", NULL
18841 };
18842
18843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18845 if (SWIG_arg_fail(1)) SWIG_fail;
18846 {
18847 PyThreadState* __tstate = wxPyBeginAllowThreads();
18848 result = (int)(arg1)->GetHeight();
18849
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 resultobj = SWIG_From_int((int)(result));
18855 }
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj;
18864 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18865 wxString *result;
18866 PyObject * obj0 = 0 ;
18867 char *kwnames[] = {
18868 (char *) "self", NULL
18869 };
18870
18871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18873 if (SWIG_arg_fail(1)) SWIG_fail;
18874 {
18875 PyThreadState* __tstate = wxPyBeginAllowThreads();
18876 {
18877 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18878 result = (wxString *) &_result_ref;
18879 }
18880
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 #if wxUSE_UNICODE
18886 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18887 #else
18888 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18889 #endif
18890 }
18891 return resultobj;
18892 fail:
18893 return NULL;
18894 }
18895
18896
18897 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18898 PyObject *obj;
18899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18900 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18901 Py_INCREF(obj);
18902 return Py_BuildValue((char *)"");
18903 }
18904 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18905 PyObject *resultobj;
18906 wxString const &arg1_defvalue = wxPyEmptyString ;
18907 wxString *arg1 = (wxString *) &arg1_defvalue ;
18908 int arg2 = (int) 0 ;
18909 int arg3 = (int) 0 ;
18910 wxString const &arg4_defvalue = wxPyEmptyString ;
18911 wxString *arg4 = (wxString *) &arg4_defvalue ;
18912 wxMetaFileDC *result;
18913 bool temp1 = false ;
18914 bool temp4 = false ;
18915 PyObject * obj0 = 0 ;
18916 PyObject * obj1 = 0 ;
18917 PyObject * obj2 = 0 ;
18918 PyObject * obj3 = 0 ;
18919 char *kwnames[] = {
18920 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18921 };
18922
18923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18924 if (obj0) {
18925 {
18926 arg1 = wxString_in_helper(obj0);
18927 if (arg1 == NULL) SWIG_fail;
18928 temp1 = true;
18929 }
18930 }
18931 if (obj1) {
18932 {
18933 arg2 = (int)(SWIG_As_int(obj1));
18934 if (SWIG_arg_fail(2)) SWIG_fail;
18935 }
18936 }
18937 if (obj2) {
18938 {
18939 arg3 = (int)(SWIG_As_int(obj2));
18940 if (SWIG_arg_fail(3)) SWIG_fail;
18941 }
18942 }
18943 if (obj3) {
18944 {
18945 arg4 = wxString_in_helper(obj3);
18946 if (arg4 == NULL) SWIG_fail;
18947 temp4 = true;
18948 }
18949 }
18950 {
18951 if (!wxPyCheckForApp()) SWIG_fail;
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18959 {
18960 if (temp1)
18961 delete arg1;
18962 }
18963 {
18964 if (temp4)
18965 delete arg4;
18966 }
18967 return resultobj;
18968 fail:
18969 {
18970 if (temp1)
18971 delete arg1;
18972 }
18973 {
18974 if (temp4)
18975 delete arg4;
18976 }
18977 return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj;
18983 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18984 wxMetaFile *result;
18985 PyObject * obj0 = 0 ;
18986 char *kwnames[] = {
18987 (char *) "self", NULL
18988 };
18989
18990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18992 if (SWIG_arg_fail(1)) SWIG_fail;
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 result = (wxMetaFile *)(arg1)->Close();
18996
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
19008 PyObject *obj;
19009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19010 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
19011 Py_INCREF(obj);
19012 return Py_BuildValue((char *)"");
19013 }
19014 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
19015 PyObject *resultobj;
19016 wxPrintData *arg1 = 0 ;
19017 wxPrinterDC *result;
19018 PyObject * obj0 = 0 ;
19019 char *kwnames[] = {
19020 (char *) "printData", NULL
19021 };
19022
19023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
19024 {
19025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
19026 if (SWIG_arg_fail(1)) SWIG_fail;
19027 if (arg1 == NULL) {
19028 SWIG_null_ref("wxPrintData");
19029 }
19030 if (SWIG_arg_fail(1)) SWIG_fail;
19031 }
19032 {
19033 if (!wxPyCheckForApp()) SWIG_fail;
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19036
19037 wxPyEndAllowThreads(__tstate);
19038 if (PyErr_Occurred()) SWIG_fail;
19039 }
19040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19041 return resultobj;
19042 fail:
19043 return NULL;
19044 }
19045
19046
19047 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19048 PyObject *obj;
19049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19050 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19051 Py_INCREF(obj);
19052 return Py_BuildValue((char *)"");
19053 }
19054 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19055 PyObject *resultobj;
19056 int arg1 ;
19057 int arg2 ;
19058 int arg3 = (int) true ;
19059 int arg4 = (int) 1 ;
19060 wxImageList *result;
19061 PyObject * obj0 = 0 ;
19062 PyObject * obj1 = 0 ;
19063 PyObject * obj2 = 0 ;
19064 PyObject * obj3 = 0 ;
19065 char *kwnames[] = {
19066 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19067 };
19068
19069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19070 {
19071 arg1 = (int)(SWIG_As_int(obj0));
19072 if (SWIG_arg_fail(1)) SWIG_fail;
19073 }
19074 {
19075 arg2 = (int)(SWIG_As_int(obj1));
19076 if (SWIG_arg_fail(2)) SWIG_fail;
19077 }
19078 if (obj2) {
19079 {
19080 arg3 = (int)(SWIG_As_int(obj2));
19081 if (SWIG_arg_fail(3)) SWIG_fail;
19082 }
19083 }
19084 if (obj3) {
19085 {
19086 arg4 = (int)(SWIG_As_int(obj3));
19087 if (SWIG_arg_fail(4)) SWIG_fail;
19088 }
19089 }
19090 {
19091 if (!wxPyCheckForApp()) SWIG_fail;
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19094
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 {
19099 resultobj = wxPyMake_wxObject(result, 1);
19100 }
19101 return resultobj;
19102 fail:
19103 return NULL;
19104 }
19105
19106
19107 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj;
19109 wxImageList *arg1 = (wxImageList *) 0 ;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 delete arg1;
19121
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 Py_INCREF(Py_None); resultobj = Py_None;
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj;
19134 wxImageList *arg1 = (wxImageList *) 0 ;
19135 wxBitmap *arg2 = 0 ;
19136 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19137 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19138 int result;
19139 PyObject * obj0 = 0 ;
19140 PyObject * obj1 = 0 ;
19141 PyObject * obj2 = 0 ;
19142 char *kwnames[] = {
19143 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19144 };
19145
19146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19148 if (SWIG_arg_fail(1)) SWIG_fail;
19149 {
19150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19151 if (SWIG_arg_fail(2)) SWIG_fail;
19152 if (arg2 == NULL) {
19153 SWIG_null_ref("wxBitmap");
19154 }
19155 if (SWIG_arg_fail(2)) SWIG_fail;
19156 }
19157 if (obj2) {
19158 {
19159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19160 if (SWIG_arg_fail(3)) SWIG_fail;
19161 if (arg3 == NULL) {
19162 SWIG_null_ref("wxBitmap");
19163 }
19164 if (SWIG_arg_fail(3)) SWIG_fail;
19165 }
19166 }
19167 {
19168 PyThreadState* __tstate = wxPyBeginAllowThreads();
19169 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19170
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 {
19175 resultobj = SWIG_From_int((int)(result));
19176 }
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj;
19185 wxImageList *arg1 = (wxImageList *) 0 ;
19186 wxBitmap *arg2 = 0 ;
19187 wxColour *arg3 = 0 ;
19188 int result;
19189 wxColour temp3 ;
19190 PyObject * obj0 = 0 ;
19191 PyObject * obj1 = 0 ;
19192 PyObject * obj2 = 0 ;
19193 char *kwnames[] = {
19194 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19195 };
19196
19197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19199 if (SWIG_arg_fail(1)) SWIG_fail;
19200 {
19201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19202 if (SWIG_arg_fail(2)) SWIG_fail;
19203 if (arg2 == NULL) {
19204 SWIG_null_ref("wxBitmap");
19205 }
19206 if (SWIG_arg_fail(2)) SWIG_fail;
19207 }
19208 {
19209 arg3 = &temp3;
19210 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19211 }
19212 {
19213 PyThreadState* __tstate = wxPyBeginAllowThreads();
19214 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19215
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 {
19220 resultobj = SWIG_From_int((int)(result));
19221 }
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj;
19230 wxImageList *arg1 = (wxImageList *) 0 ;
19231 wxIcon *arg2 = 0 ;
19232 int result;
19233 PyObject * obj0 = 0 ;
19234 PyObject * obj1 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "self",(char *) "icon", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19241 if (SWIG_arg_fail(1)) SWIG_fail;
19242 {
19243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19244 if (SWIG_arg_fail(2)) SWIG_fail;
19245 if (arg2 == NULL) {
19246 SWIG_null_ref("wxIcon");
19247 }
19248 if (SWIG_arg_fail(2)) SWIG_fail;
19249 }
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19253
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = SWIG_From_int((int)(result));
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj;
19268 wxImageList *arg1 = (wxImageList *) 0 ;
19269 int arg2 ;
19270 SwigValueWrapper<wxBitmap > result;
19271 PyObject * obj0 = 0 ;
19272 PyObject * obj1 = 0 ;
19273 char *kwnames[] = {
19274 (char *) "self",(char *) "index", NULL
19275 };
19276
19277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 {
19281 arg2 = (int)(SWIG_As_int(obj1));
19282 if (SWIG_arg_fail(2)) SWIG_fail;
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19287
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 {
19292 wxBitmap * resultptr;
19293 resultptr = new wxBitmap((wxBitmap &)(result));
19294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19295 }
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxImageList *arg1 = (wxImageList *) 0 ;
19305 int arg2 ;
19306 wxIcon result;
19307 PyObject * obj0 = 0 ;
19308 PyObject * obj1 = 0 ;
19309 char *kwnames[] = {
19310 (char *) "self",(char *) "index", NULL
19311 };
19312
19313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19315 if (SWIG_arg_fail(1)) SWIG_fail;
19316 {
19317 arg2 = (int)(SWIG_As_int(obj1));
19318 if (SWIG_arg_fail(2)) SWIG_fail;
19319 }
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 result = ((wxImageList const *)arg1)->GetIcon(arg2);
19323
19324 wxPyEndAllowThreads(__tstate);
19325 if (PyErr_Occurred()) SWIG_fail;
19326 }
19327 {
19328 wxIcon * resultptr;
19329 resultptr = new wxIcon((wxIcon &)(result));
19330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19331 }
19332 return resultobj;
19333 fail:
19334 return NULL;
19335 }
19336
19337
19338 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19339 PyObject *resultobj;
19340 wxImageList *arg1 = (wxImageList *) 0 ;
19341 int arg2 ;
19342 wxBitmap *arg3 = 0 ;
19343 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19344 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19345 bool result;
19346 PyObject * obj0 = 0 ;
19347 PyObject * obj1 = 0 ;
19348 PyObject * obj2 = 0 ;
19349 PyObject * obj3 = 0 ;
19350 char *kwnames[] = {
19351 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19352 };
19353
19354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19356 if (SWIG_arg_fail(1)) SWIG_fail;
19357 {
19358 arg2 = (int)(SWIG_As_int(obj1));
19359 if (SWIG_arg_fail(2)) SWIG_fail;
19360 }
19361 {
19362 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19363 if (SWIG_arg_fail(3)) SWIG_fail;
19364 if (arg3 == NULL) {
19365 SWIG_null_ref("wxBitmap");
19366 }
19367 if (SWIG_arg_fail(3)) SWIG_fail;
19368 }
19369 if (obj3) {
19370 {
19371 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19372 if (SWIG_arg_fail(4)) SWIG_fail;
19373 if (arg4 == NULL) {
19374 SWIG_null_ref("wxBitmap");
19375 }
19376 if (SWIG_arg_fail(4)) SWIG_fail;
19377 }
19378 }
19379 {
19380 PyThreadState* __tstate = wxPyBeginAllowThreads();
19381 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19382
19383 wxPyEndAllowThreads(__tstate);
19384 if (PyErr_Occurred()) SWIG_fail;
19385 }
19386 {
19387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19388 }
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj;
19397 wxImageList *arg1 = (wxImageList *) 0 ;
19398 int arg2 ;
19399 wxDC *arg3 = 0 ;
19400 int arg4 ;
19401 int arg5 ;
19402 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19403 bool arg7 = (bool) (bool)false ;
19404 bool result;
19405 PyObject * obj0 = 0 ;
19406 PyObject * obj1 = 0 ;
19407 PyObject * obj2 = 0 ;
19408 PyObject * obj3 = 0 ;
19409 PyObject * obj4 = 0 ;
19410 PyObject * obj5 = 0 ;
19411 PyObject * obj6 = 0 ;
19412 char *kwnames[] = {
19413 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19414 };
19415
19416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19418 if (SWIG_arg_fail(1)) SWIG_fail;
19419 {
19420 arg2 = (int)(SWIG_As_int(obj1));
19421 if (SWIG_arg_fail(2)) SWIG_fail;
19422 }
19423 {
19424 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19425 if (SWIG_arg_fail(3)) SWIG_fail;
19426 if (arg3 == NULL) {
19427 SWIG_null_ref("wxDC");
19428 }
19429 if (SWIG_arg_fail(3)) SWIG_fail;
19430 }
19431 {
19432 arg4 = (int)(SWIG_As_int(obj3));
19433 if (SWIG_arg_fail(4)) SWIG_fail;
19434 }
19435 {
19436 arg5 = (int)(SWIG_As_int(obj4));
19437 if (SWIG_arg_fail(5)) SWIG_fail;
19438 }
19439 if (obj5) {
19440 {
19441 arg6 = (int)(SWIG_As_int(obj5));
19442 if (SWIG_arg_fail(6)) SWIG_fail;
19443 }
19444 }
19445 if (obj6) {
19446 {
19447 arg7 = (bool const)(SWIG_As_bool(obj6));
19448 if (SWIG_arg_fail(7)) SWIG_fail;
19449 }
19450 }
19451 {
19452 PyThreadState* __tstate = wxPyBeginAllowThreads();
19453 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19454
19455 wxPyEndAllowThreads(__tstate);
19456 if (PyErr_Occurred()) SWIG_fail;
19457 }
19458 {
19459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19460 }
19461 return resultobj;
19462 fail:
19463 return NULL;
19464 }
19465
19466
19467 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 wxImageList *arg1 = (wxImageList *) 0 ;
19470 int result;
19471 PyObject * obj0 = 0 ;
19472 char *kwnames[] = {
19473 (char *) "self", NULL
19474 };
19475
19476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(1)) SWIG_fail;
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 result = (int)(arg1)->GetImageCount();
19482
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 {
19487 resultobj = SWIG_From_int((int)(result));
19488 }
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19496 PyObject *resultobj;
19497 wxImageList *arg1 = (wxImageList *) 0 ;
19498 int arg2 ;
19499 bool result;
19500 PyObject * obj0 = 0 ;
19501 PyObject * obj1 = 0 ;
19502 char *kwnames[] = {
19503 (char *) "self",(char *) "index", NULL
19504 };
19505
19506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19508 if (SWIG_arg_fail(1)) SWIG_fail;
19509 {
19510 arg2 = (int)(SWIG_As_int(obj1));
19511 if (SWIG_arg_fail(2)) SWIG_fail;
19512 }
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 result = (bool)(arg1)->Remove(arg2);
19516
19517 wxPyEndAllowThreads(__tstate);
19518 if (PyErr_Occurred()) SWIG_fail;
19519 }
19520 {
19521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxImageList *arg1 = (wxImageList *) 0 ;
19532 bool result;
19533 PyObject * obj0 = 0 ;
19534 char *kwnames[] = {
19535 (char *) "self", NULL
19536 };
19537
19538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19540 if (SWIG_arg_fail(1)) SWIG_fail;
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 result = (bool)(arg1)->RemoveAll();
19544
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 {
19549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19550 }
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19558 PyObject *resultobj;
19559 wxImageList *arg1 = (wxImageList *) 0 ;
19560 int arg2 ;
19561 int *arg3 = 0 ;
19562 int *arg4 = 0 ;
19563 int temp3 ;
19564 int res3 = 0 ;
19565 int temp4 ;
19566 int res4 = 0 ;
19567 PyObject * obj0 = 0 ;
19568 PyObject * obj1 = 0 ;
19569 char *kwnames[] = {
19570 (char *) "self",(char *) "index", NULL
19571 };
19572
19573 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19574 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 arg2 = (int)(SWIG_As_int(obj1));
19580 if (SWIG_arg_fail(2)) SWIG_fail;
19581 }
19582 {
19583 PyThreadState* __tstate = wxPyBeginAllowThreads();
19584 (arg1)->GetSize(arg2,*arg3,*arg4);
19585
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 Py_INCREF(Py_None); resultobj = Py_None;
19590 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19591 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19592 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19593 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19601 PyObject *obj;
19602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19603 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19604 Py_INCREF(obj);
19605 return Py_BuildValue((char *)"");
19606 }
19607 static int _wrap_NORMAL_FONT_set(PyObject *) {
19608 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19609 return 1;
19610 }
19611
19612
19613 static PyObject *_wrap_NORMAL_FONT_get(void) {
19614 PyObject *pyobj;
19615
19616 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19617 return pyobj;
19618 }
19619
19620
19621 static int _wrap_SMALL_FONT_set(PyObject *) {
19622 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19623 return 1;
19624 }
19625
19626
19627 static PyObject *_wrap_SMALL_FONT_get(void) {
19628 PyObject *pyobj;
19629
19630 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19631 return pyobj;
19632 }
19633
19634
19635 static int _wrap_ITALIC_FONT_set(PyObject *) {
19636 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19637 return 1;
19638 }
19639
19640
19641 static PyObject *_wrap_ITALIC_FONT_get(void) {
19642 PyObject *pyobj;
19643
19644 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19645 return pyobj;
19646 }
19647
19648
19649 static int _wrap_SWISS_FONT_set(PyObject *) {
19650 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19651 return 1;
19652 }
19653
19654
19655 static PyObject *_wrap_SWISS_FONT_get(void) {
19656 PyObject *pyobj;
19657
19658 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19659 return pyobj;
19660 }
19661
19662
19663 static int _wrap_RED_PEN_set(PyObject *) {
19664 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19665 return 1;
19666 }
19667
19668
19669 static PyObject *_wrap_RED_PEN_get(void) {
19670 PyObject *pyobj;
19671
19672 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19673 return pyobj;
19674 }
19675
19676
19677 static int _wrap_CYAN_PEN_set(PyObject *) {
19678 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19679 return 1;
19680 }
19681
19682
19683 static PyObject *_wrap_CYAN_PEN_get(void) {
19684 PyObject *pyobj;
19685
19686 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19687 return pyobj;
19688 }
19689
19690
19691 static int _wrap_GREEN_PEN_set(PyObject *) {
19692 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19693 return 1;
19694 }
19695
19696
19697 static PyObject *_wrap_GREEN_PEN_get(void) {
19698 PyObject *pyobj;
19699
19700 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19701 return pyobj;
19702 }
19703
19704
19705 static int _wrap_BLACK_PEN_set(PyObject *) {
19706 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19707 return 1;
19708 }
19709
19710
19711 static PyObject *_wrap_BLACK_PEN_get(void) {
19712 PyObject *pyobj;
19713
19714 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19715 return pyobj;
19716 }
19717
19718
19719 static int _wrap_WHITE_PEN_set(PyObject *) {
19720 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19721 return 1;
19722 }
19723
19724
19725 static PyObject *_wrap_WHITE_PEN_get(void) {
19726 PyObject *pyobj;
19727
19728 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19729 return pyobj;
19730 }
19731
19732
19733 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19734 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19735 return 1;
19736 }
19737
19738
19739 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19740 PyObject *pyobj;
19741
19742 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19743 return pyobj;
19744 }
19745
19746
19747 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19748 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19749 return 1;
19750 }
19751
19752
19753 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19754 PyObject *pyobj;
19755
19756 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19757 return pyobj;
19758 }
19759
19760
19761 static int _wrap_GREY_PEN_set(PyObject *) {
19762 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19763 return 1;
19764 }
19765
19766
19767 static PyObject *_wrap_GREY_PEN_get(void) {
19768 PyObject *pyobj;
19769
19770 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19771 return pyobj;
19772 }
19773
19774
19775 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19776 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19777 return 1;
19778 }
19779
19780
19781 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19782 PyObject *pyobj;
19783
19784 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19785 return pyobj;
19786 }
19787
19788
19789 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19790 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19791 return 1;
19792 }
19793
19794
19795 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19796 PyObject *pyobj;
19797
19798 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19799 return pyobj;
19800 }
19801
19802
19803 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19804 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19805 return 1;
19806 }
19807
19808
19809 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19810 PyObject *pyobj;
19811
19812 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19813 return pyobj;
19814 }
19815
19816
19817 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19818 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19819 return 1;
19820 }
19821
19822
19823 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19824 PyObject *pyobj;
19825
19826 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19827 return pyobj;
19828 }
19829
19830
19831 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19832 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19833 return 1;
19834 }
19835
19836
19837 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19838 PyObject *pyobj;
19839
19840 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19841 return pyobj;
19842 }
19843
19844
19845 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19846 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19847 return 1;
19848 }
19849
19850
19851 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19852 PyObject *pyobj;
19853
19854 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19855 return pyobj;
19856 }
19857
19858
19859 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19860 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19861 return 1;
19862 }
19863
19864
19865 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19866 PyObject *pyobj;
19867
19868 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19869 return pyobj;
19870 }
19871
19872
19873 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19874 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19875 return 1;
19876 }
19877
19878
19879 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19880 PyObject *pyobj;
19881
19882 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19883 return pyobj;
19884 }
19885
19886
19887 static int _wrap_RED_BRUSH_set(PyObject *) {
19888 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19889 return 1;
19890 }
19891
19892
19893 static PyObject *_wrap_RED_BRUSH_get(void) {
19894 PyObject *pyobj;
19895
19896 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19897 return pyobj;
19898 }
19899
19900
19901 static int _wrap_GREY_BRUSH_set(PyObject *) {
19902 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19903 return 1;
19904 }
19905
19906
19907 static PyObject *_wrap_GREY_BRUSH_get(void) {
19908 PyObject *pyobj;
19909
19910 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19911 return pyobj;
19912 }
19913
19914
19915 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19916 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19917 return 1;
19918 }
19919
19920
19921 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19922 PyObject *pyobj;
19923
19924 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19925 return pyobj;
19926 }
19927
19928
19929 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19930 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19931 return 1;
19932 }
19933
19934
19935 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19936 PyObject *pyobj;
19937
19938 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19939 return pyobj;
19940 }
19941
19942
19943 static int _wrap_BLACK_set(PyObject *) {
19944 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19945 return 1;
19946 }
19947
19948
19949 static PyObject *_wrap_BLACK_get(void) {
19950 PyObject *pyobj;
19951
19952 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19953 return pyobj;
19954 }
19955
19956
19957 static int _wrap_WHITE_set(PyObject *) {
19958 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19959 return 1;
19960 }
19961
19962
19963 static PyObject *_wrap_WHITE_get(void) {
19964 PyObject *pyobj;
19965
19966 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19967 return pyobj;
19968 }
19969
19970
19971 static int _wrap_RED_set(PyObject *) {
19972 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19973 return 1;
19974 }
19975
19976
19977 static PyObject *_wrap_RED_get(void) {
19978 PyObject *pyobj;
19979
19980 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19981 return pyobj;
19982 }
19983
19984
19985 static int _wrap_BLUE_set(PyObject *) {
19986 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19987 return 1;
19988 }
19989
19990
19991 static PyObject *_wrap_BLUE_get(void) {
19992 PyObject *pyobj;
19993
19994 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19995 return pyobj;
19996 }
19997
19998
19999 static int _wrap_GREEN_set(PyObject *) {
20000 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
20001 return 1;
20002 }
20003
20004
20005 static PyObject *_wrap_GREEN_get(void) {
20006 PyObject *pyobj;
20007
20008 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
20009 return pyobj;
20010 }
20011
20012
20013 static int _wrap_CYAN_set(PyObject *) {
20014 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
20015 return 1;
20016 }
20017
20018
20019 static PyObject *_wrap_CYAN_get(void) {
20020 PyObject *pyobj;
20021
20022 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
20023 return pyobj;
20024 }
20025
20026
20027 static int _wrap_LIGHT_GREY_set(PyObject *) {
20028 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
20029 return 1;
20030 }
20031
20032
20033 static PyObject *_wrap_LIGHT_GREY_get(void) {
20034 PyObject *pyobj;
20035
20036 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20037 return pyobj;
20038 }
20039
20040
20041 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20042 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20043 return 1;
20044 }
20045
20046
20047 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20048 PyObject *pyobj;
20049
20050 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20051 return pyobj;
20052 }
20053
20054
20055 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20056 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20057 return 1;
20058 }
20059
20060
20061 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20062 PyObject *pyobj;
20063
20064 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20065 return pyobj;
20066 }
20067
20068
20069 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20070 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20071 return 1;
20072 }
20073
20074
20075 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20076 PyObject *pyobj;
20077
20078 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20079 return pyobj;
20080 }
20081
20082
20083 static int _wrap_NullBitmap_set(PyObject *) {
20084 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20085 return 1;
20086 }
20087
20088
20089 static PyObject *_wrap_NullBitmap_get(void) {
20090 PyObject *pyobj;
20091
20092 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20093 return pyobj;
20094 }
20095
20096
20097 static int _wrap_NullIcon_set(PyObject *) {
20098 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20099 return 1;
20100 }
20101
20102
20103 static PyObject *_wrap_NullIcon_get(void) {
20104 PyObject *pyobj;
20105
20106 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20107 return pyobj;
20108 }
20109
20110
20111 static int _wrap_NullCursor_set(PyObject *) {
20112 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20113 return 1;
20114 }
20115
20116
20117 static PyObject *_wrap_NullCursor_get(void) {
20118 PyObject *pyobj;
20119
20120 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20121 return pyobj;
20122 }
20123
20124
20125 static int _wrap_NullPen_set(PyObject *) {
20126 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20127 return 1;
20128 }
20129
20130
20131 static PyObject *_wrap_NullPen_get(void) {
20132 PyObject *pyobj;
20133
20134 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20135 return pyobj;
20136 }
20137
20138
20139 static int _wrap_NullBrush_set(PyObject *) {
20140 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20141 return 1;
20142 }
20143
20144
20145 static PyObject *_wrap_NullBrush_get(void) {
20146 PyObject *pyobj;
20147
20148 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20149 return pyobj;
20150 }
20151
20152
20153 static int _wrap_NullPalette_set(PyObject *) {
20154 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20155 return 1;
20156 }
20157
20158
20159 static PyObject *_wrap_NullPalette_get(void) {
20160 PyObject *pyobj;
20161
20162 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20163 return pyobj;
20164 }
20165
20166
20167 static int _wrap_NullFont_set(PyObject *) {
20168 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20169 return 1;
20170 }
20171
20172
20173 static PyObject *_wrap_NullFont_get(void) {
20174 PyObject *pyobj;
20175
20176 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20177 return pyobj;
20178 }
20179
20180
20181 static int _wrap_NullColour_set(PyObject *) {
20182 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20183 return 1;
20184 }
20185
20186
20187 static PyObject *_wrap_NullColour_get(void) {
20188 PyObject *pyobj;
20189
20190 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20191 return pyobj;
20192 }
20193
20194
20195 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj;
20197 wxPenList *arg1 = (wxPenList *) 0 ;
20198 wxPen *arg2 = (wxPen *) 0 ;
20199 PyObject * obj0 = 0 ;
20200 PyObject * obj1 = 0 ;
20201 char *kwnames[] = {
20202 (char *) "self",(char *) "pen", NULL
20203 };
20204
20205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20207 if (SWIG_arg_fail(1)) SWIG_fail;
20208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20209 if (SWIG_arg_fail(2)) SWIG_fail;
20210 {
20211 PyThreadState* __tstate = wxPyBeginAllowThreads();
20212 (arg1)->AddPen(arg2);
20213
20214 wxPyEndAllowThreads(__tstate);
20215 if (PyErr_Occurred()) SWIG_fail;
20216 }
20217 Py_INCREF(Py_None); resultobj = Py_None;
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20225 PyObject *resultobj;
20226 wxPenList *arg1 = (wxPenList *) 0 ;
20227 wxColour *arg2 = 0 ;
20228 int arg3 ;
20229 int arg4 ;
20230 wxPen *result;
20231 wxColour temp2 ;
20232 PyObject * obj0 = 0 ;
20233 PyObject * obj1 = 0 ;
20234 PyObject * obj2 = 0 ;
20235 PyObject * obj3 = 0 ;
20236 char *kwnames[] = {
20237 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20238 };
20239
20240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20242 if (SWIG_arg_fail(1)) SWIG_fail;
20243 {
20244 arg2 = &temp2;
20245 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20246 }
20247 {
20248 arg3 = (int)(SWIG_As_int(obj2));
20249 if (SWIG_arg_fail(3)) SWIG_fail;
20250 }
20251 {
20252 arg4 = (int)(SWIG_As_int(obj3));
20253 if (SWIG_arg_fail(4)) SWIG_fail;
20254 }
20255 {
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20258
20259 wxPyEndAllowThreads(__tstate);
20260 if (PyErr_Occurred()) SWIG_fail;
20261 }
20262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxPenList *arg1 = (wxPenList *) 0 ;
20272 wxPen *arg2 = (wxPen *) 0 ;
20273 PyObject * obj0 = 0 ;
20274 PyObject * obj1 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self",(char *) "pen", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20283 if (SWIG_arg_fail(2)) SWIG_fail;
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 (arg1)->RemovePen(arg2);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 Py_INCREF(Py_None); resultobj = Py_None;
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxPenList *arg1 = (wxPenList *) 0 ;
20301 int result;
20302 PyObject * obj0 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (int)(arg1)->GetCount();
20313
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 {
20318 resultobj = SWIG_From_int((int)(result));
20319 }
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20327 PyObject *obj;
20328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20329 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20330 Py_INCREF(obj);
20331 return Py_BuildValue((char *)"");
20332 }
20333 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj;
20335 wxBrushList *arg1 = (wxBrushList *) 0 ;
20336 wxBrush *arg2 = (wxBrush *) 0 ;
20337 PyObject * obj0 = 0 ;
20338 PyObject * obj1 = 0 ;
20339 char *kwnames[] = {
20340 (char *) "self",(char *) "brush", NULL
20341 };
20342
20343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20345 if (SWIG_arg_fail(1)) SWIG_fail;
20346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(2)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 (arg1)->AddBrush(arg2);
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 Py_INCREF(Py_None); resultobj = Py_None;
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj;
20364 wxBrushList *arg1 = (wxBrushList *) 0 ;
20365 wxColour *arg2 = 0 ;
20366 int arg3 = (int) wxSOLID ;
20367 wxBrush *result;
20368 wxColour temp2 ;
20369 PyObject * obj0 = 0 ;
20370 PyObject * obj1 = 0 ;
20371 PyObject * obj2 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self",(char *) "colour",(char *) "style", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 arg2 = &temp2;
20381 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20382 }
20383 if (obj2) {
20384 {
20385 arg3 = (int)(SWIG_As_int(obj2));
20386 if (SWIG_arg_fail(3)) SWIG_fail;
20387 }
20388 }
20389 {
20390 PyThreadState* __tstate = wxPyBeginAllowThreads();
20391 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20392
20393 wxPyEndAllowThreads(__tstate);
20394 if (PyErr_Occurred()) SWIG_fail;
20395 }
20396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20404 PyObject *resultobj;
20405 wxBrushList *arg1 = (wxBrushList *) 0 ;
20406 wxBrush *arg2 = (wxBrush *) 0 ;
20407 PyObject * obj0 = 0 ;
20408 PyObject * obj1 = 0 ;
20409 char *kwnames[] = {
20410 (char *) "self",(char *) "brush", NULL
20411 };
20412
20413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20415 if (SWIG_arg_fail(1)) SWIG_fail;
20416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20417 if (SWIG_arg_fail(2)) SWIG_fail;
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 (arg1)->RemoveBrush(arg2);
20421
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 Py_INCREF(Py_None); resultobj = Py_None;
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20433 PyObject *resultobj;
20434 wxBrushList *arg1 = (wxBrushList *) 0 ;
20435 int result;
20436 PyObject * obj0 = 0 ;
20437 char *kwnames[] = {
20438 (char *) "self", NULL
20439 };
20440
20441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20443 if (SWIG_arg_fail(1)) SWIG_fail;
20444 {
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 result = (int)(arg1)->GetCount();
20447
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 {
20452 resultobj = SWIG_From_int((int)(result));
20453 }
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20461 PyObject *obj;
20462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20463 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20464 Py_INCREF(obj);
20465 return Py_BuildValue((char *)"");
20466 }
20467 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20468 PyObject *resultobj;
20469 wxColourDatabase *result;
20470 char *kwnames[] = {
20471 NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20475 {
20476 if (!wxPyCheckForApp()) SWIG_fail;
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 result = (wxColourDatabase *)new wxColourDatabase();
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj;
20492 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20493 PyObject * obj0 = 0 ;
20494 char *kwnames[] = {
20495 (char *) "self", NULL
20496 };
20497
20498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20500 if (SWIG_arg_fail(1)) SWIG_fail;
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 delete arg1;
20504
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 Py_INCREF(Py_None); resultobj = Py_None;
20509 return resultobj;
20510 fail:
20511 return NULL;
20512 }
20513
20514
20515 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20516 PyObject *resultobj;
20517 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20518 wxString *arg2 = 0 ;
20519 wxColour result;
20520 bool temp2 = false ;
20521 PyObject * obj0 = 0 ;
20522 PyObject * obj1 = 0 ;
20523 char *kwnames[] = {
20524 (char *) "self",(char *) "name", NULL
20525 };
20526
20527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20529 if (SWIG_arg_fail(1)) SWIG_fail;
20530 {
20531 arg2 = wxString_in_helper(obj1);
20532 if (arg2 == NULL) SWIG_fail;
20533 temp2 = true;
20534 }
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 {
20543 wxColour * resultptr;
20544 resultptr = new wxColour((wxColour &)(result));
20545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20546 }
20547 {
20548 if (temp2)
20549 delete arg2;
20550 }
20551 return resultobj;
20552 fail:
20553 {
20554 if (temp2)
20555 delete arg2;
20556 }
20557 return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj;
20563 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20564 wxColour *arg2 = 0 ;
20565 wxString result;
20566 wxColour temp2 ;
20567 PyObject * obj0 = 0 ;
20568 PyObject * obj1 = 0 ;
20569 char *kwnames[] = {
20570 (char *) "self",(char *) "colour", NULL
20571 };
20572
20573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20575 if (SWIG_arg_fail(1)) SWIG_fail;
20576 {
20577 arg2 = &temp2;
20578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20579 }
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20583
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 {
20588 #if wxUSE_UNICODE
20589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20590 #else
20591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20592 #endif
20593 }
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj;
20602 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20603 wxString *arg2 = 0 ;
20604 wxColour *arg3 = 0 ;
20605 bool temp2 = false ;
20606 wxColour temp3 ;
20607 PyObject * obj0 = 0 ;
20608 PyObject * obj1 = 0 ;
20609 PyObject * obj2 = 0 ;
20610 char *kwnames[] = {
20611 (char *) "self",(char *) "name",(char *) "colour", NULL
20612 };
20613
20614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20616 if (SWIG_arg_fail(1)) SWIG_fail;
20617 {
20618 arg2 = wxString_in_helper(obj1);
20619 if (arg2 == NULL) SWIG_fail;
20620 temp2 = true;
20621 }
20622 {
20623 arg3 = &temp3;
20624 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20625 }
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20629
20630 wxPyEndAllowThreads(__tstate);
20631 if (PyErr_Occurred()) SWIG_fail;
20632 }
20633 Py_INCREF(Py_None); resultobj = Py_None;
20634 {
20635 if (temp2)
20636 delete arg2;
20637 }
20638 return resultobj;
20639 fail:
20640 {
20641 if (temp2)
20642 delete arg2;
20643 }
20644 return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj;
20650 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20651 wxString *arg2 = 0 ;
20652 int arg3 ;
20653 int arg4 ;
20654 int arg5 ;
20655 bool temp2 = false ;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 PyObject * obj2 = 0 ;
20659 PyObject * obj3 = 0 ;
20660 PyObject * obj4 = 0 ;
20661 char *kwnames[] = {
20662 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20663 };
20664
20665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20667 if (SWIG_arg_fail(1)) SWIG_fail;
20668 {
20669 arg2 = wxString_in_helper(obj1);
20670 if (arg2 == NULL) SWIG_fail;
20671 temp2 = true;
20672 }
20673 {
20674 arg3 = (int)(SWIG_As_int(obj2));
20675 if (SWIG_arg_fail(3)) SWIG_fail;
20676 }
20677 {
20678 arg4 = (int)(SWIG_As_int(obj3));
20679 if (SWIG_arg_fail(4)) SWIG_fail;
20680 }
20681 {
20682 arg5 = (int)(SWIG_As_int(obj4));
20683 if (SWIG_arg_fail(5)) SWIG_fail;
20684 }
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20688
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 Py_INCREF(Py_None); resultobj = Py_None;
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 return resultobj;
20698 fail:
20699 {
20700 if (temp2)
20701 delete arg2;
20702 }
20703 return NULL;
20704 }
20705
20706
20707 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20708 PyObject *obj;
20709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20710 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20711 Py_INCREF(obj);
20712 return Py_BuildValue((char *)"");
20713 }
20714 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj;
20716 wxFontList *arg1 = (wxFontList *) 0 ;
20717 wxFont *arg2 = (wxFont *) 0 ;
20718 PyObject * obj0 = 0 ;
20719 PyObject * obj1 = 0 ;
20720 char *kwnames[] = {
20721 (char *) "self",(char *) "font", NULL
20722 };
20723
20724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(2)) SWIG_fail;
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 (arg1)->AddFont(arg2);
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 Py_INCREF(Py_None); resultobj = Py_None;
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj;
20745 wxFontList *arg1 = (wxFontList *) 0 ;
20746 int arg2 ;
20747 int arg3 ;
20748 int arg4 ;
20749 int arg5 ;
20750 bool arg6 = (bool) false ;
20751 wxString const &arg7_defvalue = wxPyEmptyString ;
20752 wxString *arg7 = (wxString *) &arg7_defvalue ;
20753 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20754 wxFont *result;
20755 bool temp7 = false ;
20756 PyObject * obj0 = 0 ;
20757 PyObject * obj1 = 0 ;
20758 PyObject * obj2 = 0 ;
20759 PyObject * obj3 = 0 ;
20760 PyObject * obj4 = 0 ;
20761 PyObject * obj5 = 0 ;
20762 PyObject * obj6 = 0 ;
20763 PyObject * obj7 = 0 ;
20764 char *kwnames[] = {
20765 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20766 };
20767
20768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20770 if (SWIG_arg_fail(1)) SWIG_fail;
20771 {
20772 arg2 = (int)(SWIG_As_int(obj1));
20773 if (SWIG_arg_fail(2)) SWIG_fail;
20774 }
20775 {
20776 arg3 = (int)(SWIG_As_int(obj2));
20777 if (SWIG_arg_fail(3)) SWIG_fail;
20778 }
20779 {
20780 arg4 = (int)(SWIG_As_int(obj3));
20781 if (SWIG_arg_fail(4)) SWIG_fail;
20782 }
20783 {
20784 arg5 = (int)(SWIG_As_int(obj4));
20785 if (SWIG_arg_fail(5)) SWIG_fail;
20786 }
20787 if (obj5) {
20788 {
20789 arg6 = (bool)(SWIG_As_bool(obj5));
20790 if (SWIG_arg_fail(6)) SWIG_fail;
20791 }
20792 }
20793 if (obj6) {
20794 {
20795 arg7 = wxString_in_helper(obj6);
20796 if (arg7 == NULL) SWIG_fail;
20797 temp7 = true;
20798 }
20799 }
20800 if (obj7) {
20801 {
20802 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20803 if (SWIG_arg_fail(8)) SWIG_fail;
20804 }
20805 }
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20809
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20814 {
20815 if (temp7)
20816 delete arg7;
20817 }
20818 return resultobj;
20819 fail:
20820 {
20821 if (temp7)
20822 delete arg7;
20823 }
20824 return NULL;
20825 }
20826
20827
20828 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj;
20830 wxFontList *arg1 = (wxFontList *) 0 ;
20831 wxFont *arg2 = (wxFont *) 0 ;
20832 PyObject * obj0 = 0 ;
20833 PyObject * obj1 = 0 ;
20834 char *kwnames[] = {
20835 (char *) "self",(char *) "font", NULL
20836 };
20837
20838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20840 if (SWIG_arg_fail(1)) SWIG_fail;
20841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(2)) SWIG_fail;
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 (arg1)->RemoveFont(arg2);
20846
20847 wxPyEndAllowThreads(__tstate);
20848 if (PyErr_Occurred()) SWIG_fail;
20849 }
20850 Py_INCREF(Py_None); resultobj = Py_None;
20851 return resultobj;
20852 fail:
20853 return NULL;
20854 }
20855
20856
20857 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20858 PyObject *resultobj;
20859 wxFontList *arg1 = (wxFontList *) 0 ;
20860 int result;
20861 PyObject * obj0 = 0 ;
20862 char *kwnames[] = {
20863 (char *) "self", NULL
20864 };
20865
20866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20868 if (SWIG_arg_fail(1)) SWIG_fail;
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (int)(arg1)->GetCount();
20872
20873 wxPyEndAllowThreads(__tstate);
20874 if (PyErr_Occurred()) SWIG_fail;
20875 }
20876 {
20877 resultobj = SWIG_From_int((int)(result));
20878 }
20879 return resultobj;
20880 fail:
20881 return NULL;
20882 }
20883
20884
20885 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20886 PyObject *obj;
20887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20888 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20889 Py_INCREF(obj);
20890 return Py_BuildValue((char *)"");
20891 }
20892 static int _wrap_TheFontList_set(PyObject *) {
20893 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20894 return 1;
20895 }
20896
20897
20898 static PyObject *_wrap_TheFontList_get(void) {
20899 PyObject *pyobj;
20900
20901 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20902 return pyobj;
20903 }
20904
20905
20906 static int _wrap_ThePenList_set(PyObject *) {
20907 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20908 return 1;
20909 }
20910
20911
20912 static PyObject *_wrap_ThePenList_get(void) {
20913 PyObject *pyobj;
20914
20915 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20916 return pyobj;
20917 }
20918
20919
20920 static int _wrap_TheBrushList_set(PyObject *) {
20921 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20922 return 1;
20923 }
20924
20925
20926 static PyObject *_wrap_TheBrushList_get(void) {
20927 PyObject *pyobj;
20928
20929 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20930 return pyobj;
20931 }
20932
20933
20934 static int _wrap_TheColourDatabase_set(PyObject *) {
20935 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20936 return 1;
20937 }
20938
20939
20940 static PyObject *_wrap_TheColourDatabase_get(void) {
20941 PyObject *pyobj;
20942
20943 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20944 return pyobj;
20945 }
20946
20947
20948 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj;
20950 wxEffects *result;
20951 char *kwnames[] = {
20952 NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (wxEffects *)new wxEffects();
20959
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxEffects *arg1 = (wxEffects *) 0 ;
20973 wxColour result;
20974 PyObject * obj0 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = ((wxEffects const *)arg1)->GetHighlightColour();
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 wxColour * resultptr;
20991 resultptr = new wxColour((wxColour &)(result));
20992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20993 }
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxEffects *arg1 = (wxEffects *) 0 ;
21003 wxColour result;
21004 PyObject * obj0 = 0 ;
21005 char *kwnames[] = {
21006 (char *) "self", NULL
21007 };
21008
21009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
21010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21011 if (SWIG_arg_fail(1)) SWIG_fail;
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 result = ((wxEffects const *)arg1)->GetLightShadow();
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 wxColour * resultptr;
21021 resultptr = new wxColour((wxColour &)(result));
21022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj;
21032 wxEffects *arg1 = (wxEffects *) 0 ;
21033 wxColour result;
21034 PyObject * obj0 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = ((wxEffects const *)arg1)->GetFaceColour();
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 wxColour * resultptr;
21051 resultptr = new wxColour((wxColour &)(result));
21052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxEffects *arg1 = (wxEffects *) 0 ;
21063 wxColour result;
21064 PyObject * obj0 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 PyThreadState* __tstate = wxPyBeginAllowThreads();
21074 result = ((wxEffects const *)arg1)->GetMediumShadow();
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 {
21080 wxColour * resultptr;
21081 resultptr = new wxColour((wxColour &)(result));
21082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21083 }
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21091 PyObject *resultobj;
21092 wxEffects *arg1 = (wxEffects *) 0 ;
21093 wxColour result;
21094 PyObject * obj0 = 0 ;
21095 char *kwnames[] = {
21096 (char *) "self", NULL
21097 };
21098
21099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21101 if (SWIG_arg_fail(1)) SWIG_fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = ((wxEffects const *)arg1)->GetDarkShadow();
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 wxColour * resultptr;
21111 resultptr = new wxColour((wxColour &)(result));
21112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21113 }
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21121 PyObject *resultobj;
21122 wxEffects *arg1 = (wxEffects *) 0 ;
21123 wxColour *arg2 = 0 ;
21124 wxColour temp2 ;
21125 PyObject * obj0 = 0 ;
21126 PyObject * obj1 = 0 ;
21127 char *kwnames[] = {
21128 (char *) "self",(char *) "c", NULL
21129 };
21130
21131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21133 if (SWIG_arg_fail(1)) SWIG_fail;
21134 {
21135 arg2 = &temp2;
21136 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21137 }
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 (arg1)->SetHighlightColour((wxColour const &)*arg2);
21141
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 Py_INCREF(Py_None); resultobj = Py_None;
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 wxEffects *arg1 = (wxEffects *) 0 ;
21155 wxColour *arg2 = 0 ;
21156 wxColour temp2 ;
21157 PyObject * obj0 = 0 ;
21158 PyObject * obj1 = 0 ;
21159 char *kwnames[] = {
21160 (char *) "self",(char *) "c", NULL
21161 };
21162
21163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21165 if (SWIG_arg_fail(1)) SWIG_fail;
21166 {
21167 arg2 = &temp2;
21168 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21169 }
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 (arg1)->SetLightShadow((wxColour const &)*arg2);
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 Py_INCREF(Py_None); resultobj = Py_None;
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj;
21186 wxEffects *arg1 = (wxEffects *) 0 ;
21187 wxColour *arg2 = 0 ;
21188 wxColour temp2 ;
21189 PyObject * obj0 = 0 ;
21190 PyObject * obj1 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self",(char *) "c", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 {
21199 arg2 = &temp2;
21200 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21201 }
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 (arg1)->SetFaceColour((wxColour const &)*arg2);
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 Py_INCREF(Py_None); resultobj = Py_None;
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxEffects *arg1 = (wxEffects *) 0 ;
21219 wxColour *arg2 = 0 ;
21220 wxColour temp2 ;
21221 PyObject * obj0 = 0 ;
21222 PyObject * obj1 = 0 ;
21223 char *kwnames[] = {
21224 (char *) "self",(char *) "c", NULL
21225 };
21226
21227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21229 if (SWIG_arg_fail(1)) SWIG_fail;
21230 {
21231 arg2 = &temp2;
21232 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21233 }
21234 {
21235 PyThreadState* __tstate = wxPyBeginAllowThreads();
21236 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21237
21238 wxPyEndAllowThreads(__tstate);
21239 if (PyErr_Occurred()) SWIG_fail;
21240 }
21241 Py_INCREF(Py_None); resultobj = Py_None;
21242 return resultobj;
21243 fail:
21244 return NULL;
21245 }
21246
21247
21248 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21249 PyObject *resultobj;
21250 wxEffects *arg1 = (wxEffects *) 0 ;
21251 wxColour *arg2 = 0 ;
21252 wxColour temp2 ;
21253 PyObject * obj0 = 0 ;
21254 PyObject * obj1 = 0 ;
21255 char *kwnames[] = {
21256 (char *) "self",(char *) "c", NULL
21257 };
21258
21259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21261 if (SWIG_arg_fail(1)) SWIG_fail;
21262 {
21263 arg2 = &temp2;
21264 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21265 }
21266 {
21267 PyThreadState* __tstate = wxPyBeginAllowThreads();
21268 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21269
21270 wxPyEndAllowThreads(__tstate);
21271 if (PyErr_Occurred()) SWIG_fail;
21272 }
21273 Py_INCREF(Py_None); resultobj = Py_None;
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21281 PyObject *resultobj;
21282 wxEffects *arg1 = (wxEffects *) 0 ;
21283 wxColour *arg2 = 0 ;
21284 wxColour *arg3 = 0 ;
21285 wxColour *arg4 = 0 ;
21286 wxColour *arg5 = 0 ;
21287 wxColour *arg6 = 0 ;
21288 wxColour temp2 ;
21289 wxColour temp3 ;
21290 wxColour temp4 ;
21291 wxColour temp5 ;
21292 wxColour temp6 ;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 PyObject * obj2 = 0 ;
21296 PyObject * obj3 = 0 ;
21297 PyObject * obj4 = 0 ;
21298 PyObject * obj5 = 0 ;
21299 char *kwnames[] = {
21300 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21301 };
21302
21303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21305 if (SWIG_arg_fail(1)) SWIG_fail;
21306 {
21307 arg2 = &temp2;
21308 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21309 }
21310 {
21311 arg3 = &temp3;
21312 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21313 }
21314 {
21315 arg4 = &temp4;
21316 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21317 }
21318 {
21319 arg5 = &temp5;
21320 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21321 }
21322 {
21323 arg6 = &temp6;
21324 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21325 }
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21329
21330 wxPyEndAllowThreads(__tstate);
21331 if (PyErr_Occurred()) SWIG_fail;
21332 }
21333 Py_INCREF(Py_None); resultobj = Py_None;
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxEffects *arg1 = (wxEffects *) 0 ;
21343 wxDC *arg2 = 0 ;
21344 wxRect *arg3 = 0 ;
21345 int arg4 = (int) 1 ;
21346 wxRect temp3 ;
21347 PyObject * obj0 = 0 ;
21348 PyObject * obj1 = 0 ;
21349 PyObject * obj2 = 0 ;
21350 PyObject * obj3 = 0 ;
21351 char *kwnames[] = {
21352 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21353 };
21354
21355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21357 if (SWIG_arg_fail(1)) SWIG_fail;
21358 {
21359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21360 if (SWIG_arg_fail(2)) SWIG_fail;
21361 if (arg2 == NULL) {
21362 SWIG_null_ref("wxDC");
21363 }
21364 if (SWIG_arg_fail(2)) SWIG_fail;
21365 }
21366 {
21367 arg3 = &temp3;
21368 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21369 }
21370 if (obj3) {
21371 {
21372 arg4 = (int)(SWIG_As_int(obj3));
21373 if (SWIG_arg_fail(4)) SWIG_fail;
21374 }
21375 }
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21379
21380 wxPyEndAllowThreads(__tstate);
21381 if (PyErr_Occurred()) SWIG_fail;
21382 }
21383 Py_INCREF(Py_None); resultobj = Py_None;
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21391 PyObject *resultobj;
21392 wxEffects *arg1 = (wxEffects *) 0 ;
21393 wxRect *arg2 = 0 ;
21394 wxDC *arg3 = 0 ;
21395 wxBitmap *arg4 = 0 ;
21396 bool result;
21397 wxRect temp2 ;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 PyObject * obj2 = 0 ;
21401 PyObject * obj3 = 0 ;
21402 char *kwnames[] = {
21403 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21404 };
21405
21406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21408 if (SWIG_arg_fail(1)) SWIG_fail;
21409 {
21410 arg2 = &temp2;
21411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21412 }
21413 {
21414 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(3)) SWIG_fail;
21416 if (arg3 == NULL) {
21417 SWIG_null_ref("wxDC");
21418 }
21419 if (SWIG_arg_fail(3)) SWIG_fail;
21420 }
21421 {
21422 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21423 if (SWIG_arg_fail(4)) SWIG_fail;
21424 if (arg4 == NULL) {
21425 SWIG_null_ref("wxBitmap");
21426 }
21427 if (SWIG_arg_fail(4)) SWIG_fail;
21428 }
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 {
21437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21438 }
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21446 PyObject *obj;
21447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21448 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21449 Py_INCREF(obj);
21450 return Py_BuildValue((char *)"");
21451 }
21452 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21453 PyObject *resultobj;
21454 int arg1 ;
21455 int arg2 ;
21456 bool arg3 ;
21457 wxSplitterRenderParams *result;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 PyObject * obj2 = 0 ;
21461 char *kwnames[] = {
21462 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
21463 };
21464
21465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
21466 {
21467 arg1 = (int)(SWIG_As_int(obj0));
21468 if (SWIG_arg_fail(1)) SWIG_fail;
21469 }
21470 {
21471 arg2 = (int)(SWIG_As_int(obj1));
21472 if (SWIG_arg_fail(2)) SWIG_fail;
21473 }
21474 {
21475 arg3 = (bool)(SWIG_As_bool(obj2));
21476 if (SWIG_arg_fail(3)) SWIG_fail;
21477 }
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
21481
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
21486 return resultobj;
21487 fail:
21488 return NULL;
21489 }
21490
21491
21492 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21493 PyObject *resultobj;
21494 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21495 PyObject * obj0 = 0 ;
21496 char *kwnames[] = {
21497 (char *) "self", NULL
21498 };
21499
21500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
21501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21502 if (SWIG_arg_fail(1)) SWIG_fail;
21503 {
21504 PyThreadState* __tstate = wxPyBeginAllowThreads();
21505 delete arg1;
21506
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 Py_INCREF(Py_None); resultobj = Py_None;
21511 return resultobj;
21512 fail:
21513 return NULL;
21514 }
21515
21516
21517 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
21518 PyObject *resultobj;
21519 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21520 int result;
21521 PyObject * obj0 = 0 ;
21522 char *kwnames[] = {
21523 (char *) "self", NULL
21524 };
21525
21526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
21527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21528 if (SWIG_arg_fail(1)) SWIG_fail;
21529 result = (int)(int) ((arg1)->widthSash);
21530
21531 {
21532 resultobj = SWIG_From_int((int)(result));
21533 }
21534 return resultobj;
21535 fail:
21536 return NULL;
21537 }
21538
21539
21540 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
21541 PyObject *resultobj;
21542 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21543 int result;
21544 PyObject * obj0 = 0 ;
21545 char *kwnames[] = {
21546 (char *) "self", NULL
21547 };
21548
21549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
21550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21551 if (SWIG_arg_fail(1)) SWIG_fail;
21552 result = (int)(int) ((arg1)->border);
21553
21554 {
21555 resultobj = SWIG_From_int((int)(result));
21556 }
21557 return resultobj;
21558 fail:
21559 return NULL;
21560 }
21561
21562
21563 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
21564 PyObject *resultobj;
21565 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21566 bool result;
21567 PyObject * obj0 = 0 ;
21568 char *kwnames[] = {
21569 (char *) "self", NULL
21570 };
21571
21572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
21573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21574 if (SWIG_arg_fail(1)) SWIG_fail;
21575 result = (bool)(bool) ((arg1)->isHotSensitive);
21576
21577 {
21578 resultobj = SWIG_From_bool((bool)(result));
21579 }
21580 return resultobj;
21581 fail:
21582 return NULL;
21583 }
21584
21585
21586 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
21587 PyObject *obj;
21588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21589 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
21590 Py_INCREF(obj);
21591 return Py_BuildValue((char *)"");
21592 }
21593 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21594 PyObject *resultobj;
21595 int arg1 ;
21596 int arg2 ;
21597 wxRendererVersion *result;
21598 PyObject * obj0 = 0 ;
21599 PyObject * obj1 = 0 ;
21600 char *kwnames[] = {
21601 (char *) "version_",(char *) "age_", NULL
21602 };
21603
21604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
21605 {
21606 arg1 = (int)(SWIG_As_int(obj0));
21607 if (SWIG_arg_fail(1)) SWIG_fail;
21608 }
21609 {
21610 arg2 = (int)(SWIG_As_int(obj1));
21611 if (SWIG_arg_fail(2)) SWIG_fail;
21612 }
21613 {
21614 PyThreadState* __tstate = wxPyBeginAllowThreads();
21615 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
21616
21617 wxPyEndAllowThreads(__tstate);
21618 if (PyErr_Occurred()) SWIG_fail;
21619 }
21620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
21621 return resultobj;
21622 fail:
21623 return NULL;
21624 }
21625
21626
21627 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21628 PyObject *resultobj;
21629 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21630 PyObject * obj0 = 0 ;
21631 char *kwnames[] = {
21632 (char *) "self", NULL
21633 };
21634
21635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
21636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21637 if (SWIG_arg_fail(1)) SWIG_fail;
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 delete arg1;
21641
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 Py_INCREF(Py_None); resultobj = Py_None;
21646 return resultobj;
21647 fail:
21648 return NULL;
21649 }
21650
21651
21652 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj;
21654 wxRendererVersion *arg1 = 0 ;
21655 bool result;
21656 PyObject * obj0 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "ver", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
21662 {
21663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(1)) SWIG_fail;
21665 if (arg1 == NULL) {
21666 SWIG_null_ref("wxRendererVersion");
21667 }
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
21673
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 {
21678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21679 }
21680 return resultobj;
21681 fail:
21682 return NULL;
21683 }
21684
21685
21686 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
21687 PyObject *resultobj;
21688 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21689 int result;
21690 PyObject * obj0 = 0 ;
21691 char *kwnames[] = {
21692 (char *) "self", NULL
21693 };
21694
21695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
21696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21697 if (SWIG_arg_fail(1)) SWIG_fail;
21698 result = (int)(int) ((arg1)->version);
21699
21700 {
21701 resultobj = SWIG_From_int((int)(result));
21702 }
21703 return resultobj;
21704 fail:
21705 return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
21710 PyObject *resultobj;
21711 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21712 int result;
21713 PyObject * obj0 = 0 ;
21714 char *kwnames[] = {
21715 (char *) "self", NULL
21716 };
21717
21718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
21719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21720 if (SWIG_arg_fail(1)) SWIG_fail;
21721 result = (int)(int) ((arg1)->age);
21722
21723 {
21724 resultobj = SWIG_From_int((int)(result));
21725 }
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
21733 PyObject *obj;
21734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21735 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
21736 Py_INCREF(obj);
21737 return Py_BuildValue((char *)"");
21738 }
21739 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj;
21741 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21742 wxWindow *arg2 = (wxWindow *) 0 ;
21743 wxDC *arg3 = 0 ;
21744 wxRect *arg4 = 0 ;
21745 int arg5 = (int) 0 ;
21746 wxRect temp4 ;
21747 PyObject * obj0 = 0 ;
21748 PyObject * obj1 = 0 ;
21749 PyObject * obj2 = 0 ;
21750 PyObject * obj3 = 0 ;
21751 PyObject * obj4 = 0 ;
21752 char *kwnames[] = {
21753 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21754 };
21755
21756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21758 if (SWIG_arg_fail(1)) SWIG_fail;
21759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 {
21762 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21763 if (SWIG_arg_fail(3)) SWIG_fail;
21764 if (arg3 == NULL) {
21765 SWIG_null_ref("wxDC");
21766 }
21767 if (SWIG_arg_fail(3)) SWIG_fail;
21768 }
21769 {
21770 arg4 = &temp4;
21771 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21772 }
21773 if (obj4) {
21774 {
21775 arg5 = (int)(SWIG_As_int(obj4));
21776 if (SWIG_arg_fail(5)) SWIG_fail;
21777 }
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 Py_INCREF(Py_None); resultobj = Py_None;
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21796 wxWindow *arg2 = (wxWindow *) 0 ;
21797 wxDC *arg3 = 0 ;
21798 wxRect *arg4 = 0 ;
21799 int arg5 = (int) 0 ;
21800 wxRect temp4 ;
21801 PyObject * obj0 = 0 ;
21802 PyObject * obj1 = 0 ;
21803 PyObject * obj2 = 0 ;
21804 PyObject * obj3 = 0 ;
21805 PyObject * obj4 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21814 if (SWIG_arg_fail(2)) SWIG_fail;
21815 {
21816 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(3)) SWIG_fail;
21818 if (arg3 == NULL) {
21819 SWIG_null_ref("wxDC");
21820 }
21821 if (SWIG_arg_fail(3)) SWIG_fail;
21822 }
21823 {
21824 arg4 = &temp4;
21825 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21826 }
21827 if (obj4) {
21828 {
21829 arg5 = (int)(SWIG_As_int(obj4));
21830 if (SWIG_arg_fail(5)) SWIG_fail;
21831 }
21832 }
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21836
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 Py_INCREF(Py_None); resultobj = Py_None;
21841 return resultobj;
21842 fail:
21843 return NULL;
21844 }
21845
21846
21847 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
21848 PyObject *resultobj;
21849 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21850 wxWindow *arg2 = (wxWindow *) 0 ;
21851 wxDC *arg3 = 0 ;
21852 wxRect *arg4 = 0 ;
21853 int arg5 = (int) 0 ;
21854 wxRect temp4 ;
21855 PyObject * obj0 = 0 ;
21856 PyObject * obj1 = 0 ;
21857 PyObject * obj2 = 0 ;
21858 PyObject * obj3 = 0 ;
21859 PyObject * obj4 = 0 ;
21860 char *kwnames[] = {
21861 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21862 };
21863
21864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21866 if (SWIG_arg_fail(1)) SWIG_fail;
21867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21868 if (SWIG_arg_fail(2)) SWIG_fail;
21869 {
21870 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21871 if (SWIG_arg_fail(3)) SWIG_fail;
21872 if (arg3 == NULL) {
21873 SWIG_null_ref("wxDC");
21874 }
21875 if (SWIG_arg_fail(3)) SWIG_fail;
21876 }
21877 {
21878 arg4 = &temp4;
21879 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21880 }
21881 if (obj4) {
21882 {
21883 arg5 = (int)(SWIG_As_int(obj4));
21884 if (SWIG_arg_fail(5)) SWIG_fail;
21885 }
21886 }
21887 {
21888 PyThreadState* __tstate = wxPyBeginAllowThreads();
21889 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21890
21891 wxPyEndAllowThreads(__tstate);
21892 if (PyErr_Occurred()) SWIG_fail;
21893 }
21894 Py_INCREF(Py_None); resultobj = Py_None;
21895 return resultobj;
21896 fail:
21897 return NULL;
21898 }
21899
21900
21901 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21902 PyObject *resultobj;
21903 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21904 wxWindow *arg2 = (wxWindow *) 0 ;
21905 wxDC *arg3 = 0 ;
21906 wxSize *arg4 = 0 ;
21907 int arg5 ;
21908 wxOrientation arg6 ;
21909 int arg7 = (int) 0 ;
21910 wxSize temp4 ;
21911 PyObject * obj0 = 0 ;
21912 PyObject * obj1 = 0 ;
21913 PyObject * obj2 = 0 ;
21914 PyObject * obj3 = 0 ;
21915 PyObject * obj4 = 0 ;
21916 PyObject * obj5 = 0 ;
21917 PyObject * obj6 = 0 ;
21918 char *kwnames[] = {
21919 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21920 };
21921
21922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21924 if (SWIG_arg_fail(1)) SWIG_fail;
21925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(2)) SWIG_fail;
21927 {
21928 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21929 if (SWIG_arg_fail(3)) SWIG_fail;
21930 if (arg3 == NULL) {
21931 SWIG_null_ref("wxDC");
21932 }
21933 if (SWIG_arg_fail(3)) SWIG_fail;
21934 }
21935 {
21936 arg4 = &temp4;
21937 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21938 }
21939 {
21940 arg5 = (int)(SWIG_As_int(obj4));
21941 if (SWIG_arg_fail(5)) SWIG_fail;
21942 }
21943 {
21944 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21945 if (SWIG_arg_fail(6)) SWIG_fail;
21946 }
21947 if (obj6) {
21948 {
21949 arg7 = (int)(SWIG_As_int(obj6));
21950 if (SWIG_arg_fail(7)) SWIG_fail;
21951 }
21952 }
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21956
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 Py_INCREF(Py_None); resultobj = Py_None;
21961 return resultobj;
21962 fail:
21963 return NULL;
21964 }
21965
21966
21967 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj;
21969 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21970 wxWindow *arg2 = (wxWindow *) 0 ;
21971 wxDC *arg3 = 0 ;
21972 wxRect *arg4 = 0 ;
21973 int arg5 = (int) 0 ;
21974 wxRect temp4 ;
21975 PyObject * obj0 = 0 ;
21976 PyObject * obj1 = 0 ;
21977 PyObject * obj2 = 0 ;
21978 PyObject * obj3 = 0 ;
21979 PyObject * obj4 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21988 if (SWIG_arg_fail(2)) SWIG_fail;
21989 {
21990 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(3)) SWIG_fail;
21992 if (arg3 == NULL) {
21993 SWIG_null_ref("wxDC");
21994 }
21995 if (SWIG_arg_fail(3)) SWIG_fail;
21996 }
21997 {
21998 arg4 = &temp4;
21999 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22000 }
22001 if (obj4) {
22002 {
22003 arg5 = (int)(SWIG_As_int(obj4));
22004 if (SWIG_arg_fail(5)) SWIG_fail;
22005 }
22006 }
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
22010
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 Py_INCREF(Py_None); resultobj = Py_None;
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj;
22023 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22024 wxWindow *arg2 = (wxWindow *) 0 ;
22025 wxDC *arg3 = 0 ;
22026 wxRect *arg4 = 0 ;
22027 int arg5 = (int) 0 ;
22028 wxRect temp4 ;
22029 PyObject * obj0 = 0 ;
22030 PyObject * obj1 = 0 ;
22031 PyObject * obj2 = 0 ;
22032 PyObject * obj3 = 0 ;
22033 PyObject * obj4 = 0 ;
22034 char *kwnames[] = {
22035 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
22036 };
22037
22038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
22039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22040 if (SWIG_arg_fail(1)) SWIG_fail;
22041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(2)) SWIG_fail;
22043 {
22044 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22045 if (SWIG_arg_fail(3)) SWIG_fail;
22046 if (arg3 == NULL) {
22047 SWIG_null_ref("wxDC");
22048 }
22049 if (SWIG_arg_fail(3)) SWIG_fail;
22050 }
22051 {
22052 arg4 = &temp4;
22053 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22054 }
22055 if (obj4) {
22056 {
22057 arg5 = (int)(SWIG_As_int(obj4));
22058 if (SWIG_arg_fail(5)) SWIG_fail;
22059 }
22060 }
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
22064
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 Py_INCREF(Py_None); resultobj = Py_None;
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj;
22077 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22078 wxWindow *arg2 = (wxWindow *) 0 ;
22079 SwigValueWrapper<wxSplitterRenderParams > result;
22080 PyObject * obj0 = 0 ;
22081 PyObject * obj1 = 0 ;
22082 char *kwnames[] = {
22083 (char *) "self",(char *) "win", NULL
22084 };
22085
22086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
22087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22088 if (SWIG_arg_fail(1)) SWIG_fail;
22089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22090 if (SWIG_arg_fail(2)) SWIG_fail;
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 {
22099 wxSplitterRenderParams * resultptr;
22100 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
22101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
22102 }
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj;
22111 wxRendererNative *result;
22112 char *kwnames[] = {
22113 NULL
22114 };
22115
22116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 {
22120 wxRendererNative &_result_ref = wxRendererNative::Get();
22121 result = (wxRendererNative *) &_result_ref;
22122 }
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxRendererNative *result;
22137 char *kwnames[] = {
22138 NULL
22139 };
22140
22141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 {
22145 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
22146 result = (wxRendererNative *) &_result_ref;
22147 }
22148
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
22160 PyObject *resultobj;
22161 wxRendererNative *result;
22162 char *kwnames[] = {
22163 NULL
22164 };
22165
22166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 {
22170 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
22171 result = (wxRendererNative *) &_result_ref;
22172 }
22173
22174 wxPyEndAllowThreads(__tstate);
22175 if (PyErr_Occurred()) SWIG_fail;
22176 }
22177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj;
22186 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22187 wxRendererNative *result;
22188 PyObject * obj0 = 0 ;
22189 char *kwnames[] = {
22190 (char *) "renderer", NULL
22191 };
22192
22193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
22194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22195 if (SWIG_arg_fail(1)) SWIG_fail;
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxRendererNative *)wxRendererNative::Set(arg1);
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22213 SwigValueWrapper<wxRendererVersion > result;
22214 PyObject * obj0 = 0 ;
22215 char *kwnames[] = {
22216 (char *) "self", NULL
22217 };
22218
22219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
22220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = ((wxRendererNative const *)arg1)->GetVersion();
22225
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 {
22230 wxRendererVersion * resultptr;
22231 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
22232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
22233 }
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
22241 PyObject *obj;
22242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22243 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
22244 Py_INCREF(obj);
22245 return Py_BuildValue((char *)"");
22246 }
22247 static PyMethodDef SwigMethods[] = {
22248 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22249 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22250 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22251 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22252 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
22253 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
22254 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22255 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
22256 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22257 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22258 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
22259 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
22260 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
22261 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22262 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22263 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22264 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22265 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22266 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22267 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22268 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22269 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22270 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
22271 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22272 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22273 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22274 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22275 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
22276 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22277 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
22278 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22279 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22280 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22281 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22282 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22283 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22284 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22285 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22286 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22287 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22288 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22289 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22290 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22291 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22292 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22293 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22294 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
22295 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22296 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22297 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22298 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22299 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
22300 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22301 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22302 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22303 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22304 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22305 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22306 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22307 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22308 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22309 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
22310 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22311 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
22312 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22313 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22314 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22315 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22316 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22317 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22318 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
22319 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22320 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22321 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22322 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22323 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22324 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22325 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22326 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
22327 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22328 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22329 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
22330 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22331 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
22332 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22333 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22334 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22335 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22336 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22337 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22338 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22339 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22340 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22341 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22342 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22343 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
22344 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
22345 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
22346 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22347 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22348 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22349 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22350 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22351 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22352 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22353 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22354 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22355 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22356 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22357 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22358 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22359 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22360 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22361 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22362 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22363 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22364 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
22365 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22366 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22367 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22368 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22369 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22370 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22371 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22372 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
22373 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22374 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22375 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22376 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22377 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22378 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22379 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22380 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
22381 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22382 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22383 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22384 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22385 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22386 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22387 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22388 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22389 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22390 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22391 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22392 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22393 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22394 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22395 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
22396 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22397 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22398 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22399 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
22400 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22401 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22402 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
22403 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
22404 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22405 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
22406 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
22407 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
22408 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
22409 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
22410 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22411 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
22412 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
22413 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
22414 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22415 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
22416 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
22417 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22418 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
22419 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
22420 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22421 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22422 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22423 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22424 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
22425 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22426 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22427 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
22428 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
22429 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
22430 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22431 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
22432 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22433 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
22434 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
22435 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
22436 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
22437 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
22438 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
22439 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22440 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22441 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22442 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
22443 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22444 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22445 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22446 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22447 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22448 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22449 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22450 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22451 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22452 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22453 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22454 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22455 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22456 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22457 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22458 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22459 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22460 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22461 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
22462 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22463 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22464 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
22465 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
22466 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
22467 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
22468 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
22469 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22470 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22471 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22472 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22473 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
22474 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22475 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22476 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22477 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22478 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22479 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22480 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22481 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
22482 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22483 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22484 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
22485 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22486 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22487 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22488 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22489 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
22490 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
22491 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
22492 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
22493 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22494 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22495 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22496 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
22497 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
22498 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22499 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22500 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22501 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22502 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22503 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22504 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22505 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
22506 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22507 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22508 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22509 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22510 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22511 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22512 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22513 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22514 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22515 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22516 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22517 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22518 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22519 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22520 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22521 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22522 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22523 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22524 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22525 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
22526 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22527 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
22528 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
22529 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
22530 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22531 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22532 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22533 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22534 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
22535 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22536 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22537 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22538 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22539 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22540 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22541 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22542 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
22543 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
22544 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
22545 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
22546 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
22547 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
22548 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
22549 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
22550 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22551 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22552 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
22553 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
22554 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22555 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22556 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22557 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22558 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22559 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22560 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
22561 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
22562 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
22563 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
22564 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
22565 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22566 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
22567 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22568 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22569 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
22570 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
22571 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
22572 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22573 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
22574 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22575 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22576 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22577 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
22578 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22579 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22580 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
22581 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
22582 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
22583 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22584 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22585 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
22586 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22587 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22588 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22589 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
22590 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22591 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
22592 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22593 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
22594 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22595 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
22596 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
22597 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
22598 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22599 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22600 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22601 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22602 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22603 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22604 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22605 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22606 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22607 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
22608 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22609 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
22610 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
22611 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22612 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22613 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22614 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22615 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22616 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
22617 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22618 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
22619 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22620 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
22621 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22622 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22623 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22624 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22625 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22626 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
22627 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
22628 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22629 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22630 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
22631 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22632 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22633 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22634 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
22635 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
22636 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22637 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22638 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22639 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22640 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22641 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22642 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22643 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22644 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22645 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22646 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22647 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22648 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22649 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22650 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
22651 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22652 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22653 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
22654 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22655 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
22656 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
22657 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22658 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22659 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
22660 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
22661 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22662 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22663 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22664 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22665 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22666 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
22667 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22668 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22669 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22670 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22671 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22672 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22673 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22674 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22675 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22676 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22677 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22678 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22679 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22680 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22681 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22682 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22683 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22684 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22685 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22686 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22687 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22688 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22689 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22690 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22691 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
22692 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22693 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22694 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22695 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22696 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22697 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22698 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
22699 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
22700 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
22701 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
22702 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22703 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
22704 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
22705 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
22706 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
22707 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
22708 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
22709 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
22710 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
22711 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
22712 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
22713 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
22714 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
22715 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
22716 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
22717 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22718 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22719 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22720 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22721 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22722 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22723 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22724 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22725 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22726 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22727 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22728 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22729 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22730 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22731 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22732 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22733 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22734 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22735 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22736 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22737 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22738 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22739 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22740 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22741 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22742 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22743 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22744 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22745 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22746 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22747 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22748 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22749 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22750 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22751 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22752 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22753 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22754 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22755 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22756 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22757 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22758 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22759 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22760 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22761 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22762 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22763 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22764 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22765 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22766 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22767 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22768 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22769 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22770 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22771 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22772 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22773 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22774 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22775 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22776 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22777 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22778 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22779 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22780 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22781 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22782 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22783 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22784 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22785 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22786 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22787 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22788 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22789 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22790 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22791 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22792 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22793 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22794 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22795 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22796 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22797 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22798 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22799 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22800 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22801 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22802 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22803 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22804 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22805 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22806 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22807 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
22808 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
22809 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
22810 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
22811 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22812 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22813 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
22814 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
22815 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
22816 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
22817 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
22818 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
22819 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
22820 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
22821 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
22822 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
22823 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
22824 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22825 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
22826 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
22827 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22828 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22829 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
22830 { NULL, NULL, 0, NULL }
22831 };
22832
22833
22834 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22835
22836 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22837 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22838 }
22839 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22840 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22841 }
22842 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22843 return (void *)((wxGDIObject *) ((wxIcon *) x));
22844 }
22845 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22846 return (void *)((wxGDIObject *) ((wxPalette *) x));
22847 }
22848 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22849 return (void *)((wxGDIObject *) ((wxPen *) x));
22850 }
22851 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22852 return (void *)((wxGDIObject *) ((wxFont *) x));
22853 }
22854 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22855 return (void *)((wxGDIObject *) ((wxCursor *) x));
22856 }
22857 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22858 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22859 }
22860 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22861 return (void *)((wxGDIObject *) ((wxRegion *) x));
22862 }
22863 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22864 return (void *)((wxGDIObject *) ((wxBrush *) x));
22865 }
22866 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22867 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22868 }
22869 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22870 return (void *)((wxDC *) ((wxScreenDC *) x));
22871 }
22872 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22873 return (void *)((wxDC *) ((wxMirrorDC *) x));
22874 }
22875 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22876 return (void *)((wxDC *) ((wxMemoryDC *) x));
22877 }
22878 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22879 return (void *)((wxDC *) ((wxWindowDC *) x));
22880 }
22881 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22882 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22883 }
22884 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22885 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22886 }
22887 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22888 return (void *)((wxDC *) ((wxClientDC *) x));
22889 }
22890 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22891 return (void *)((wxDC *) ((wxPaintDC *) x));
22892 }
22893 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22894 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22895 }
22896 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22897 return (void *)((wxDC *) ((wxPrinterDC *) x));
22898 }
22899 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22900 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22901 }
22902 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22903 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22904 }
22905 static void *_p_wxPenTo_p_wxObject(void *x) {
22906 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22907 }
22908 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22909 return (void *)((wxObject *) ((wxRegionIterator *) x));
22910 }
22911 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22912 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22913 }
22914 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22915 return (void *)((wxObject *) ((wxSizerItem *) x));
22916 }
22917 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22918 return (void *)((wxObject *) ((wxColourDatabase *) x));
22919 }
22920 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22921 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22922 }
22923 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22924 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22925 }
22926 static void *_p_wxIconTo_p_wxObject(void *x) {
22927 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22928 }
22929 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22930 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22931 }
22932 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22933 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22934 }
22935 static void *_p_wxSizerTo_p_wxObject(void *x) {
22936 return (void *)((wxObject *) ((wxSizer *) x));
22937 }
22938 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22939 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22940 }
22941 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22942 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22943 }
22944 static void *_p_wxPenListTo_p_wxObject(void *x) {
22945 return (void *)((wxObject *) ((wxPenList *) x));
22946 }
22947 static void *_p_wxEventTo_p_wxObject(void *x) {
22948 return (void *)((wxObject *) ((wxEvent *) x));
22949 }
22950 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22951 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22952 }
22953 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22954 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22955 }
22956 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22957 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22958 }
22959 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22960 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22961 }
22962 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22963 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22964 }
22965 static void *_p_wxDCTo_p_wxObject(void *x) {
22966 return (void *)((wxObject *) ((wxDC *) x));
22967 }
22968 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22969 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22970 }
22971 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22972 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22973 }
22974 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22975 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22976 }
22977 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22978 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22979 }
22980 static void *_p_wxControlTo_p_wxObject(void *x) {
22981 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22982 }
22983 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22984 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22985 }
22986 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22987 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22988 }
22989 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22990 return (void *)((wxObject *) ((wxFSFile *) x));
22991 }
22992 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22993 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22994 }
22995 static void *_p_wxRegionTo_p_wxObject(void *x) {
22996 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22997 }
22998 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22999 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
23000 }
23001 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
23002 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
23003 }
23004 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
23005 return (void *)((wxObject *) ((wxGDIObject *) x));
23006 }
23007 static void *_p_wxEffectsTo_p_wxObject(void *x) {
23008 return (void *)((wxObject *) ((wxEffects *) x));
23009 }
23010 static void *_p_wxPyEventTo_p_wxObject(void *x) {
23011 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
23012 }
23013 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
23014 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
23015 }
23016 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
23017 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
23018 }
23019 static void *_p_wxShowEventTo_p_wxObject(void *x) {
23020 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
23021 }
23022 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
23023 return (void *)((wxObject *) ((wxMenuItem *) x));
23024 }
23025 static void *_p_wxDateEventTo_p_wxObject(void *x) {
23026 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
23027 }
23028 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
23029 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
23030 }
23031 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
23032 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
23033 }
23034 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
23035 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
23036 }
23037 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
23038 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
23039 }
23040 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
23041 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
23042 }
23043 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
23044 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
23045 }
23046 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
23047 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
23048 }
23049 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
23050 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
23051 }
23052 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
23053 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
23054 }
23055 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
23056 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
23057 }
23058 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
23059 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
23060 }
23061 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
23062 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
23063 }
23064 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
23065 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
23066 }
23067 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
23068 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
23069 }
23070 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
23071 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
23072 }
23073 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
23074 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
23075 }
23076 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
23077 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
23078 }
23079 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
23080 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
23081 }
23082 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
23083 return (void *)((wxObject *) ((wxImageHandler *) x));
23084 }
23085 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
23086 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
23087 }
23088 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
23089 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
23090 }
23091 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
23092 return (void *)((wxObject *) ((wxEvtHandler *) x));
23093 }
23094 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
23095 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
23096 }
23097 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
23098 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
23099 }
23100 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
23101 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
23102 }
23103 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
23104 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
23105 }
23106 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
23107 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
23108 }
23109 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
23110 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
23111 }
23112 static void *_p_wxImageTo_p_wxObject(void *x) {
23113 return (void *)((wxObject *) ((wxImage *) x));
23114 }
23115 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
23116 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
23117 }
23118 static void *_p_wxPaletteTo_p_wxObject(void *x) {
23119 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
23120 }
23121 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
23122 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
23123 }
23124 static void *_p_wxImageListTo_p_wxObject(void *x) {
23125 return (void *)((wxObject *) ((wxImageList *) x));
23126 }
23127 static void *_p_wxCursorTo_p_wxObject(void *x) {
23128 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
23129 }
23130 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
23131 return (void *)((wxObject *) ((wxEncodingConverter *) x));
23132 }
23133 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
23134 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
23135 }
23136 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
23137 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
23138 }
23139 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
23140 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
23141 }
23142 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
23143 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
23144 }
23145 static void *_p_wxWindowTo_p_wxObject(void *x) {
23146 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
23147 }
23148 static void *_p_wxMenuTo_p_wxObject(void *x) {
23149 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
23150 }
23151 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
23152 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
23153 }
23154 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
23155 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
23156 }
23157 static void *_p_wxBrushListTo_p_wxObject(void *x) {
23158 return (void *)((wxObject *) ((wxBrushList *) x));
23159 }
23160 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
23161 return (void *)((wxObject *) ((wxFileSystem *) x));
23162 }
23163 static void *_p_wxBitmapTo_p_wxObject(void *x) {
23164 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
23165 }
23166 static void *_p_wxMaskTo_p_wxObject(void *x) {
23167 return (void *)((wxObject *) ((wxMask *) x));
23168 }
23169 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
23170 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
23171 }
23172 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
23173 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
23174 }
23175 static void *_p_wxPyAppTo_p_wxObject(void *x) {
23176 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
23177 }
23178 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
23179 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
23180 }
23181 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
23182 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
23183 }
23184 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
23185 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
23186 }
23187 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
23188 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
23189 }
23190 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
23191 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
23192 }
23193 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
23194 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
23195 }
23196 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
23197 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
23198 }
23199 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
23200 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
23201 }
23202 static void *_p_wxFontTo_p_wxObject(void *x) {
23203 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
23204 }
23205 static void *_p_wxBrushTo_p_wxObject(void *x) {
23206 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
23207 }
23208 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
23209 return (void *)((wxObject *) ((wxMetaFile *) x));
23210 }
23211 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
23212 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
23213 }
23214 static void *_p_wxColourTo_p_wxObject(void *x) {
23215 return (void *)((wxObject *) ((wxColour *) x));
23216 }
23217 static void *_p_wxFontListTo_p_wxObject(void *x) {
23218 return (void *)((wxObject *) ((wxFontList *) x));
23219 }
23220 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
23221 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
23222 }
23223 static void *_p_wxValidatorTo_p_wxObject(void *x) {
23224 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
23225 }
23226 static void *_p_wxControlTo_p_wxWindow(void *x) {
23227 return (void *)((wxWindow *) ((wxControl *) x));
23228 }
23229 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
23230 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
23231 }
23232 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
23233 return (void *)((wxWindow *) ((wxMenuBar *) x));
23234 }
23235 static swig_type_info _swigt__p_wxPostScriptDC[] = {{"_p_wxPostScriptDC", 0, "wxPostScriptDC *", 0, 0, 0, 0},{"_p_wxPostScriptDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23236 static swig_type_info _swigt__p_wxBrush[] = {{"_p_wxBrush", 0, "wxBrush *", 0, 0, 0, 0},{"_p_wxBrush", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23237 static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23238 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxDC, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxDC, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23239 static swig_type_info _swigt__p_wxMirrorDC[] = {{"_p_wxMirrorDC", 0, "wxMirrorDC *", 0, 0, 0, 0},{"_p_wxMirrorDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23240 static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t *|form_ops_t *", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23241 static swig_type_info _swigt__p_wxRendererVersion[] = {{"_p_wxRendererVersion", 0, "wxRendererVersion *", 0, 0, 0, 0},{"_p_wxRendererVersion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23242 static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23243 static swig_type_info _swigt__p_wxPyFontEnumerator[] = {{"_p_wxPyFontEnumerator", 0, "wxPyFontEnumerator *", 0, 0, 0, 0},{"_p_wxPyFontEnumerator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23244 static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23245 static swig_type_info _swigt__p_wxIconLocation[] = {{"_p_wxIconLocation", 0, "wxIconLocation *", 0, 0, 0, 0},{"_p_wxIconLocation", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23246 static swig_type_info _swigt__p_wxImage[] = {{"_p_wxImage", 0, "wxImage *", 0, 0, 0, 0},{"_p_wxImage", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23247 static swig_type_info _swigt__p_wxMetaFileDC[] = {{"_p_wxMetaFileDC", 0, "wxMetaFileDC *", 0, 0, 0, 0},{"_p_wxMetaFileDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23248 static swig_type_info _swigt__p_wxMask[] = {{"_p_wxMask", 0, "wxMask *", 0, 0, 0, 0},{"_p_wxMask", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23249 static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23250 static swig_type_info _swigt__p_wxFont[] = {{"_p_wxFont", 0, "wxFont *", 0, 0, 0, 0},{"_p_wxFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23251 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23252 static swig_type_info _swigt__p_double[] = {{"_p_double", 0, "double *", 0, 0, 0, 0},{"_p_double", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23253 static swig_type_info _swigt__p_wxMemoryDC[] = {{"_p_wxMemoryDC", 0, "wxMemoryDC *", 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxMemoryDC, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", 0, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxMemoryDC, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23254 static swig_type_info _swigt__p_wxFontMapper[] = {{"_p_wxFontMapper", 0, "wxFontMapper *", 0, 0, 0, 0},{"_p_wxFontMapper", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23255 static swig_type_info _swigt__p_wxEffects[] = {{"_p_wxEffects", 0, "wxEffects *", 0, 0, 0, 0},{"_p_wxEffects", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23256 static swig_type_info _swigt__p_wxNativeEncodingInfo[] = {{"_p_wxNativeEncodingInfo", 0, "wxNativeEncodingInfo *", 0, 0, 0, 0},{"_p_wxNativeEncodingInfo", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23257 static swig_type_info _swigt__p_wxPalette[] = {{"_p_wxPalette", 0, "wxPalette *", 0, 0, 0, 0},{"_p_wxPalette", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23258 static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0, 0, 0, 0},{"_p_wxBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23259 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23260 static swig_type_info _swigt__p_wxRegionIterator[] = {{"_p_wxRegionIterator", 0, "wxRegionIterator *", 0, 0, 0, 0},{"_p_wxRegionIterator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23261 static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23262 static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize *|wxPaperSize *", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23263 static swig_type_info _swigt__p_wxString[] = {{"_p_wxString", 0, "wxString *", 0, 0, 0, 0},{"_p_wxString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23264 static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23265 static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|time_t *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23266 static swig_type_info _swigt__p_wxPrinterDC[] = {{"_p_wxPrinterDC", 0, "wxPrinterDC *", 0, 0, 0, 0},{"_p_wxPrinterDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23267 static swig_type_info _swigt__p_wxIconBundle[] = {{"_p_wxIconBundle", 0, "wxIconBundle *", 0, 0, 0, 0},{"_p_wxIconBundle", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23268 static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23269 static swig_type_info _swigt__p_wxDash[] = {{"_p_wxDash", 0, "wxDash *", 0, 0, 0, 0},{"_p_wxDash", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23270 static swig_type_info _swigt__p_wxScreenDC[] = {{"_p_wxScreenDC", 0, "wxScreenDC *", 0, 0, 0, 0},{"_p_wxScreenDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23271 static swig_type_info _swigt__p_wxCursor[] = {{"_p_wxCursor", 0, "wxCursor *", 0, 0, 0, 0},{"_p_wxCursor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23272 static swig_type_info _swigt__p_wxClientDC[] = {{"_p_wxClientDC", 0, "wxClientDC *", 0, 0, 0, 0},{"_p_wxClientDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23273 static swig_type_info _swigt__p_wxBufferedDC[] = {{"_p_wxBufferedDC", 0, "wxBufferedDC *", 0, 0, 0, 0},{"_p_wxBufferedDC", 0, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxBufferedDC, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23274 static swig_type_info _swigt__p_wxImageList[] = {{"_p_wxImageList", 0, "wxImageList *", 0, 0, 0, 0},{"_p_wxImageList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23275 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23276 static swig_type_info _swigt__p_wxGDIObject[] = {{"_p_wxGDIObject", 0, "wxGDIObject *", 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", 0, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxGDIObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxGDIObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23277 static swig_type_info _swigt__p_wxIcon[] = {{"_p_wxIcon", 0, "wxIcon *", 0, 0, 0, 0},{"_p_wxIcon", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23278 static swig_type_info _swigt__p_wxLocale[] = {{"_p_wxLocale", 0, "wxLocale *", 0, 0, 0, 0},{"_p_wxLocale", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23279 static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23280 static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23281 static swig_type_info _swigt__p_wxRegion[] = {{"_p_wxRegion", 0, "wxRegion *", 0, 0, 0, 0},{"_p_wxRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23282 static swig_type_info _swigt__p_wxLanguageInfo[] = {{"_p_wxLanguageInfo", 0, "wxLanguageInfo *", 0, 0, 0, 0},{"_p_wxLanguageInfo", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23283 static swig_type_info _swigt__p_wxWindowDC[] = {{"_p_wxWindowDC", 0, "wxWindowDC *", 0, 0, 0, 0},{"_p_wxWindowDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23284 static swig_type_info _swigt__p_wxPrintData[] = {{"_p_wxPrintData", 0, "wxPrintData *", 0, 0, 0, 0},{"_p_wxPrintData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23285 static swig_type_info _swigt__p_wxBrushList[] = {{"_p_wxBrushList", 0, "wxBrushList *", 0, 0, 0, 0},{"_p_wxBrushList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23286 static swig_type_info _swigt__p_wxFontList[] = {{"_p_wxFontList", 0, "wxFontList *", 0, 0, 0, 0},{"_p_wxFontList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23287 static swig_type_info _swigt__p_wxPen[] = {{"_p_wxPen", 0, "wxPen *", 0, 0, 0, 0},{"_p_wxPen", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23288 static swig_type_info _swigt__p_wxBufferedPaintDC[] = {{"_p_wxBufferedPaintDC", 0, "wxBufferedPaintDC *", 0, 0, 0, 0},{"_p_wxBufferedPaintDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23289 static swig_type_info _swigt__p_wxPaintDC[] = {{"_p_wxPaintDC", 0, "wxPaintDC *", 0, 0, 0, 0},{"_p_wxPaintDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23290 static swig_type_info _swigt__p_wxPenList[] = {{"_p_wxPenList", 0, "wxPenList *", 0, 0, 0, 0},{"_p_wxPenList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23291 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23292 static swig_type_info _swigt__p_wxMetaFile[] = {{"_p_wxMetaFile", 0, "wxMetaFile *", 0, 0, 0, 0},{"_p_wxMetaFile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23293 static swig_type_info _swigt__p_wxRendererNative[] = {{"_p_wxRendererNative", 0, "wxRendererNative *", 0, 0, 0, 0},{"_p_wxRendererNative", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23294 static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|wxUIntPtr *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23295 static swig_type_info _swigt__p_wxNativeFontInfo[] = {{"_p_wxNativeFontInfo", 0, "wxNativeFontInfo *", 0, 0, 0, 0},{"_p_wxNativeFontInfo", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23296 static swig_type_info _swigt__p_wxEncodingConverter[] = {{"_p_wxEncodingConverter", 0, "wxEncodingConverter *", 0, 0, 0, 0},{"_p_wxEncodingConverter", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23297 static swig_type_info _swigt__p_wxSplitterRenderParams[] = {{"_p_wxSplitterRenderParams", 0, "wxSplitterRenderParams *", 0, 0, 0, 0},{"_p_wxSplitterRenderParams", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23298 static swig_type_info _swigt__p_wxColourDatabase[] = {{"_p_wxColourDatabase", 0, "wxColourDatabase *", 0, 0, 0, 0},{"_p_wxColourDatabase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23299
23300 static swig_type_info *swig_types_initial[] = {
23301 _swigt__p_wxPostScriptDC,
23302 _swigt__p_wxBrush,
23303 _swigt__p_wxColour,
23304 _swigt__p_wxDC,
23305 _swigt__p_wxMirrorDC,
23306 _swigt__p_form_ops_t,
23307 _swigt__p_wxRendererVersion,
23308 _swigt__p_wxDuplexMode,
23309 _swigt__p_wxPyFontEnumerator,
23310 _swigt__p_char,
23311 _swigt__p_wxIconLocation,
23312 _swigt__p_wxImage,
23313 _swigt__p_wxMetaFileDC,
23314 _swigt__p_wxMask,
23315 _swigt__p_wxSize,
23316 _swigt__p_wxFont,
23317 _swigt__p_wxWindow,
23318 _swigt__p_double,
23319 _swigt__p_wxMemoryDC,
23320 _swigt__p_wxFontMapper,
23321 _swigt__p_wxEffects,
23322 _swigt__p_wxNativeEncodingInfo,
23323 _swigt__p_wxPalette,
23324 _swigt__p_wxBitmap,
23325 _swigt__p_wxObject,
23326 _swigt__p_wxRegionIterator,
23327 _swigt__p_wxRect,
23328 _swigt__p_wxPaperSize,
23329 _swigt__p_wxString,
23330 _swigt__unsigned_int,
23331 _swigt__p_unsigned_int,
23332 _swigt__p_wxPrinterDC,
23333 _swigt__p_wxIconBundle,
23334 _swigt__p_wxPoint,
23335 _swigt__p_wxDash,
23336 _swigt__p_wxScreenDC,
23337 _swigt__p_wxCursor,
23338 _swigt__p_wxClientDC,
23339 _swigt__p_wxBufferedDC,
23340 _swigt__p_wxImageList,
23341 _swigt__p_unsigned_char,
23342 _swigt__p_wxGDIObject,
23343 _swigt__p_wxIcon,
23344 _swigt__p_wxLocale,
23345 _swigt__ptrdiff_t,
23346 _swigt__std__ptrdiff_t,
23347 _swigt__p_wxRegion,
23348 _swigt__p_wxLanguageInfo,
23349 _swigt__p_wxWindowDC,
23350 _swigt__p_wxPrintData,
23351 _swigt__p_wxBrushList,
23352 _swigt__p_wxFontList,
23353 _swigt__p_wxPen,
23354 _swigt__p_wxBufferedPaintDC,
23355 _swigt__p_wxPaintDC,
23356 _swigt__p_wxPenList,
23357 _swigt__p_int,
23358 _swigt__p_wxMetaFile,
23359 _swigt__p_wxRendererNative,
23360 _swigt__p_unsigned_long,
23361 _swigt__p_wxNativeFontInfo,
23362 _swigt__p_wxEncodingConverter,
23363 _swigt__p_wxSplitterRenderParams,
23364 _swigt__p_wxColourDatabase,
23365 0
23366 };
23367
23368
23369 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23370
23371 static swig_const_info swig_const_table[] = {
23372 {0, 0, 0, 0.0, 0, 0}};
23373
23374 #ifdef __cplusplus
23375 }
23376 #endif
23377
23378
23379 #ifdef __cplusplus
23380 extern "C" {
23381 #endif
23382
23383 /* Python-specific SWIG API */
23384 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23385 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23386 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23387
23388 /* -----------------------------------------------------------------------------
23389 * global variable support code.
23390 * ----------------------------------------------------------------------------- */
23391
23392 typedef struct swig_globalvar {
23393 char *name; /* Name of global variable */
23394 PyObject *(*get_attr)(); /* Return the current value */
23395 int (*set_attr)(PyObject *); /* Set the value */
23396 struct swig_globalvar *next;
23397 } swig_globalvar;
23398
23399 typedef struct swig_varlinkobject {
23400 PyObject_HEAD
23401 swig_globalvar *vars;
23402 } swig_varlinkobject;
23403
23404 static PyObject *
23405 swig_varlink_repr(swig_varlinkobject *v) {
23406 v = v;
23407 return PyString_FromString("<Swig global variables>");
23408 }
23409
23410 static int
23411 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
23412 swig_globalvar *var;
23413 flags = flags;
23414 fprintf(fp,"Swig global variables { ");
23415 for (var = v->vars; var; var=var->next) {
23416 fprintf(fp,"%s", var->name);
23417 if (var->next) fprintf(fp,", ");
23418 }
23419 fprintf(fp," }\n");
23420 return 0;
23421 }
23422
23423 static PyObject *
23424 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23425 swig_globalvar *var = v->vars;
23426 while (var) {
23427 if (strcmp(var->name,n) == 0) {
23428 return (*var->get_attr)();
23429 }
23430 var = var->next;
23431 }
23432 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23433 return NULL;
23434 }
23435
23436 static int
23437 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23438 swig_globalvar *var = v->vars;
23439 while (var) {
23440 if (strcmp(var->name,n) == 0) {
23441 return (*var->set_attr)(p);
23442 }
23443 var = var->next;
23444 }
23445 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23446 return 1;
23447 }
23448
23449 static PyTypeObject varlinktype = {
23450 PyObject_HEAD_INIT(0)
23451 0, /* Number of items in variable part (ob_size) */
23452 (char *)"swigvarlink", /* Type name (tp_name) */
23453 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23454 0, /* Itemsize (tp_itemsize) */
23455 0, /* Deallocator (tp_dealloc) */
23456 (printfunc) swig_varlink_print, /* Print (tp_print) */
23457 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23458 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23459 0, /* tp_compare */
23460 (reprfunc) swig_varlink_repr, /* tp_repr */
23461 0, /* tp_as_number */
23462 0, /* tp_as_sequence */
23463 0, /* tp_as_mapping */
23464 0, /* tp_hash */
23465 0, /* tp_call */
23466 0, /* tp_str */
23467 0, /* tp_getattro */
23468 0, /* tp_setattro */
23469 0, /* tp_as_buffer */
23470 0, /* tp_flags */
23471 0, /* tp_doc */
23472 #if PY_VERSION_HEX >= 0x02000000
23473 0, /* tp_traverse */
23474 0, /* tp_clear */
23475 #endif
23476 #if PY_VERSION_HEX >= 0x02010000
23477 0, /* tp_richcompare */
23478 0, /* tp_weaklistoffset */
23479 #endif
23480 #if PY_VERSION_HEX >= 0x02020000
23481 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23482 #endif
23483 #if PY_VERSION_HEX >= 0x02030000
23484 0, /* tp_del */
23485 #endif
23486 #ifdef COUNT_ALLOCS
23487 0,0,0,0 /* tp_alloc -> tp_next */
23488 #endif
23489 };
23490
23491 /* Create a variable linking object for use later */
23492 static PyObject *
23493 SWIG_Python_newvarlink(void) {
23494 swig_varlinkobject *result = 0;
23495 result = PyMem_NEW(swig_varlinkobject,1);
23496 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
23497 result->ob_type = &varlinktype;
23498 result->vars = 0;
23499 result->ob_refcnt = 0;
23500 Py_XINCREF((PyObject *) result);
23501 return ((PyObject*) result);
23502 }
23503
23504 static void
23505 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23506 swig_varlinkobject *v;
23507 swig_globalvar *gv;
23508 v= (swig_varlinkobject *) p;
23509 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23510 gv->name = (char *) malloc(strlen(name)+1);
23511 strcpy(gv->name,name);
23512 gv->get_attr = get_attr;
23513 gv->set_attr = set_attr;
23514 gv->next = v->vars;
23515 v->vars = gv;
23516 }
23517
23518 /* -----------------------------------------------------------------------------
23519 * constants/methods manipulation
23520 * ----------------------------------------------------------------------------- */
23521
23522 /* Install Constants */
23523 static void
23524 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23525 PyObject *obj = 0;
23526 size_t i;
23527 for (i = 0; constants[i].type; i++) {
23528 switch(constants[i].type) {
23529 case SWIG_PY_INT:
23530 obj = PyInt_FromLong(constants[i].lvalue);
23531 break;
23532 case SWIG_PY_FLOAT:
23533 obj = PyFloat_FromDouble(constants[i].dvalue);
23534 break;
23535 case SWIG_PY_STRING:
23536 if (constants[i].pvalue) {
23537 obj = PyString_FromString((char *) constants[i].pvalue);
23538 } else {
23539 Py_INCREF(Py_None);
23540 obj = Py_None;
23541 }
23542 break;
23543 case SWIG_PY_POINTER:
23544 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23545 break;
23546 case SWIG_PY_BINARY:
23547 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23548 break;
23549 default:
23550 obj = 0;
23551 break;
23552 }
23553 if (obj) {
23554 PyDict_SetItemString(d,constants[i].name,obj);
23555 Py_DECREF(obj);
23556 }
23557 }
23558 }
23559
23560 /* -----------------------------------------------------------------------------*/
23561 /* Fix SwigMethods to carry the callback ptrs when needed */
23562 /* -----------------------------------------------------------------------------*/
23563
23564 static void
23565 SWIG_Python_FixMethods(PyMethodDef *methods,
23566 swig_const_info *const_table,
23567 swig_type_info **types,
23568 swig_type_info **types_initial) {
23569 size_t i;
23570 for (i = 0; methods[i].ml_name; ++i) {
23571 char *c = methods[i].ml_doc;
23572 if (c && (c = strstr(c, "swig_ptr: "))) {
23573 int j;
23574 swig_const_info *ci = 0;
23575 char *name = c + 10;
23576 for (j = 0; const_table[j].type; j++) {
23577 if (strncmp(const_table[j].name, name,
23578 strlen(const_table[j].name)) == 0) {
23579 ci = &(const_table[j]);
23580 break;
23581 }
23582 }
23583 if (ci) {
23584 size_t shift = (ci->ptype) - types;
23585 swig_type_info *ty = types_initial[shift];
23586 size_t ldoc = (c - methods[i].ml_doc);
23587 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23588 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23589 char *buff = ndoc;
23590 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
23591 strncpy(buff, methods[i].ml_doc, ldoc);
23592 buff += ldoc;
23593 strncpy(buff, "swig_ptr: ", 10);
23594 buff += 10;
23595 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23596 methods[i].ml_doc = ndoc;
23597 }
23598 }
23599 }
23600 }
23601
23602 /* -----------------------------------------------------------------------------*
23603 * Initialize type list
23604 * -----------------------------------------------------------------------------*/
23605
23606 #if PY_MAJOR_VERSION < 2
23607 /* PyModule_AddObject function was introduced in Python 2.0. The following function
23608 is copied out of Python/modsupport.c in python version 2.3.4 */
23609 static int
23610 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
23611 {
23612 PyObject *dict;
23613 if (!PyModule_Check(m)) {
23614 PyErr_SetString(PyExc_TypeError,
23615 "PyModule_AddObject() needs module as first arg");
23616 return -1;
23617 }
23618 if (!o) {
23619 PyErr_SetString(PyExc_TypeError,
23620 "PyModule_AddObject() needs non-NULL value");
23621 return -1;
23622 }
23623
23624 dict = PyModule_GetDict(m);
23625 if (dict == NULL) {
23626 /* Internal error -- modules must have a dict! */
23627 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
23628 PyModule_GetName(m));
23629 return -1;
23630 }
23631 if (PyDict_SetItemString(dict, name, o))
23632 return -1;
23633 Py_DECREF(o);
23634 return 0;
23635 }
23636 #endif
23637
23638 static swig_type_info **
23639 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
23640 static PyMethodDef swig_empty_runtime_method_table[] = {
23641 {
23642 NULL, NULL, 0, NULL
23643 }
23644 };/* Sentinel */
23645
23646 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
23647 swig_empty_runtime_method_table);
23648 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
23649 if (pointer && module) {
23650 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
23651 }
23652 return type_list_handle;
23653 }
23654
23655 static swig_type_info **
23656 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
23657 swig_type_info **type_pointer;
23658
23659 /* first check if module already created */
23660 type_pointer = SWIG_Python_GetTypeListHandle();
23661 if (type_pointer) {
23662 return type_pointer;
23663 } else {
23664 /* create a new module and variable */
23665 return SWIG_Python_SetTypeListHandle(type_list_handle);
23666 }
23667 }
23668
23669 #ifdef __cplusplus
23670 }
23671 #endif
23672
23673 /* -----------------------------------------------------------------------------*
23674 * Partial Init method
23675 * -----------------------------------------------------------------------------*/
23676
23677 #ifdef SWIG_LINK_RUNTIME
23678 #ifdef __cplusplus
23679 extern "C"
23680 #endif
23681 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
23682 #endif
23683
23684 #ifdef __cplusplus
23685 extern "C"
23686 #endif
23687 SWIGEXPORT(void) SWIG_init(void) {
23688 static PyObject *SWIG_globals = 0;
23689 static int typeinit = 0;
23690 PyObject *m, *d;
23691 int i;
23692 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
23693
23694 /* Fix SwigMethods to carry the callback ptrs when needed */
23695 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
23696
23697 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23698 d = PyModule_GetDict(m);
23699
23700 if (!typeinit) {
23701 #ifdef SWIG_LINK_RUNTIME
23702 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
23703 #else
23704 # ifndef SWIG_STATIC_RUNTIME
23705 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
23706 # endif
23707 #endif
23708 for (i = 0; swig_types_initial[i]; i++) {
23709 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
23710 }
23711 typeinit = 1;
23712 }
23713 SWIG_InstallConstants(d,swig_const_table);
23714
23715 {
23716 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
23717 }
23718 {
23719 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
23720 }
23721 {
23722 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
23723 }
23724 {
23725 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
23726 }
23727 {
23728 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
23729 }
23730 {
23731 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
23732 }
23733 {
23734 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
23735 }
23736 {
23737 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
23738 }
23739 {
23740 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
23741 }
23742 {
23743 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
23744 }
23745 {
23746 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23876 }
23877 {
23878 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23879 }
23880 {
23881 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23882 }
23883 {
23884 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23885 }
23886 {
23887 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23888 }
23889 {
23890 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23891 }
23892 {
23893 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23894 }
23895 {
23896 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23897 }
23898 {
23899 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23900 }
23901 {
23902 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23903 }
23904 {
23905 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23906 }
23907 {
23908 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23909 }
23910 {
23911 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23912 }
23913 {
23914 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23915 }
23916 {
23917 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23918 }
23919 {
23920 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23921 }
23922 {
23923 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23924 }
23925 {
23926 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23927 }
23928 {
23929 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23930 }
23931 {
23932 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23933 }
23934 {
23935 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23936 }
23937 {
23938 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23939 }
23940 {
23941 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23942 }
23943 {
23944 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23945 }
23946 {
23947 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23948 }
23949 {
23950 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23951 }
23952 {
23953 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23954 }
23955 {
23956 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23957 }
23958 {
23959 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23960 }
23961 {
23962 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23963 }
23964 {
23965 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23966 }
23967 {
23968 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23969 }
23970 {
23971 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23972 }
23973 {
23974 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23975 }
23976 {
23977 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23978 }
23979 {
23980 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23981 }
23982 {
23983 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23984 }
23985 {
23986 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23987 }
23988 {
23989 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23990 }
23991 {
23992 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23993 }
23994 {
23995 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23996 }
23997 {
23998 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23999 }
24000 {
24001 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
24002 }
24003 {
24004 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
24005 }
24006 {
24007 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
24008 }
24009 {
24010 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
24011 }
24012 {
24013 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
24014 }
24015 {
24016 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
24017 }
24018 {
24019 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
24020 }
24021 {
24022 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
24023 }
24024 {
24025 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
24026 }
24027 {
24028 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
24029 }
24030 {
24031 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
24032 }
24033 {
24034 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
24035 }
24036 {
24037 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
24038 }
24039 {
24040 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
24041 }
24042 {
24043 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
24044 }
24045 {
24046 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
24047 }
24048 {
24049 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
24050 }
24051 {
24052 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
24053 }
24054 {
24055 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
24056 }
24057 {
24058 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
24059 }
24060 {
24061 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
24062 }
24063 {
24064 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
24065 }
24066 {
24067 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
24068 }
24069 {
24070 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
24071 }
24072 {
24073 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
24074 }
24075 {
24076 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
24077 }
24078 {
24079 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
24080 }
24081 {
24082 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
24083 }
24084 {
24085 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
24086 }
24087 {
24088 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
24089 }
24090 {
24091 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
24092 }
24093 {
24094 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
24095 }
24096
24097 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
24098
24099 {
24100 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
24101 }
24102 {
24103 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
24104 }
24105 {
24106 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
24107 }
24108 {
24109 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
24110 }
24111 {
24112 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
24113 }
24114 {
24115 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
24116 }
24117 {
24118 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
24119 }
24120 {
24121 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
24122 }
24123 {
24124 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
24125 }
24126 {
24127 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
24128 }
24129 {
24130 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
24131 }
24132 {
24133 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
24134 }
24135 {
24136 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
24137 }
24138 {
24139 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
24140 }
24141 {
24142 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
24143 }
24144 {
24145 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
24146 }
24147 {
24148 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
24149 }
24150 {
24151 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
24152 }
24153 {
24154 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
24155 }
24156 {
24157 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
24158 }
24159 {
24160 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
24161 }
24162 {
24163 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
24164 }
24165 {
24166 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
24167 }
24168 {
24169 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
24170 }
24171 {
24172 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
24173 }
24174 {
24175 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
24176 }
24177 {
24178 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
24179 }
24180 {
24181 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
24182 }
24183 {
24184 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
24185 }
24186 {
24187 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
24188 }
24189 {
24190 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
24191 }
24192 {
24193 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
24194 }
24195 {
24196 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
24197 }
24198 {
24199 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
24200 }
24201 {
24202 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
24203 }
24204 {
24205 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
24206 }
24207 {
24208 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
24209 }
24210 {
24211 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
24212 }
24213 {
24214 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
24215 }
24216 {
24217 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
24218 }
24219 {
24220 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
24221 }
24222 {
24223 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
24224 }
24225 {
24226 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
24227 }
24228 {
24229 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
24230 }
24231 {
24232 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
24233 }
24234 {
24235 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
24236 }
24237 {
24238 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
24239 }
24240 {
24241 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
24242 }
24243 {
24244 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
24245 }
24246 {
24247 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
24248 }
24249 {
24250 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
24251 }
24252 {
24253 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
24254 }
24255 {
24256 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
24257 }
24258 {
24259 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
24260 }
24261 {
24262 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
24263 }
24264 {
24265 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
24266 }
24267 {
24268 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
24269 }
24270 {
24271 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
24272 }
24273 {
24274 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
24275 }
24276 {
24277 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
24278 }
24279 {
24280 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
24281 }
24282 {
24283 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
24284 }
24285 {
24286 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
24287 }
24288 {
24289 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
24290 }
24291 {
24292 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
24293 }
24294 {
24295 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
24296 }
24297 {
24298 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
24299 }
24300 {
24301 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
24302 }
24303 {
24304 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
24305 }
24306 {
24307 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
24308 }
24309 {
24310 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
24311 }
24312 {
24313 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
24314 }
24315 {
24316 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
24317 }
24318 {
24319 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
24320 }
24321 {
24322 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
24323 }
24324 {
24325 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
24326 }
24327 {
24328 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
24329 }
24330 {
24331 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
24332 }
24333 {
24334 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
24335 }
24336 {
24337 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
24338 }
24339 {
24340 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
24341 }
24342 {
24343 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
24344 }
24345 {
24346 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
24347 }
24348 {
24349 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
24350 }
24351 {
24352 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
24353 }
24354 {
24355 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
24356 }
24357 {
24358 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
24359 }
24360 {
24361 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
24362 }
24363 {
24364 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
24365 }
24366 {
24367 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
24368 }
24369 {
24370 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
24371 }
24372 {
24373 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
24374 }
24375 {
24376 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
24377 }
24378 {
24379 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
24380 }
24381 {
24382 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
24383 }
24384 {
24385 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
24386 }
24387 {
24388 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
24389 }
24390 {
24391 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
24392 }
24393 {
24394 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
24395 }
24396 {
24397 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
24398 }
24399 {
24400 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
24401 }
24402 {
24403 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
24404 }
24405 {
24406 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
24407 }
24408 {
24409 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
24410 }
24411 {
24412 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
24413 }
24414 {
24415 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
24416 }
24417 {
24418 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
24419 }
24420 {
24421 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
24422 }
24423 {
24424 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
24425 }
24426 {
24427 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
24428 }
24429 {
24430 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
24431 }
24432 {
24433 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
24434 }
24435 {
24436 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
24437 }
24438 {
24439 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
24440 }
24441 {
24442 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
24443 }
24444 {
24445 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
24446 }
24447 {
24448 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
24449 }
24450 {
24451 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
24452 }
24453 {
24454 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
24455 }
24456 {
24457 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
24458 }
24459 {
24460 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
24461 }
24462 {
24463 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
24464 }
24465 {
24466 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
24467 }
24468 {
24469 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
24470 }
24471 {
24472 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
24473 }
24474 {
24475 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
24476 }
24477 {
24478 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
24479 }
24480 {
24481 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
24482 }
24483 {
24484 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
24485 }
24486 {
24487 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
24488 }
24489 {
24490 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
24491 }
24492 {
24493 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
24494 }
24495 {
24496 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
24497 }
24498 {
24499 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
24500 }
24501 {
24502 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
24503 }
24504 {
24505 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
24506 }
24507 {
24508 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
24509 }
24510 {
24511 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
24512 }
24513 {
24514 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
24515 }
24516 {
24517 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
24518 }
24519 {
24520 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
24521 }
24522 {
24523 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
24524 }
24525 {
24526 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
24527 }
24528 {
24529 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
24530 }
24531 {
24532 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
24533 }
24534 {
24535 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
24536 }
24537 {
24538 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
24539 }
24540 {
24541 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
24542 }
24543 {
24544 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
24545 }
24546 {
24547 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
24548 }
24549 {
24550 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
24551 }
24552 {
24553 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
24554 }
24555 {
24556 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
24557 }
24558 {
24559 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
24560 }
24561 {
24562 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
24563 }
24564 {
24565 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
24566 }
24567 {
24568 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
24569 }
24570 {
24571 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
24572 }
24573 {
24574 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
24575 }
24576 {
24577 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
24578 }
24579 {
24580 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
24581 }
24582 {
24583 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
24584 }
24585 {
24586 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
24587 }
24588 {
24589 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
24590 }
24591 {
24592 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
24593 }
24594 {
24595 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
24596 }
24597 {
24598 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
24599 }
24600 {
24601 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
24602 }
24603 {
24604 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
24605 }
24606 {
24607 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
24608 }
24609 {
24610 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
24611 }
24612 {
24613 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
24614 }
24615 {
24616 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
24617 }
24618 {
24619 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
24620 }
24621 {
24622 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
24623 }
24624 {
24625 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
24626 }
24627 {
24628 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
24629 }
24630 {
24631 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
24632 }
24633 {
24634 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
24635 }
24636 {
24637 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
24638 }
24639 {
24640 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
24641 }
24642 {
24643 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
24644 }
24645 {
24646 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
24647 }
24648 {
24649 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
24650 }
24651 {
24652 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
24653 }
24654 {
24655 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
24656 }
24657 {
24658 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
24659 }
24660 {
24661 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
24662 }
24663 {
24664 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
24665 }
24666 {
24667 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
24668 }
24669 {
24670 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
24671 }
24672 {
24673 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
24674 }
24675 {
24676 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
24677 }
24678 {
24679 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
24680 }
24681 {
24682 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
24683 }
24684 {
24685 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
24686 }
24687 {
24688 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
24689 }
24690 {
24691 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
24692 }
24693 {
24694 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
24695 }
24696 {
24697 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
24698 }
24699 {
24700 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
24701 }
24702 {
24703 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
24704 }
24705 {
24706 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
24707 }
24708 {
24709 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
24710 }
24711 {
24712 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
24713 }
24714 {
24715 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
24716 }
24717 {
24718 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
24719 }
24720 {
24721 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
24722 }
24723 {
24724 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
24725 }
24726 {
24727 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
24728 }
24729 {
24730 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
24731 }
24732 {
24733 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
24734 }
24735 {
24736 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
24737 }
24738 {
24739 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
24740 }
24741 {
24742 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
24743 }
24744 {
24745 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
24746 }
24747 {
24748 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
24749 }
24750 {
24751 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24752 }
24753 {
24754 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24755 }
24756 {
24757 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24758 }
24759 {
24760 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24761 }
24762 {
24763 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24764 }
24765 {
24766 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24767 }
24768 {
24769 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24770 }
24771 {
24772 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24773 }
24774 {
24775 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24776 }
24777 {
24778 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24779 }
24780 {
24781 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24782 }
24783 {
24784 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24785 }
24786 {
24787 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24788 }
24789 {
24790 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24791 }
24792 {
24793 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24794 }
24795 {
24796 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24797 }
24798 {
24799 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24800 }
24801 {
24802 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24803 }
24804 {
24805 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24806 }
24807 {
24808 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24809 }
24810 {
24811 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24812 }
24813 {
24814 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24815 }
24816 {
24817 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24818 }
24819 {
24820 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24821 }
24822 {
24823 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24824 }
24825 {
24826 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24827 }
24828 {
24829 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24830 }
24831 {
24832 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24833 }
24834 {
24835 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24836 }
24837 {
24838 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24839 }
24840 {
24841 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24842 }
24843 {
24844 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24845 }
24846 {
24847 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24848 }
24849 {
24850 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24851 }
24852 {
24853 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24854 }
24855 {
24856 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24857 }
24858 {
24859 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24860 }
24861 {
24862 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24863 }
24864 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24865 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24866 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24867 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24868 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24869 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24870 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24871 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24872 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24873 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24874 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24875 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24876 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24877 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24878 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24879 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24880 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24881 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24882 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24883 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24884 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24885 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24886 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24887 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24888 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24889 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24890 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24891 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24892 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24893 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24894 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24895 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24896 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24897 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24898 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24899 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24900 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24901 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24902 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24903 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24904 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24905 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24906 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24907 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24908 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24909 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24910 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24911 {
24912 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24913 }
24914 {
24915 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24916 }
24917 {
24918 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24919 }
24920 {
24921 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24922 }
24923 {
24924 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24925 }
24926 {
24927 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24928 }
24929 {
24930 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24931 }
24932 {
24933 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24934 }
24935 {
24936 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24937 }
24938 {
24939 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24940 }
24941 {
24942 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24943 }
24944 {
24945 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24946 }
24947 {
24948 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24949 }
24950 {
24951 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24952 }
24953 {
24954 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24955 }
24956
24957 // Work around a chicken/egg problem in drawlist.cpp
24958 wxPyDrawList_SetAPIPtr();
24959
24960 }
24961
wxWidgets (Impactor)