]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied [ 1235509 ] wxCocoa unicode wxT("fixes")
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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_wxConfigBase swig_types[47]
1390 #define SWIGTYPE_p_wxLanguageInfo swig_types[48]
1391 #define SWIGTYPE_p_wxWindowDC swig_types[49]
1392 #define SWIGTYPE_p_wxPrintData swig_types[50]
1393 #define SWIGTYPE_p_wxBrushList swig_types[51]
1394 #define SWIGTYPE_p_wxFontList swig_types[52]
1395 #define SWIGTYPE_p_wxPen swig_types[53]
1396 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPaintDC swig_types[55]
1398 #define SWIGTYPE_p_wxPenList swig_types[56]
1399 #define SWIGTYPE_p_int swig_types[57]
1400 #define SWIGTYPE_p_wxMetaFile swig_types[58]
1401 #define SWIGTYPE_p_wxRendererNative swig_types[59]
1402 #define SWIGTYPE_p_unsigned_long swig_types[60]
1403 #define SWIGTYPE_p_wxNativeFontInfo swig_types[61]
1404 #define SWIGTYPE_p_wxEncodingConverter swig_types[62]
1405 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[63]
1406 #define SWIGTYPE_p_wxColourDatabase swig_types[64]
1407 static swig_type_info *swig_types[66];
1408
1409 /* -------- TYPES TABLE (END) -------- */
1410
1411
1412 /*-----------------------------------------------
1413 @(target):= _gdi_.so
1414 ------------------------------------------------*/
1415 #define SWIG_init init_gdi_
1416
1417 #define SWIG_name "_gdi_"
1418
1419 #include "wx/wxPython/wxPython.h"
1420 #include "wx/wxPython/pyclasses.h"
1421
1422
1423 static const wxString wxPyEmptyString(wxEmptyString);
1424
1425 #include <limits.h>
1426
1427
1428 SWIGINTERN int
1429 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1430 const char *errmsg)
1431 {
1432 if (value < min_value) {
1433 if (errmsg) {
1434 PyErr_Format(PyExc_OverflowError,
1435 "value %ld is less than '%s' minimum %ld",
1436 value, errmsg, min_value);
1437 }
1438 return 0;
1439 } else if (value > max_value) {
1440 if (errmsg) {
1441 PyErr_Format(PyExc_OverflowError,
1442 "value %ld is greater than '%s' maximum %ld",
1443 value, errmsg, max_value);
1444 }
1445 return 0;
1446 }
1447 return 1;
1448 }
1449
1450
1451 SWIGINTERN int
1452 SWIG_AsVal_long(PyObject* obj, long* val)
1453 {
1454 if (PyNumber_Check(obj)) {
1455 if (val) *val = PyInt_AsLong(obj);
1456 return 1;
1457 }
1458 else {
1459 SWIG_type_error("number", obj);
1460 }
1461 return 0;
1462 }
1463
1464
1465 #if INT_MAX != LONG_MAX
1466 SWIGINTERN int
1467 SWIG_AsVal_int(PyObject *obj, int *val)
1468 {
1469 const char* errmsg = val ? "int" : (char*)0;
1470 long v;
1471 if (SWIG_AsVal_long(obj, &v)) {
1472 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1473 if (val) *val = (int)(v);
1474 return 1;
1475 } else {
1476 return 0;
1477 }
1478 } else {
1479 PyErr_Clear();
1480 }
1481 if (val) {
1482 SWIG_type_error(errmsg, obj);
1483 }
1484 return 0;
1485 }
1486 #else
1487 SWIGINTERNSHORT int
1488 SWIG_AsVal_int(PyObject *obj, int *val)
1489 {
1490 return SWIG_AsVal_long(obj,(long*)val);
1491 }
1492 #endif
1493
1494
1495 SWIGINTERN int
1496 SWIG_AsVal_bool(PyObject *obj, bool *val)
1497 {
1498 if (obj == Py_True) {
1499 if (val) *val = true;
1500 return 1;
1501 }
1502 if (obj == Py_False) {
1503 if (val) *val = false;
1504 return 1;
1505 }
1506 int res = 0;
1507 if (SWIG_AsVal_int(obj, &res)) {
1508 if (val) *val = res ? true : false;
1509 return 1;
1510 } else {
1511 PyErr_Clear();
1512 }
1513 if (val) {
1514 SWIG_type_error("bool", obj);
1515 }
1516 return 0;
1517 }
1518
1519
1520 SWIGINTERNSHORT bool
1521 SWIG_As_bool(PyObject* obj)
1522 {
1523 bool v;
1524 if (!SWIG_AsVal_bool(obj, &v)) {
1525 /*
1526 this is needed to make valgrind/purify happier.
1527 */
1528 memset((void*)&v, 0, sizeof(bool));
1529 }
1530 return v;
1531 }
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_Check_bool(PyObject* obj)
1536 {
1537 return SWIG_AsVal_bool(obj, (bool*)0);
1538 }
1539
1540
1541 SWIGINTERN int
1542 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1543 {
1544 long v = 0;
1545 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1546 SWIG_type_error("unsigned number", obj);
1547 }
1548 else if (val)
1549 *val = (unsigned long)v;
1550 return 1;
1551 }
1552
1553
1554 SWIGINTERNSHORT int
1555 SWIG_CheckUnsignedLongInRange(unsigned long value,
1556 unsigned long max_value,
1557 const char *errmsg)
1558 {
1559 if (value > max_value) {
1560 if (errmsg) {
1561 PyErr_Format(PyExc_OverflowError,
1562 "value %lu is greater than '%s' minimum %lu",
1563 value, errmsg, max_value);
1564 }
1565 return 0;
1566 }
1567 return 1;
1568 }
1569
1570
1571 SWIGINTERN int
1572 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1573 {
1574 const char* errmsg = val ? "unsigned char" : (char*)0;
1575 unsigned long v;
1576 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1577 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1578 if (val) *val = (unsigned char)(v);
1579 return 1;
1580 } else {
1581 return 0;
1582 }
1583 } else {
1584 PyErr_Clear();
1585 }
1586 if (val) {
1587 SWIG_type_error(errmsg, obj);
1588 }
1589 return 0;
1590 }
1591
1592
1593 SWIGINTERNSHORT unsigned char
1594 SWIG_As_unsigned_SS_char(PyObject* obj)
1595 {
1596 unsigned char v;
1597 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1598 /*
1599 this is needed to make valgrind/purify happier.
1600 */
1601 memset((void*)&v, 0, sizeof(unsigned char));
1602 }
1603 return v;
1604 }
1605
1606
1607 SWIGINTERNSHORT int
1608 SWIG_Check_unsigned_SS_char(PyObject* obj)
1609 {
1610 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1611 }
1612
1613
1614 SWIGINTERNSHORT unsigned long
1615 SWIG_As_unsigned_SS_long(PyObject* obj)
1616 {
1617 unsigned long v;
1618 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(unsigned long));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_unsigned_SS_long(PyObject* obj)
1630 {
1631 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1632 }
1633
1634
1635 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1636 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1637 /*@@*/
1638
1639
1640 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1641 #define SWIG_From_long PyInt_FromLong
1642 /*@@*/
1643
1644 static PyObject *wxColour_Get(wxColour *self){
1645 PyObject* rv = PyTuple_New(3);
1646 int red = -1;
1647 int green = -1;
1648 int blue = -1;
1649 if (self->Ok()) {
1650 red = self->Red();
1651 green = self->Green();
1652 blue = self->Blue();
1653 }
1654 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1655 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1656 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1657 return rv;
1658 }
1659 static unsigned long wxColour_GetRGB(wxColour *self){
1660 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1661 }
1662
1663 SWIGINTERNSHORT PyObject*
1664 SWIG_From_unsigned_SS_long(unsigned long value)
1665 {
1666 return (value > LONG_MAX) ?
1667 PyLong_FromUnsignedLong(value)
1668 : PyInt_FromLong((long)(value));
1669 }
1670
1671
1672 SWIGINTERNSHORT int
1673 SWIG_As_int(PyObject* obj)
1674 {
1675 int v;
1676 if (!SWIG_AsVal_int(obj, &v)) {
1677 /*
1678 this is needed to make valgrind/purify happier.
1679 */
1680 memset((void*)&v, 0, sizeof(int));
1681 }
1682 return v;
1683 }
1684
1685
1686 SWIGINTERNSHORT int
1687 SWIG_Check_int(PyObject* obj)
1688 {
1689 return SWIG_AsVal_int(obj, (int*)0);
1690 }
1691
1692
1693 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1694 #define SWIG_From_int PyInt_FromLong
1695 /*@@*/
1696
1697
1698 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1699 PyObject* o2;
1700 PyObject* o3;
1701
1702 if (!target) {
1703 target = o;
1704 } else if (target == Py_None) {
1705 Py_DECREF(Py_None);
1706 target = o;
1707 } else {
1708 if (!PyTuple_Check(target)) {
1709 o2 = target;
1710 target = PyTuple_New(1);
1711 PyTuple_SetItem(target, 0, o2);
1712 }
1713 o3 = PyTuple_New(1);
1714 PyTuple_SetItem(o3, 0, o);
1715
1716 o2 = target;
1717 target = PySequence_Concat(o2, o3);
1718 Py_DECREF(o2);
1719 Py_DECREF(o3);
1720 }
1721 return target;
1722 }
1723
1724
1725 static PyObject *wxPen_GetDashes(wxPen *self){
1726 wxDash* dashes;
1727 int count = self->GetDashes(&dashes);
1728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1729 PyObject* retval = PyList_New(0);
1730 for (int x=0; x<count; x++) {
1731 PyObject* pyint = PyInt_FromLong(dashes[x]);
1732 PyList_Append(retval, pyint);
1733 Py_DECREF(pyint);
1734 }
1735 wxPyEndBlockThreads(blocked);
1736 return retval;
1737 }
1738 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1740 int size = PyList_Size(pyDashes);
1741 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1742
1743 // black magic warning! The array of wxDashes needs to exist as
1744 // long as the pen does because wxPen does not copy the array. So
1745 // stick a copy in a Python string object and attach it to _self,
1746 // and then call SetDashes with a pointer to that array. Then
1747 // when the Python pen object is destroyed the array will be
1748 // cleaned up too.
1749 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1750 PyObject_SetAttrString(_self, "_dashes", strDashes);
1751
1752 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1753 delete [] dashes;
1754 Py_DECREF(strDashes);
1755 wxPyEndBlockThreads(blocked);
1756 }
1757 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1758 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1759
1760 #include <wx/image.h>
1761
1762 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1763 char** cArray = NULL;
1764 int count;
1765
1766 if (!PyList_Check(listOfStrings)) {
1767 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1768 return NULL;
1769 }
1770 count = PyList_Size(listOfStrings);
1771 cArray = new char*[count];
1772
1773 for(int x=0; x<count; x++) {
1774 // TODO: Need some validation and error checking here
1775 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1776 }
1777 return cArray;
1778 }
1779
1780
1781 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1782 char** cArray = NULL;
1783 wxBitmap* bmp;
1784
1785 cArray = ConvertListOfStrings(listOfStrings);
1786 if (! cArray)
1787 return NULL;
1788 bmp = new wxBitmap(cArray);
1789 delete [] cArray;
1790 return bmp;
1791 }
1792 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1793 char* buf;
1794 int length;
1795 PyString_AsStringAndSize(bits, &buf, &length);
1796 return new wxBitmap(buf, width, height, depth);
1797 }
1798 static wxSize wxBitmap_GetSize(wxBitmap *self){
1799 wxSize size(self->GetWidth(), self->GetHeight());
1800 return size;
1801 }
1802 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1803 wxMask *mask = new wxMask(*self, colour);
1804 self->SetMask(mask);
1805 }
1806 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1807 self->SetWidth(size.x);
1808 self->SetHeight(size.y);
1809 }
1810 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1811 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1812 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1813 if ( !colour.Ok() )
1814 return new wxMask(bitmap, *wxBLACK);
1815 else
1816 return new wxMask(bitmap, colour);
1817 }
1818
1819 #include <wx/iconbndl.h>
1820
1821 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1822 wxIcon* icon = new wxIcon();
1823 icon->CopyFromBitmap(bmp);
1824 return icon;
1825 }
1826 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1827 char** cArray = NULL;
1828 wxIcon* icon;
1829
1830 cArray = ConvertListOfStrings(listOfStrings);
1831 if (! cArray)
1832 return NULL;
1833 icon = new wxIcon(cArray);
1834 delete [] cArray;
1835 return icon;
1836 }
1837 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1838
1839
1840
1841 return new wxIconLocation(*filename);
1842
1843 }
1844 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1845
1846
1847
1848 // do nothing
1849
1850 }
1851 static int wxIconLocation_GetIndex(wxIconLocation *self){
1852
1853
1854
1855 return -1;
1856
1857 }
1858
1859 SWIGINTERNSHORT long
1860 SWIG_As_long(PyObject* obj)
1861 {
1862 long v;
1863 if (!SWIG_AsVal_long(obj, &v)) {
1864 /*
1865 this is needed to make valgrind/purify happier.
1866 */
1867 memset((void*)&v, 0, sizeof(long));
1868 }
1869 return v;
1870 }
1871
1872
1873 SWIGINTERNSHORT int
1874 SWIG_Check_long(PyObject* obj)
1875 {
1876 return SWIG_AsVal_long(obj, (long*)0);
1877 }
1878
1879 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1880 #ifdef __WXGTK__
1881 wxImage img(cursorName, type);
1882 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1883 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1884 return new wxCursor(img);
1885 #else
1886 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1887 #endif
1888 }
1889
1890
1891 static void wxRegionIterator_Next(wxRegionIterator *self){
1892 (*self) ++;
1893 }
1894 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1895 return self->operator bool();
1896 }
1897
1898 #include <wx/fontutil.h>
1899 #include <wx/fontmap.h>
1900 #include <wx/fontenum.h>
1901
1902 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1903 return self->ToString();
1904 }
1905
1906 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1907 static wxNativeEncodingInfo info;
1908 if ( wxGetNativeFontEncoding(encoding, &info) )
1909 return &info;
1910 else
1911 return NULL;
1912 }
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 /*@/opt/swig/share/swig/1.3.24/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 class wxMetaFile : public wxObject {
2118 public:
2119 wxMetaFile(const wxString&)
2120 { wxPyRaiseNotImplemented(); }
2121 };
2122
2123 class wxMetaFileDC : public wxClientDC {
2124 public:
2125 wxMetaFileDC(const wxString&, int, int, const wxString&)
2126 { wxPyRaiseNotImplemented(); }
2127 };
2128
2129
2130
2131 class wxPrinterDC : public wxClientDC {
2132 public:
2133 wxPrinterDC(const wxPrintData&)
2134 { wxPyRaiseNotImplemented(); }
2135
2136 };
2137
2138
2139
2140 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2141 self->AddColour(name, wxColour(red, green, blue));
2142 }
2143
2144 #include <wx/effects.h>
2145
2146
2147 #include "wx/renderer.h"
2148
2149
2150 SWIGINTERNSHORT PyObject*
2151 SWIG_From_bool(bool value)
2152 {
2153 PyObject *obj = value ? Py_True : Py_False;
2154 Py_INCREF(obj);
2155 return obj;
2156 }
2157
2158 #ifdef __cplusplus
2159 extern "C" {
2160 #endif
2161 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2162 PyObject *resultobj;
2163 wxGDIObject *result;
2164 char *kwnames[] = {
2165 NULL
2166 };
2167
2168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2169 {
2170 if (!wxPyCheckForApp()) SWIG_fail;
2171 PyThreadState* __tstate = wxPyBeginAllowThreads();
2172 result = (wxGDIObject *)new wxGDIObject();
2173
2174 wxPyEndAllowThreads(__tstate);
2175 if (PyErr_Occurred()) SWIG_fail;
2176 }
2177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2178 return resultobj;
2179 fail:
2180 return NULL;
2181 }
2182
2183
2184 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2185 PyObject *resultobj;
2186 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2187 PyObject * obj0 = 0 ;
2188 char *kwnames[] = {
2189 (char *) "self", NULL
2190 };
2191
2192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2194 if (SWIG_arg_fail(1)) SWIG_fail;
2195 {
2196 PyThreadState* __tstate = wxPyBeginAllowThreads();
2197 delete arg1;
2198
2199 wxPyEndAllowThreads(__tstate);
2200 if (PyErr_Occurred()) SWIG_fail;
2201 }
2202 Py_INCREF(Py_None); resultobj = Py_None;
2203 return resultobj;
2204 fail:
2205 return NULL;
2206 }
2207
2208
2209 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2210 PyObject *resultobj;
2211 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2212 bool result;
2213 PyObject * obj0 = 0 ;
2214 char *kwnames[] = {
2215 (char *) "self", NULL
2216 };
2217
2218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2220 if (SWIG_arg_fail(1)) SWIG_fail;
2221 {
2222 PyThreadState* __tstate = wxPyBeginAllowThreads();
2223 result = (bool)(arg1)->GetVisible();
2224
2225 wxPyEndAllowThreads(__tstate);
2226 if (PyErr_Occurred()) SWIG_fail;
2227 }
2228 {
2229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2230 }
2231 return resultobj;
2232 fail:
2233 return NULL;
2234 }
2235
2236
2237 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2238 PyObject *resultobj;
2239 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2240 bool arg2 ;
2241 PyObject * obj0 = 0 ;
2242 PyObject * obj1 = 0 ;
2243 char *kwnames[] = {
2244 (char *) "self",(char *) "visible", NULL
2245 };
2246
2247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2249 if (SWIG_arg_fail(1)) SWIG_fail;
2250 {
2251 arg2 = (bool)(SWIG_As_bool(obj1));
2252 if (SWIG_arg_fail(2)) SWIG_fail;
2253 }
2254 {
2255 PyThreadState* __tstate = wxPyBeginAllowThreads();
2256 (arg1)->SetVisible(arg2);
2257
2258 wxPyEndAllowThreads(__tstate);
2259 if (PyErr_Occurred()) SWIG_fail;
2260 }
2261 Py_INCREF(Py_None); resultobj = Py_None;
2262 return resultobj;
2263 fail:
2264 return NULL;
2265 }
2266
2267
2268 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2269 PyObject *resultobj;
2270 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2271 bool result;
2272 PyObject * obj0 = 0 ;
2273 char *kwnames[] = {
2274 (char *) "self", NULL
2275 };
2276
2277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2279 if (SWIG_arg_fail(1)) SWIG_fail;
2280 {
2281 PyThreadState* __tstate = wxPyBeginAllowThreads();
2282 result = (bool)(arg1)->IsNull();
2283
2284 wxPyEndAllowThreads(__tstate);
2285 if (PyErr_Occurred()) SWIG_fail;
2286 }
2287 {
2288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2289 }
2290 return resultobj;
2291 fail:
2292 return NULL;
2293 }
2294
2295
2296 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2297 PyObject *obj;
2298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2299 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2300 Py_INCREF(obj);
2301 return Py_BuildValue((char *)"");
2302 }
2303 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2304 PyObject *resultobj;
2305 byte arg1 = (byte) 0 ;
2306 byte arg2 = (byte) 0 ;
2307 byte arg3 = (byte) 0 ;
2308 wxColour *result;
2309 PyObject * obj0 = 0 ;
2310 PyObject * obj1 = 0 ;
2311 PyObject * obj2 = 0 ;
2312 char *kwnames[] = {
2313 (char *) "red",(char *) "green",(char *) "blue", NULL
2314 };
2315
2316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2317 if (obj0) {
2318 {
2319 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2320 if (SWIG_arg_fail(1)) SWIG_fail;
2321 }
2322 }
2323 if (obj1) {
2324 {
2325 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2326 if (SWIG_arg_fail(2)) SWIG_fail;
2327 }
2328 }
2329 if (obj2) {
2330 {
2331 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2332 if (SWIG_arg_fail(3)) SWIG_fail;
2333 }
2334 }
2335 {
2336 PyThreadState* __tstate = wxPyBeginAllowThreads();
2337 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2338
2339 wxPyEndAllowThreads(__tstate);
2340 if (PyErr_Occurred()) SWIG_fail;
2341 }
2342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2343 return resultobj;
2344 fail:
2345 return NULL;
2346 }
2347
2348
2349 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2350 PyObject *resultobj;
2351 wxString *arg1 = 0 ;
2352 wxColour *result;
2353 bool temp1 = false ;
2354 PyObject * obj0 = 0 ;
2355 char *kwnames[] = {
2356 (char *) "colorName", NULL
2357 };
2358
2359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2360 {
2361 arg1 = wxString_in_helper(obj0);
2362 if (arg1 == NULL) SWIG_fail;
2363 temp1 = true;
2364 }
2365 {
2366 if (!wxPyCheckForApp()) SWIG_fail;
2367 PyThreadState* __tstate = wxPyBeginAllowThreads();
2368 result = (wxColour *)new wxColour((wxString const &)*arg1);
2369
2370 wxPyEndAllowThreads(__tstate);
2371 if (PyErr_Occurred()) SWIG_fail;
2372 }
2373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2374 {
2375 if (temp1)
2376 delete arg1;
2377 }
2378 return resultobj;
2379 fail:
2380 {
2381 if (temp1)
2382 delete arg1;
2383 }
2384 return NULL;
2385 }
2386
2387
2388 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2389 PyObject *resultobj;
2390 unsigned long arg1 ;
2391 wxColour *result;
2392 PyObject * obj0 = 0 ;
2393 char *kwnames[] = {
2394 (char *) "colRGB", NULL
2395 };
2396
2397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2398 {
2399 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2400 if (SWIG_arg_fail(1)) SWIG_fail;
2401 }
2402 {
2403 PyThreadState* __tstate = wxPyBeginAllowThreads();
2404 result = (wxColour *)new wxColour(arg1);
2405
2406 wxPyEndAllowThreads(__tstate);
2407 if (PyErr_Occurred()) SWIG_fail;
2408 }
2409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2410 return resultobj;
2411 fail:
2412 return NULL;
2413 }
2414
2415
2416 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2417 PyObject *resultobj;
2418 wxColour *arg1 = (wxColour *) 0 ;
2419 PyObject * obj0 = 0 ;
2420 char *kwnames[] = {
2421 (char *) "self", NULL
2422 };
2423
2424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2426 if (SWIG_arg_fail(1)) SWIG_fail;
2427 {
2428 PyThreadState* __tstate = wxPyBeginAllowThreads();
2429 delete arg1;
2430
2431 wxPyEndAllowThreads(__tstate);
2432 if (PyErr_Occurred()) SWIG_fail;
2433 }
2434 Py_INCREF(Py_None); resultobj = Py_None;
2435 return resultobj;
2436 fail:
2437 return NULL;
2438 }
2439
2440
2441 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2442 PyObject *resultobj;
2443 wxColour *arg1 = (wxColour *) 0 ;
2444 byte result;
2445 PyObject * obj0 = 0 ;
2446 char *kwnames[] = {
2447 (char *) "self", NULL
2448 };
2449
2450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2452 if (SWIG_arg_fail(1)) SWIG_fail;
2453 {
2454 PyThreadState* __tstate = wxPyBeginAllowThreads();
2455 result = (byte)(arg1)->Red();
2456
2457 wxPyEndAllowThreads(__tstate);
2458 if (PyErr_Occurred()) SWIG_fail;
2459 }
2460 {
2461 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2462 }
2463 return resultobj;
2464 fail:
2465 return NULL;
2466 }
2467
2468
2469 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2470 PyObject *resultobj;
2471 wxColour *arg1 = (wxColour *) 0 ;
2472 byte result;
2473 PyObject * obj0 = 0 ;
2474 char *kwnames[] = {
2475 (char *) "self", NULL
2476 };
2477
2478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2480 if (SWIG_arg_fail(1)) SWIG_fail;
2481 {
2482 PyThreadState* __tstate = wxPyBeginAllowThreads();
2483 result = (byte)(arg1)->Green();
2484
2485 wxPyEndAllowThreads(__tstate);
2486 if (PyErr_Occurred()) SWIG_fail;
2487 }
2488 {
2489 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2490 }
2491 return resultobj;
2492 fail:
2493 return NULL;
2494 }
2495
2496
2497 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2498 PyObject *resultobj;
2499 wxColour *arg1 = (wxColour *) 0 ;
2500 byte result;
2501 PyObject * obj0 = 0 ;
2502 char *kwnames[] = {
2503 (char *) "self", NULL
2504 };
2505
2506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2508 if (SWIG_arg_fail(1)) SWIG_fail;
2509 {
2510 PyThreadState* __tstate = wxPyBeginAllowThreads();
2511 result = (byte)(arg1)->Blue();
2512
2513 wxPyEndAllowThreads(__tstate);
2514 if (PyErr_Occurred()) SWIG_fail;
2515 }
2516 {
2517 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2518 }
2519 return resultobj;
2520 fail:
2521 return NULL;
2522 }
2523
2524
2525 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2526 PyObject *resultobj;
2527 wxColour *arg1 = (wxColour *) 0 ;
2528 bool result;
2529 PyObject * obj0 = 0 ;
2530 char *kwnames[] = {
2531 (char *) "self", NULL
2532 };
2533
2534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2536 if (SWIG_arg_fail(1)) SWIG_fail;
2537 {
2538 PyThreadState* __tstate = wxPyBeginAllowThreads();
2539 result = (bool)(arg1)->Ok();
2540
2541 wxPyEndAllowThreads(__tstate);
2542 if (PyErr_Occurred()) SWIG_fail;
2543 }
2544 {
2545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2546 }
2547 return resultobj;
2548 fail:
2549 return NULL;
2550 }
2551
2552
2553 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2554 PyObject *resultobj;
2555 wxColour *arg1 = (wxColour *) 0 ;
2556 byte arg2 ;
2557 byte arg3 ;
2558 byte arg4 ;
2559 PyObject * obj0 = 0 ;
2560 PyObject * obj1 = 0 ;
2561 PyObject * obj2 = 0 ;
2562 PyObject * obj3 = 0 ;
2563 char *kwnames[] = {
2564 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2565 };
2566
2567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2569 if (SWIG_arg_fail(1)) SWIG_fail;
2570 {
2571 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2572 if (SWIG_arg_fail(2)) SWIG_fail;
2573 }
2574 {
2575 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2576 if (SWIG_arg_fail(3)) SWIG_fail;
2577 }
2578 {
2579 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2580 if (SWIG_arg_fail(4)) SWIG_fail;
2581 }
2582 {
2583 PyThreadState* __tstate = wxPyBeginAllowThreads();
2584 (arg1)->Set(arg2,arg3,arg4);
2585
2586 wxPyEndAllowThreads(__tstate);
2587 if (PyErr_Occurred()) SWIG_fail;
2588 }
2589 Py_INCREF(Py_None); resultobj = Py_None;
2590 return resultobj;
2591 fail:
2592 return NULL;
2593 }
2594
2595
2596 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2597 PyObject *resultobj;
2598 wxColour *arg1 = (wxColour *) 0 ;
2599 unsigned long arg2 ;
2600 PyObject * obj0 = 0 ;
2601 PyObject * obj1 = 0 ;
2602 char *kwnames[] = {
2603 (char *) "self",(char *) "colRGB", NULL
2604 };
2605
2606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2608 if (SWIG_arg_fail(1)) SWIG_fail;
2609 {
2610 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2611 if (SWIG_arg_fail(2)) SWIG_fail;
2612 }
2613 {
2614 PyThreadState* __tstate = wxPyBeginAllowThreads();
2615 (arg1)->Set(arg2);
2616
2617 wxPyEndAllowThreads(__tstate);
2618 if (PyErr_Occurred()) SWIG_fail;
2619 }
2620 Py_INCREF(Py_None); resultobj = Py_None;
2621 return resultobj;
2622 fail:
2623 return NULL;
2624 }
2625
2626
2627 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2628 PyObject *resultobj;
2629 wxColour *arg1 = (wxColour *) 0 ;
2630 wxString *arg2 = 0 ;
2631 bool temp2 = false ;
2632 PyObject * obj0 = 0 ;
2633 PyObject * obj1 = 0 ;
2634 char *kwnames[] = {
2635 (char *) "self",(char *) "colourName", NULL
2636 };
2637
2638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2640 if (SWIG_arg_fail(1)) SWIG_fail;
2641 {
2642 arg2 = wxString_in_helper(obj1);
2643 if (arg2 == NULL) SWIG_fail;
2644 temp2 = true;
2645 }
2646 {
2647 PyThreadState* __tstate = wxPyBeginAllowThreads();
2648 (arg1)->InitFromName((wxString const &)*arg2);
2649
2650 wxPyEndAllowThreads(__tstate);
2651 if (PyErr_Occurred()) SWIG_fail;
2652 }
2653 Py_INCREF(Py_None); resultobj = Py_None;
2654 {
2655 if (temp2)
2656 delete arg2;
2657 }
2658 return resultobj;
2659 fail:
2660 {
2661 if (temp2)
2662 delete arg2;
2663 }
2664 return NULL;
2665 }
2666
2667
2668 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2669 PyObject *resultobj;
2670 wxColour *arg1 = (wxColour *) 0 ;
2671 long result;
2672 PyObject * obj0 = 0 ;
2673 char *kwnames[] = {
2674 (char *) "self", NULL
2675 };
2676
2677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2679 if (SWIG_arg_fail(1)) SWIG_fail;
2680 {
2681 PyThreadState* __tstate = wxPyBeginAllowThreads();
2682 result = (long)((wxColour const *)arg1)->GetPixel();
2683
2684 wxPyEndAllowThreads(__tstate);
2685 if (PyErr_Occurred()) SWIG_fail;
2686 }
2687 {
2688 resultobj = SWIG_From_long((long)(result));
2689 }
2690 return resultobj;
2691 fail:
2692 return NULL;
2693 }
2694
2695
2696 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2697 PyObject *resultobj;
2698 wxColour *arg1 = (wxColour *) 0 ;
2699 wxColour *arg2 = 0 ;
2700 bool result;
2701 wxColour temp2 ;
2702 PyObject * obj0 = 0 ;
2703 PyObject * obj1 = 0 ;
2704 char *kwnames[] = {
2705 (char *) "self",(char *) "colour", NULL
2706 };
2707
2708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2710 if (SWIG_arg_fail(1)) SWIG_fail;
2711 {
2712 arg2 = &temp2;
2713 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2714 }
2715 {
2716 PyThreadState* __tstate = wxPyBeginAllowThreads();
2717 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2718
2719 wxPyEndAllowThreads(__tstate);
2720 if (PyErr_Occurred()) SWIG_fail;
2721 }
2722 {
2723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2724 }
2725 return resultobj;
2726 fail:
2727 return NULL;
2728 }
2729
2730
2731 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2732 PyObject *resultobj;
2733 wxColour *arg1 = (wxColour *) 0 ;
2734 wxColour *arg2 = 0 ;
2735 bool result;
2736 wxColour temp2 ;
2737 PyObject * obj0 = 0 ;
2738 PyObject * obj1 = 0 ;
2739 char *kwnames[] = {
2740 (char *) "self",(char *) "colour", NULL
2741 };
2742
2743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2745 if (SWIG_arg_fail(1)) SWIG_fail;
2746 {
2747 arg2 = &temp2;
2748 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2749 }
2750 {
2751 PyThreadState* __tstate = wxPyBeginAllowThreads();
2752 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2753
2754 wxPyEndAllowThreads(__tstate);
2755 if (PyErr_Occurred()) SWIG_fail;
2756 }
2757 {
2758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2759 }
2760 return resultobj;
2761 fail:
2762 return NULL;
2763 }
2764
2765
2766 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2767 PyObject *resultobj;
2768 wxColour *arg1 = (wxColour *) 0 ;
2769 PyObject *result;
2770 PyObject * obj0 = 0 ;
2771 char *kwnames[] = {
2772 (char *) "self", NULL
2773 };
2774
2775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2777 if (SWIG_arg_fail(1)) SWIG_fail;
2778 {
2779 PyThreadState* __tstate = wxPyBeginAllowThreads();
2780 result = (PyObject *)wxColour_Get(arg1);
2781
2782 wxPyEndAllowThreads(__tstate);
2783 if (PyErr_Occurred()) SWIG_fail;
2784 }
2785 resultobj = result;
2786 return resultobj;
2787 fail:
2788 return NULL;
2789 }
2790
2791
2792 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2793 PyObject *resultobj;
2794 wxColour *arg1 = (wxColour *) 0 ;
2795 unsigned long result;
2796 PyObject * obj0 = 0 ;
2797 char *kwnames[] = {
2798 (char *) "self", NULL
2799 };
2800
2801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2803 if (SWIG_arg_fail(1)) SWIG_fail;
2804 {
2805 PyThreadState* __tstate = wxPyBeginAllowThreads();
2806 result = (unsigned long)wxColour_GetRGB(arg1);
2807
2808 wxPyEndAllowThreads(__tstate);
2809 if (PyErr_Occurred()) SWIG_fail;
2810 }
2811 {
2812 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2813 }
2814 return resultobj;
2815 fail:
2816 return NULL;
2817 }
2818
2819
2820 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2821 PyObject *obj;
2822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2823 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2824 Py_INCREF(obj);
2825 return Py_BuildValue((char *)"");
2826 }
2827 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2828 PyObject *resultobj;
2829 int arg1 ;
2830 unsigned char *arg2 = (unsigned char *) 0 ;
2831 unsigned char *arg3 = (unsigned char *) 0 ;
2832 unsigned char *arg4 = (unsigned char *) 0 ;
2833 wxPalette *result;
2834 PyObject * obj0 = 0 ;
2835 PyObject * obj1 = 0 ;
2836 PyObject * obj2 = 0 ;
2837 PyObject * obj3 = 0 ;
2838 char *kwnames[] = {
2839 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2840 };
2841
2842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2843 {
2844 arg1 = (int)(SWIG_As_int(obj0));
2845 if (SWIG_arg_fail(1)) SWIG_fail;
2846 }
2847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2848 if (SWIG_arg_fail(2)) SWIG_fail;
2849 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2850 if (SWIG_arg_fail(3)) SWIG_fail;
2851 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2852 if (SWIG_arg_fail(4)) SWIG_fail;
2853 {
2854 if (!wxPyCheckForApp()) SWIG_fail;
2855 PyThreadState* __tstate = wxPyBeginAllowThreads();
2856 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2857
2858 wxPyEndAllowThreads(__tstate);
2859 if (PyErr_Occurred()) SWIG_fail;
2860 }
2861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2862 return resultobj;
2863 fail:
2864 return NULL;
2865 }
2866
2867
2868 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2869 PyObject *resultobj;
2870 wxPalette *arg1 = (wxPalette *) 0 ;
2871 PyObject * obj0 = 0 ;
2872 char *kwnames[] = {
2873 (char *) "self", NULL
2874 };
2875
2876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2878 if (SWIG_arg_fail(1)) SWIG_fail;
2879 {
2880 PyThreadState* __tstate = wxPyBeginAllowThreads();
2881 delete arg1;
2882
2883 wxPyEndAllowThreads(__tstate);
2884 if (PyErr_Occurred()) SWIG_fail;
2885 }
2886 Py_INCREF(Py_None); resultobj = Py_None;
2887 return resultobj;
2888 fail:
2889 return NULL;
2890 }
2891
2892
2893 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2894 PyObject *resultobj;
2895 wxPalette *arg1 = (wxPalette *) 0 ;
2896 byte arg2 ;
2897 byte arg3 ;
2898 byte arg4 ;
2899 int result;
2900 PyObject * obj0 = 0 ;
2901 PyObject * obj1 = 0 ;
2902 PyObject * obj2 = 0 ;
2903 PyObject * obj3 = 0 ;
2904 char *kwnames[] = {
2905 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2906 };
2907
2908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2910 if (SWIG_arg_fail(1)) SWIG_fail;
2911 {
2912 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2913 if (SWIG_arg_fail(2)) SWIG_fail;
2914 }
2915 {
2916 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2917 if (SWIG_arg_fail(3)) SWIG_fail;
2918 }
2919 {
2920 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2921 if (SWIG_arg_fail(4)) SWIG_fail;
2922 }
2923 {
2924 PyThreadState* __tstate = wxPyBeginAllowThreads();
2925 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2926
2927 wxPyEndAllowThreads(__tstate);
2928 if (PyErr_Occurred()) SWIG_fail;
2929 }
2930 {
2931 resultobj = SWIG_From_int((int)(result));
2932 }
2933 return resultobj;
2934 fail:
2935 return NULL;
2936 }
2937
2938
2939 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2940 PyObject *resultobj;
2941 wxPalette *arg1 = (wxPalette *) 0 ;
2942 int arg2 ;
2943 byte *arg3 = (byte *) 0 ;
2944 byte *arg4 = (byte *) 0 ;
2945 byte *arg5 = (byte *) 0 ;
2946 bool result;
2947 byte temp3 ;
2948 int res3 = 0 ;
2949 byte temp4 ;
2950 int res4 = 0 ;
2951 byte temp5 ;
2952 int res5 = 0 ;
2953 PyObject * obj0 = 0 ;
2954 PyObject * obj1 = 0 ;
2955 char *kwnames[] = {
2956 (char *) "self",(char *) "pixel", NULL
2957 };
2958
2959 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2960 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2961 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2964 if (SWIG_arg_fail(1)) SWIG_fail;
2965 {
2966 arg2 = (int)(SWIG_As_int(obj1));
2967 if (SWIG_arg_fail(2)) SWIG_fail;
2968 }
2969 {
2970 PyThreadState* __tstate = wxPyBeginAllowThreads();
2971 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2972
2973 wxPyEndAllowThreads(__tstate);
2974 if (PyErr_Occurred()) SWIG_fail;
2975 }
2976 {
2977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2978 }
2979 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2980 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2981 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2982 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2983 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2984 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2985 return resultobj;
2986 fail:
2987 return NULL;
2988 }
2989
2990
2991 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2992 PyObject *resultobj;
2993 wxPalette *arg1 = (wxPalette *) 0 ;
2994 int result;
2995 PyObject * obj0 = 0 ;
2996 char *kwnames[] = {
2997 (char *) "self", NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3002 if (SWIG_arg_fail(1)) SWIG_fail;
3003 {
3004 PyThreadState* __tstate = wxPyBeginAllowThreads();
3005 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3006
3007 wxPyEndAllowThreads(__tstate);
3008 if (PyErr_Occurred()) SWIG_fail;
3009 }
3010 {
3011 resultobj = SWIG_From_int((int)(result));
3012 }
3013 return resultobj;
3014 fail:
3015 return NULL;
3016 }
3017
3018
3019 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3020 PyObject *resultobj;
3021 wxPalette *arg1 = (wxPalette *) 0 ;
3022 bool result;
3023 PyObject * obj0 = 0 ;
3024 char *kwnames[] = {
3025 (char *) "self", NULL
3026 };
3027
3028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3030 if (SWIG_arg_fail(1)) SWIG_fail;
3031 {
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = (bool)(arg1)->Ok();
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3040 }
3041 return resultobj;
3042 fail:
3043 return NULL;
3044 }
3045
3046
3047 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3048 PyObject *obj;
3049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3050 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3051 Py_INCREF(obj);
3052 return Py_BuildValue((char *)"");
3053 }
3054 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3055 PyObject *resultobj;
3056 wxColour *arg1 = 0 ;
3057 int arg2 = (int) 1 ;
3058 int arg3 = (int) wxSOLID ;
3059 wxPen *result;
3060 wxColour temp1 ;
3061 PyObject * obj0 = 0 ;
3062 PyObject * obj1 = 0 ;
3063 PyObject * obj2 = 0 ;
3064 char *kwnames[] = {
3065 (char *) "colour",(char *) "width",(char *) "style", NULL
3066 };
3067
3068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3069 {
3070 arg1 = &temp1;
3071 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3072 }
3073 if (obj1) {
3074 {
3075 arg2 = (int)(SWIG_As_int(obj1));
3076 if (SWIG_arg_fail(2)) SWIG_fail;
3077 }
3078 }
3079 if (obj2) {
3080 {
3081 arg3 = (int)(SWIG_As_int(obj2));
3082 if (SWIG_arg_fail(3)) SWIG_fail;
3083 }
3084 }
3085 {
3086 if (!wxPyCheckForApp()) SWIG_fail;
3087 PyThreadState* __tstate = wxPyBeginAllowThreads();
3088 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3089
3090 wxPyEndAllowThreads(__tstate);
3091 if (PyErr_Occurred()) SWIG_fail;
3092 }
3093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3094 return resultobj;
3095 fail:
3096 return NULL;
3097 }
3098
3099
3100 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3101 PyObject *resultobj;
3102 wxPen *arg1 = (wxPen *) 0 ;
3103 PyObject * obj0 = 0 ;
3104 char *kwnames[] = {
3105 (char *) "self", NULL
3106 };
3107
3108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3110 if (SWIG_arg_fail(1)) SWIG_fail;
3111 {
3112 PyThreadState* __tstate = wxPyBeginAllowThreads();
3113 delete arg1;
3114
3115 wxPyEndAllowThreads(__tstate);
3116 if (PyErr_Occurred()) SWIG_fail;
3117 }
3118 Py_INCREF(Py_None); resultobj = Py_None;
3119 return resultobj;
3120 fail:
3121 return NULL;
3122 }
3123
3124
3125 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3126 PyObject *resultobj;
3127 wxPen *arg1 = (wxPen *) 0 ;
3128 int result;
3129 PyObject * obj0 = 0 ;
3130 char *kwnames[] = {
3131 (char *) "self", NULL
3132 };
3133
3134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3136 if (SWIG_arg_fail(1)) SWIG_fail;
3137 {
3138 PyThreadState* __tstate = wxPyBeginAllowThreads();
3139 result = (int)(arg1)->GetCap();
3140
3141 wxPyEndAllowThreads(__tstate);
3142 if (PyErr_Occurred()) SWIG_fail;
3143 }
3144 {
3145 resultobj = SWIG_From_int((int)(result));
3146 }
3147 return resultobj;
3148 fail:
3149 return NULL;
3150 }
3151
3152
3153 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj;
3155 wxPen *arg1 = (wxPen *) 0 ;
3156 wxColour result;
3157 PyObject * obj0 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "self", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3164 if (SWIG_arg_fail(1)) SWIG_fail;
3165 {
3166 PyThreadState* __tstate = wxPyBeginAllowThreads();
3167 result = (arg1)->GetColour();
3168
3169 wxPyEndAllowThreads(__tstate);
3170 if (PyErr_Occurred()) SWIG_fail;
3171 }
3172 {
3173 wxColour * resultptr;
3174 resultptr = new wxColour((wxColour &)(result));
3175 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3176 }
3177 return resultobj;
3178 fail:
3179 return NULL;
3180 }
3181
3182
3183 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3184 PyObject *resultobj;
3185 wxPen *arg1 = (wxPen *) 0 ;
3186 int result;
3187 PyObject * obj0 = 0 ;
3188 char *kwnames[] = {
3189 (char *) "self", NULL
3190 };
3191
3192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3194 if (SWIG_arg_fail(1)) SWIG_fail;
3195 {
3196 PyThreadState* __tstate = wxPyBeginAllowThreads();
3197 result = (int)(arg1)->GetJoin();
3198
3199 wxPyEndAllowThreads(__tstate);
3200 if (PyErr_Occurred()) SWIG_fail;
3201 }
3202 {
3203 resultobj = SWIG_From_int((int)(result));
3204 }
3205 return resultobj;
3206 fail:
3207 return NULL;
3208 }
3209
3210
3211 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3212 PyObject *resultobj;
3213 wxPen *arg1 = (wxPen *) 0 ;
3214 int result;
3215 PyObject * obj0 = 0 ;
3216 char *kwnames[] = {
3217 (char *) "self", NULL
3218 };
3219
3220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3222 if (SWIG_arg_fail(1)) SWIG_fail;
3223 {
3224 PyThreadState* __tstate = wxPyBeginAllowThreads();
3225 result = (int)(arg1)->GetStyle();
3226
3227 wxPyEndAllowThreads(__tstate);
3228 if (PyErr_Occurred()) SWIG_fail;
3229 }
3230 {
3231 resultobj = SWIG_From_int((int)(result));
3232 }
3233 return resultobj;
3234 fail:
3235 return NULL;
3236 }
3237
3238
3239 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxPen *arg1 = (wxPen *) 0 ;
3242 int result;
3243 PyObject * obj0 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "self", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 {
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = (int)(arg1)->GetWidth();
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 resultobj = SWIG_From_int((int)(result));
3260 }
3261 return resultobj;
3262 fail:
3263 return NULL;
3264 }
3265
3266
3267 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3268 PyObject *resultobj;
3269 wxPen *arg1 = (wxPen *) 0 ;
3270 bool result;
3271 PyObject * obj0 = 0 ;
3272 char *kwnames[] = {
3273 (char *) "self", NULL
3274 };
3275
3276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3278 if (SWIG_arg_fail(1)) SWIG_fail;
3279 {
3280 PyThreadState* __tstate = wxPyBeginAllowThreads();
3281 result = (bool)(arg1)->Ok();
3282
3283 wxPyEndAllowThreads(__tstate);
3284 if (PyErr_Occurred()) SWIG_fail;
3285 }
3286 {
3287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3288 }
3289 return resultobj;
3290 fail:
3291 return NULL;
3292 }
3293
3294
3295 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3296 PyObject *resultobj;
3297 wxPen *arg1 = (wxPen *) 0 ;
3298 int arg2 ;
3299 PyObject * obj0 = 0 ;
3300 PyObject * obj1 = 0 ;
3301 char *kwnames[] = {
3302 (char *) "self",(char *) "cap_style", NULL
3303 };
3304
3305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3307 if (SWIG_arg_fail(1)) SWIG_fail;
3308 {
3309 arg2 = (int)(SWIG_As_int(obj1));
3310 if (SWIG_arg_fail(2)) SWIG_fail;
3311 }
3312 {
3313 PyThreadState* __tstate = wxPyBeginAllowThreads();
3314 (arg1)->SetCap(arg2);
3315
3316 wxPyEndAllowThreads(__tstate);
3317 if (PyErr_Occurred()) SWIG_fail;
3318 }
3319 Py_INCREF(Py_None); resultobj = Py_None;
3320 return resultobj;
3321 fail:
3322 return NULL;
3323 }
3324
3325
3326 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxPen *arg1 = (wxPen *) 0 ;
3329 wxColour *arg2 = 0 ;
3330 wxColour temp2 ;
3331 PyObject * obj0 = 0 ;
3332 PyObject * obj1 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "self",(char *) "colour", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3339 if (SWIG_arg_fail(1)) SWIG_fail;
3340 {
3341 arg2 = &temp2;
3342 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3343 }
3344 {
3345 PyThreadState* __tstate = wxPyBeginAllowThreads();
3346 (arg1)->SetColour(*arg2);
3347
3348 wxPyEndAllowThreads(__tstate);
3349 if (PyErr_Occurred()) SWIG_fail;
3350 }
3351 Py_INCREF(Py_None); resultobj = Py_None;
3352 return resultobj;
3353 fail:
3354 return NULL;
3355 }
3356
3357
3358 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3359 PyObject *resultobj;
3360 wxPen *arg1 = (wxPen *) 0 ;
3361 int arg2 ;
3362 PyObject * obj0 = 0 ;
3363 PyObject * obj1 = 0 ;
3364 char *kwnames[] = {
3365 (char *) "self",(char *) "join_style", NULL
3366 };
3367
3368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3370 if (SWIG_arg_fail(1)) SWIG_fail;
3371 {
3372 arg2 = (int)(SWIG_As_int(obj1));
3373 if (SWIG_arg_fail(2)) SWIG_fail;
3374 }
3375 {
3376 PyThreadState* __tstate = wxPyBeginAllowThreads();
3377 (arg1)->SetJoin(arg2);
3378
3379 wxPyEndAllowThreads(__tstate);
3380 if (PyErr_Occurred()) SWIG_fail;
3381 }
3382 Py_INCREF(Py_None); resultobj = Py_None;
3383 return resultobj;
3384 fail:
3385 return NULL;
3386 }
3387
3388
3389 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj;
3391 wxPen *arg1 = (wxPen *) 0 ;
3392 int arg2 ;
3393 PyObject * obj0 = 0 ;
3394 PyObject * obj1 = 0 ;
3395 char *kwnames[] = {
3396 (char *) "self",(char *) "style", NULL
3397 };
3398
3399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3401 if (SWIG_arg_fail(1)) SWIG_fail;
3402 {
3403 arg2 = (int)(SWIG_As_int(obj1));
3404 if (SWIG_arg_fail(2)) SWIG_fail;
3405 }
3406 {
3407 PyThreadState* __tstate = wxPyBeginAllowThreads();
3408 (arg1)->SetStyle(arg2);
3409
3410 wxPyEndAllowThreads(__tstate);
3411 if (PyErr_Occurred()) SWIG_fail;
3412 }
3413 Py_INCREF(Py_None); resultobj = Py_None;
3414 return resultobj;
3415 fail:
3416 return NULL;
3417 }
3418
3419
3420 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3421 PyObject *resultobj;
3422 wxPen *arg1 = (wxPen *) 0 ;
3423 int arg2 ;
3424 PyObject * obj0 = 0 ;
3425 PyObject * obj1 = 0 ;
3426 char *kwnames[] = {
3427 (char *) "self",(char *) "width", NULL
3428 };
3429
3430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3432 if (SWIG_arg_fail(1)) SWIG_fail;
3433 {
3434 arg2 = (int)(SWIG_As_int(obj1));
3435 if (SWIG_arg_fail(2)) SWIG_fail;
3436 }
3437 {
3438 PyThreadState* __tstate = wxPyBeginAllowThreads();
3439 (arg1)->SetWidth(arg2);
3440
3441 wxPyEndAllowThreads(__tstate);
3442 if (PyErr_Occurred()) SWIG_fail;
3443 }
3444 Py_INCREF(Py_None); resultobj = Py_None;
3445 return resultobj;
3446 fail:
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxPen *arg1 = (wxPen *) 0 ;
3454 int arg2 ;
3455 wxDash *arg3 = (wxDash *) 0 ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self",(char *) "dashes", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 arg2 = PyList_Size(obj1);
3467 arg3 = (wxDash*)byte_LIST_helper(obj1);
3468 if (arg3 == NULL) SWIG_fail;
3469 }
3470 {
3471 PyThreadState* __tstate = wxPyBeginAllowThreads();
3472 (arg1)->SetDashes(arg2,arg3);
3473
3474 wxPyEndAllowThreads(__tstate);
3475 if (PyErr_Occurred()) SWIG_fail;
3476 }
3477 Py_INCREF(Py_None); resultobj = Py_None;
3478 {
3479 if (arg3) delete [] arg3;
3480 }
3481 return resultobj;
3482 fail:
3483 {
3484 if (arg3) delete [] arg3;
3485 }
3486 return NULL;
3487 }
3488
3489
3490 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3491 PyObject *resultobj;
3492 wxPen *arg1 = (wxPen *) 0 ;
3493 PyObject *result;
3494 PyObject * obj0 = 0 ;
3495 char *kwnames[] = {
3496 (char *) "self", NULL
3497 };
3498
3499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3501 if (SWIG_arg_fail(1)) SWIG_fail;
3502 {
3503 PyThreadState* __tstate = wxPyBeginAllowThreads();
3504 result = (PyObject *)wxPen_GetDashes(arg1);
3505
3506 wxPyEndAllowThreads(__tstate);
3507 if (PyErr_Occurred()) SWIG_fail;
3508 }
3509 resultobj = result;
3510 return resultobj;
3511 fail:
3512 return NULL;
3513 }
3514
3515
3516 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3517 PyObject *resultobj;
3518 wxPen *arg1 = (wxPen *) 0 ;
3519 PyObject *arg2 = (PyObject *) 0 ;
3520 PyObject *arg3 = (PyObject *) 0 ;
3521 PyObject * obj0 = 0 ;
3522 PyObject * obj1 = 0 ;
3523 PyObject * obj2 = 0 ;
3524 char *kwnames[] = {
3525 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3526 };
3527
3528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3530 if (SWIG_arg_fail(1)) SWIG_fail;
3531 arg2 = obj1;
3532 arg3 = obj2;
3533 {
3534 PyThreadState* __tstate = wxPyBeginAllowThreads();
3535 wxPen__SetDashes(arg1,arg2,arg3);
3536
3537 wxPyEndAllowThreads(__tstate);
3538 if (PyErr_Occurred()) SWIG_fail;
3539 }
3540 Py_INCREF(Py_None); resultobj = Py_None;
3541 return resultobj;
3542 fail:
3543 return NULL;
3544 }
3545
3546
3547 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3548 PyObject *resultobj;
3549 wxPen *arg1 = (wxPen *) 0 ;
3550 int result;
3551 PyObject * obj0 = 0 ;
3552 char *kwnames[] = {
3553 (char *) "self", NULL
3554 };
3555
3556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3558 if (SWIG_arg_fail(1)) SWIG_fail;
3559 {
3560 PyThreadState* __tstate = wxPyBeginAllowThreads();
3561 result = (int)((wxPen const *)arg1)->GetDashCount();
3562
3563 wxPyEndAllowThreads(__tstate);
3564 if (PyErr_Occurred()) SWIG_fail;
3565 }
3566 {
3567 resultobj = SWIG_From_int((int)(result));
3568 }
3569 return resultobj;
3570 fail:
3571 return NULL;
3572 }
3573
3574
3575 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3576 PyObject *resultobj;
3577 wxPen *arg1 = (wxPen *) 0 ;
3578 wxPen *arg2 = (wxPen *) 0 ;
3579 bool result;
3580 PyObject * obj0 = 0 ;
3581 PyObject * obj1 = 0 ;
3582 char *kwnames[] = {
3583 (char *) "self",(char *) "other", NULL
3584 };
3585
3586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3588 if (SWIG_arg_fail(1)) SWIG_fail;
3589 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3590 if (SWIG_arg_fail(2)) SWIG_fail;
3591 {
3592 PyThreadState* __tstate = wxPyBeginAllowThreads();
3593 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3594
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 {
3599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3600 }
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 wxPen *arg1 = (wxPen *) 0 ;
3610 wxPen *arg2 = (wxPen *) 0 ;
3611 bool result;
3612 PyObject * obj0 = 0 ;
3613 PyObject * obj1 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self",(char *) "other", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(2)) SWIG_fail;
3623 {
3624 PyThreadState* __tstate = wxPyBeginAllowThreads();
3625 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 {
3631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3632 }
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3640 PyObject *obj;
3641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3642 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3643 Py_INCREF(obj);
3644 return Py_BuildValue((char *)"");
3645 }
3646 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3647 PyObject *resultobj;
3648 wxColour *arg1 = 0 ;
3649 int arg2 = (int) wxSOLID ;
3650 wxBrush *result;
3651 wxColour temp1 ;
3652 PyObject * obj0 = 0 ;
3653 PyObject * obj1 = 0 ;
3654 char *kwnames[] = {
3655 (char *) "colour",(char *) "style", NULL
3656 };
3657
3658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3659 {
3660 arg1 = &temp1;
3661 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3662 }
3663 if (obj1) {
3664 {
3665 arg2 = (int)(SWIG_As_int(obj1));
3666 if (SWIG_arg_fail(2)) SWIG_fail;
3667 }
3668 }
3669 {
3670 if (!wxPyCheckForApp()) SWIG_fail;
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3678 return resultobj;
3679 fail:
3680 return NULL;
3681 }
3682
3683
3684 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3685 PyObject *resultobj;
3686 wxBitmap *arg1 = 0 ;
3687 wxBrush *result;
3688 PyObject * obj0 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "stippleBitmap", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3694 {
3695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3696 if (SWIG_arg_fail(1)) SWIG_fail;
3697 if (arg1 == NULL) {
3698 SWIG_null_ref("wxBitmap");
3699 }
3700 if (SWIG_arg_fail(1)) SWIG_fail;
3701 }
3702 {
3703 if (!wxPyCheckForApp()) SWIG_fail;
3704 PyThreadState* __tstate = wxPyBeginAllowThreads();
3705 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3706
3707 wxPyEndAllowThreads(__tstate);
3708 if (PyErr_Occurred()) SWIG_fail;
3709 }
3710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3711 return resultobj;
3712 fail:
3713 return NULL;
3714 }
3715
3716
3717 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3718 PyObject *resultobj;
3719 wxBrush *arg1 = (wxBrush *) 0 ;
3720 PyObject * obj0 = 0 ;
3721 char *kwnames[] = {
3722 (char *) "self", NULL
3723 };
3724
3725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3727 if (SWIG_arg_fail(1)) SWIG_fail;
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 delete arg1;
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 Py_INCREF(Py_None); resultobj = Py_None;
3736 return resultobj;
3737 fail:
3738 return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3743 PyObject *resultobj;
3744 wxBrush *arg1 = (wxBrush *) 0 ;
3745 wxColour *arg2 = 0 ;
3746 wxColour temp2 ;
3747 PyObject * obj0 = 0 ;
3748 PyObject * obj1 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "self",(char *) "col", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3755 if (SWIG_arg_fail(1)) SWIG_fail;
3756 {
3757 arg2 = &temp2;
3758 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 (arg1)->SetColour((wxColour const &)*arg2);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 Py_INCREF(Py_None); resultobj = Py_None;
3768 return resultobj;
3769 fail:
3770 return NULL;
3771 }
3772
3773
3774 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3775 PyObject *resultobj;
3776 wxBrush *arg1 = (wxBrush *) 0 ;
3777 int arg2 ;
3778 PyObject * obj0 = 0 ;
3779 PyObject * obj1 = 0 ;
3780 char *kwnames[] = {
3781 (char *) "self",(char *) "style", NULL
3782 };
3783
3784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3786 if (SWIG_arg_fail(1)) SWIG_fail;
3787 {
3788 arg2 = (int)(SWIG_As_int(obj1));
3789 if (SWIG_arg_fail(2)) SWIG_fail;
3790 }
3791 {
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 (arg1)->SetStyle(arg2);
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 wxBrush *arg1 = (wxBrush *) 0 ;
3808 wxBitmap *arg2 = 0 ;
3809 PyObject * obj0 = 0 ;
3810 PyObject * obj1 = 0 ;
3811 char *kwnames[] = {
3812 (char *) "self",(char *) "stipple", NULL
3813 };
3814
3815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3817 if (SWIG_arg_fail(1)) SWIG_fail;
3818 {
3819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3820 if (SWIG_arg_fail(2)) SWIG_fail;
3821 if (arg2 == NULL) {
3822 SWIG_null_ref("wxBitmap");
3823 }
3824 if (SWIG_arg_fail(2)) SWIG_fail;
3825 }
3826 {
3827 PyThreadState* __tstate = wxPyBeginAllowThreads();
3828 (arg1)->SetStipple((wxBitmap const &)*arg2);
3829
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 Py_INCREF(Py_None); resultobj = Py_None;
3834 return resultobj;
3835 fail:
3836 return NULL;
3837 }
3838
3839
3840 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3841 PyObject *resultobj;
3842 wxBrush *arg1 = (wxBrush *) 0 ;
3843 wxColour result;
3844 PyObject * obj0 = 0 ;
3845 char *kwnames[] = {
3846 (char *) "self", NULL
3847 };
3848
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3851 if (SWIG_arg_fail(1)) SWIG_fail;
3852 {
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 result = ((wxBrush const *)arg1)->GetColour();
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 {
3860 wxColour * resultptr;
3861 resultptr = new wxColour((wxColour &)(result));
3862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3863 }
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 wxBrush *arg1 = (wxBrush *) 0 ;
3873 int result;
3874 PyObject * obj0 = 0 ;
3875 char *kwnames[] = {
3876 (char *) "self", NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3881 if (SWIG_arg_fail(1)) SWIG_fail;
3882 {
3883 PyThreadState* __tstate = wxPyBeginAllowThreads();
3884 result = (int)((wxBrush const *)arg1)->GetStyle();
3885
3886 wxPyEndAllowThreads(__tstate);
3887 if (PyErr_Occurred()) SWIG_fail;
3888 }
3889 {
3890 resultobj = SWIG_From_int((int)(result));
3891 }
3892 return resultobj;
3893 fail:
3894 return NULL;
3895 }
3896
3897
3898 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3899 PyObject *resultobj;
3900 wxBrush *arg1 = (wxBrush *) 0 ;
3901 wxBitmap *result;
3902 PyObject * obj0 = 0 ;
3903 char *kwnames[] = {
3904 (char *) "self", NULL
3905 };
3906
3907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 wxBrush *arg1 = (wxBrush *) 0 ;
3927 bool result;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "self", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 result = (bool)((wxBrush const *)arg1)->IsHatch();
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 {
3944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3945 }
3946 return resultobj;
3947 fail:
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxBrush *arg1 = (wxBrush *) 0 ;
3955 bool result;
3956 PyObject * obj0 = 0 ;
3957 char *kwnames[] = {
3958 (char *) "self", NULL
3959 };
3960
3961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3963 if (SWIG_arg_fail(1)) SWIG_fail;
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 result = (bool)(arg1)->Ok();
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 {
3972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3973 }
3974 return resultobj;
3975 fail:
3976 return NULL;
3977 }
3978
3979
3980 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3981 PyObject *obj;
3982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3983 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3984 Py_INCREF(obj);
3985 return Py_BuildValue((char *)"");
3986 }
3987 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj;
3989 wxString *arg1 = 0 ;
3990 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3991 wxBitmap *result;
3992 bool temp1 = false ;
3993 PyObject * obj0 = 0 ;
3994 PyObject * obj1 = 0 ;
3995 char *kwnames[] = {
3996 (char *) "name",(char *) "type", NULL
3997 };
3998
3999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4000 {
4001 arg1 = wxString_in_helper(obj0);
4002 if (arg1 == NULL) SWIG_fail;
4003 temp1 = true;
4004 }
4005 if (obj1) {
4006 {
4007 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4008 if (SWIG_arg_fail(2)) SWIG_fail;
4009 }
4010 }
4011 {
4012 if (!wxPyCheckForApp()) SWIG_fail;
4013 PyThreadState* __tstate = wxPyBeginAllowThreads();
4014 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4015
4016 wxPyEndAllowThreads(__tstate);
4017 if (PyErr_Occurred()) SWIG_fail;
4018 }
4019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4020 {
4021 if (temp1)
4022 delete arg1;
4023 }
4024 return resultobj;
4025 fail:
4026 {
4027 if (temp1)
4028 delete arg1;
4029 }
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj;
4036 wxBitmap *arg1 = (wxBitmap *) 0 ;
4037 PyObject * obj0 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "self", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4044 if (SWIG_arg_fail(1)) SWIG_fail;
4045 {
4046 PyThreadState* __tstate = wxPyBeginAllowThreads();
4047 delete arg1;
4048
4049 wxPyEndAllowThreads(__tstate);
4050 if (PyErr_Occurred()) SWIG_fail;
4051 }
4052 Py_INCREF(Py_None); resultobj = Py_None;
4053 return resultobj;
4054 fail:
4055 return NULL;
4056 }
4057
4058
4059 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4060 PyObject *resultobj;
4061 int arg1 ;
4062 int arg2 ;
4063 int arg3 = (int) -1 ;
4064 wxBitmap *result;
4065 PyObject * obj0 = 0 ;
4066 PyObject * obj1 = 0 ;
4067 PyObject * obj2 = 0 ;
4068 char *kwnames[] = {
4069 (char *) "width",(char *) "height",(char *) "depth", NULL
4070 };
4071
4072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4073 {
4074 arg1 = (int)(SWIG_As_int(obj0));
4075 if (SWIG_arg_fail(1)) SWIG_fail;
4076 }
4077 {
4078 arg2 = (int)(SWIG_As_int(obj1));
4079 if (SWIG_arg_fail(2)) SWIG_fail;
4080 }
4081 if (obj2) {
4082 {
4083 arg3 = (int)(SWIG_As_int(obj2));
4084 if (SWIG_arg_fail(3)) SWIG_fail;
4085 }
4086 }
4087 {
4088 if (!wxPyCheckForApp()) SWIG_fail;
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 wxIcon *arg1 = 0 ;
4105 wxBitmap *result;
4106 PyObject * obj0 = 0 ;
4107 char *kwnames[] = {
4108 (char *) "icon", NULL
4109 };
4110
4111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4112 {
4113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4114 if (SWIG_arg_fail(1)) SWIG_fail;
4115 if (arg1 == NULL) {
4116 SWIG_null_ref("wxIcon");
4117 }
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 }
4120 {
4121 if (!wxPyCheckForApp()) SWIG_fail;
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 wxImage *arg1 = 0 ;
4138 int arg2 = (int) -1 ;
4139 wxBitmap *result;
4140 PyObject * obj0 = 0 ;
4141 PyObject * obj1 = 0 ;
4142 char *kwnames[] = {
4143 (char *) "image",(char *) "depth", NULL
4144 };
4145
4146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4147 {
4148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4149 if (SWIG_arg_fail(1)) SWIG_fail;
4150 if (arg1 == NULL) {
4151 SWIG_null_ref("wxImage");
4152 }
4153 if (SWIG_arg_fail(1)) SWIG_fail;
4154 }
4155 if (obj1) {
4156 {
4157 arg2 = (int)(SWIG_As_int(obj1));
4158 if (SWIG_arg_fail(2)) SWIG_fail;
4159 }
4160 }
4161 {
4162 if (!wxPyCheckForApp()) SWIG_fail;
4163 PyThreadState* __tstate = wxPyBeginAllowThreads();
4164 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4165
4166 wxPyEndAllowThreads(__tstate);
4167 if (PyErr_Occurred()) SWIG_fail;
4168 }
4169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 PyObject *arg1 = (PyObject *) 0 ;
4179 wxBitmap *result;
4180 PyObject * obj0 = 0 ;
4181 char *kwnames[] = {
4182 (char *) "listOfStrings", NULL
4183 };
4184
4185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4186 arg1 = obj0;
4187 {
4188 if (!wxPyCheckForApp()) SWIG_fail;
4189 PyThreadState* __tstate = wxPyBeginAllowThreads();
4190 result = (wxBitmap *)new_wxBitmap(arg1);
4191
4192 wxPyEndAllowThreads(__tstate);
4193 if (PyErr_Occurred()) SWIG_fail;
4194 }
4195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4196 return resultobj;
4197 fail:
4198 return NULL;
4199 }
4200
4201
4202 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4203 PyObject *resultobj;
4204 PyObject *arg1 = (PyObject *) 0 ;
4205 int arg2 ;
4206 int arg3 ;
4207 int arg4 = (int) 1 ;
4208 wxBitmap *result;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4211 PyObject * obj2 = 0 ;
4212 PyObject * obj3 = 0 ;
4213 char *kwnames[] = {
4214 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4215 };
4216
4217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4218 arg1 = obj0;
4219 {
4220 arg2 = (int)(SWIG_As_int(obj1));
4221 if (SWIG_arg_fail(2)) SWIG_fail;
4222 }
4223 {
4224 arg3 = (int)(SWIG_As_int(obj2));
4225 if (SWIG_arg_fail(3)) SWIG_fail;
4226 }
4227 if (obj3) {
4228 {
4229 arg4 = (int)(SWIG_As_int(obj3));
4230 if (SWIG_arg_fail(4)) SWIG_fail;
4231 }
4232 }
4233 {
4234 if (!wxPyCheckForApp()) SWIG_fail;
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj;
4250 wxBitmap *arg1 = (wxBitmap *) 0 ;
4251 bool result;
4252 PyObject * obj0 = 0 ;
4253 char *kwnames[] = {
4254 (char *) "self", NULL
4255 };
4256
4257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (bool)(arg1)->Ok();
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 {
4268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4269 }
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4277 PyObject *resultobj;
4278 wxBitmap *arg1 = (wxBitmap *) 0 ;
4279 int result;
4280 PyObject * obj0 = 0 ;
4281 char *kwnames[] = {
4282 (char *) "self", NULL
4283 };
4284
4285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4287 if (SWIG_arg_fail(1)) SWIG_fail;
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = (int)(arg1)->GetWidth();
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 {
4296 resultobj = SWIG_From_int((int)(result));
4297 }
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 wxBitmap *arg1 = (wxBitmap *) 0 ;
4307 int result;
4308 PyObject * obj0 = 0 ;
4309 char *kwnames[] = {
4310 (char *) "self", NULL
4311 };
4312
4313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4315 if (SWIG_arg_fail(1)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (int)(arg1)->GetHeight();
4319
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 {
4324 resultobj = SWIG_From_int((int)(result));
4325 }
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj;
4334 wxBitmap *arg1 = (wxBitmap *) 0 ;
4335 int result;
4336 PyObject * obj0 = 0 ;
4337 char *kwnames[] = {
4338 (char *) "self", NULL
4339 };
4340
4341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4343 if (SWIG_arg_fail(1)) SWIG_fail;
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 result = (int)(arg1)->GetDepth();
4347
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 {
4352 resultobj = SWIG_From_int((int)(result));
4353 }
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxBitmap *arg1 = (wxBitmap *) 0 ;
4363 wxSize result;
4364 PyObject * obj0 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "self", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(1)) SWIG_fail;
4372 {
4373 PyThreadState* __tstate = wxPyBeginAllowThreads();
4374 result = wxBitmap_GetSize(arg1);
4375
4376 wxPyEndAllowThreads(__tstate);
4377 if (PyErr_Occurred()) SWIG_fail;
4378 }
4379 {
4380 wxSize * resultptr;
4381 resultptr = new wxSize((wxSize &)(result));
4382 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4383 }
4384 return resultobj;
4385 fail:
4386 return NULL;
4387 }
4388
4389
4390 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj;
4392 wxBitmap *arg1 = (wxBitmap *) 0 ;
4393 SwigValueWrapper<wxImage > result;
4394 PyObject * obj0 = 0 ;
4395 char *kwnames[] = {
4396 (char *) "self", NULL
4397 };
4398
4399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4401 if (SWIG_arg_fail(1)) SWIG_fail;
4402 {
4403 PyThreadState* __tstate = wxPyBeginAllowThreads();
4404 result = ((wxBitmap const *)arg1)->ConvertToImage();
4405
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 {
4410 wxImage * resultptr;
4411 resultptr = new wxImage((wxImage &)(result));
4412 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4413 }
4414 return resultobj;
4415 fail:
4416 return NULL;
4417 }
4418
4419
4420 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4421 PyObject *resultobj;
4422 wxBitmap *arg1 = (wxBitmap *) 0 ;
4423 wxMask *result;
4424 PyObject * obj0 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "self", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(1)) SWIG_fail;
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxBitmap *arg1 = (wxBitmap *) 0 ;
4449 wxMask *arg2 = (wxMask *) 0 ;
4450 PyObject * obj0 = 0 ;
4451 PyObject * obj1 = 0 ;
4452 char *kwnames[] = {
4453 (char *) "self",(char *) "mask", NULL
4454 };
4455
4456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4458 if (SWIG_arg_fail(1)) SWIG_fail;
4459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4460 if (SWIG_arg_fail(2)) SWIG_fail;
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 (arg1)->SetMask(arg2);
4464
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 Py_INCREF(Py_None); resultobj = Py_None;
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 wxBitmap *arg1 = (wxBitmap *) 0 ;
4478 wxColour *arg2 = 0 ;
4479 wxColour temp2 ;
4480 PyObject * obj0 = 0 ;
4481 PyObject * obj1 = 0 ;
4482 char *kwnames[] = {
4483 (char *) "self",(char *) "colour", NULL
4484 };
4485
4486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4488 if (SWIG_arg_fail(1)) SWIG_fail;
4489 {
4490 arg2 = &temp2;
4491 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4492 }
4493 {
4494 PyThreadState* __tstate = wxPyBeginAllowThreads();
4495 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4496
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 Py_INCREF(Py_None); resultobj = Py_None;
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj;
4509 wxBitmap *arg1 = (wxBitmap *) 0 ;
4510 wxRect *arg2 = 0 ;
4511 SwigValueWrapper<wxBitmap > result;
4512 wxRect temp2 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char *kwnames[] = {
4516 (char *) "self",(char *) "rect", NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4521 if (SWIG_arg_fail(1)) SWIG_fail;
4522 {
4523 arg2 = &temp2;
4524 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4525 }
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4529
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 {
4534 wxBitmap * resultptr;
4535 resultptr = new wxBitmap((wxBitmap &)(result));
4536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4537 }
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4545 PyObject *resultobj;
4546 wxBitmap *arg1 = (wxBitmap *) 0 ;
4547 wxString *arg2 = 0 ;
4548 wxBitmapType arg3 ;
4549 wxPalette *arg4 = (wxPalette *) NULL ;
4550 bool result;
4551 bool temp2 = false ;
4552 PyObject * obj0 = 0 ;
4553 PyObject * obj1 = 0 ;
4554 PyObject * obj2 = 0 ;
4555 PyObject * obj3 = 0 ;
4556 char *kwnames[] = {
4557 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4558 };
4559
4560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4562 if (SWIG_arg_fail(1)) SWIG_fail;
4563 {
4564 arg2 = wxString_in_helper(obj1);
4565 if (arg2 == NULL) SWIG_fail;
4566 temp2 = true;
4567 }
4568 {
4569 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4570 if (SWIG_arg_fail(3)) SWIG_fail;
4571 }
4572 if (obj3) {
4573 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4574 if (SWIG_arg_fail(4)) SWIG_fail;
4575 }
4576 {
4577 PyThreadState* __tstate = wxPyBeginAllowThreads();
4578 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4579
4580 wxPyEndAllowThreads(__tstate);
4581 if (PyErr_Occurred()) SWIG_fail;
4582 }
4583 {
4584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4585 }
4586 {
4587 if (temp2)
4588 delete arg2;
4589 }
4590 return resultobj;
4591 fail:
4592 {
4593 if (temp2)
4594 delete arg2;
4595 }
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxBitmap *arg1 = (wxBitmap *) 0 ;
4603 wxString *arg2 = 0 ;
4604 wxBitmapType arg3 ;
4605 bool result;
4606 bool temp2 = false ;
4607 PyObject * obj0 = 0 ;
4608 PyObject * obj1 = 0 ;
4609 PyObject * obj2 = 0 ;
4610 char *kwnames[] = {
4611 (char *) "self",(char *) "name",(char *) "type", NULL
4612 };
4613
4614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4616 if (SWIG_arg_fail(1)) SWIG_fail;
4617 {
4618 arg2 = wxString_in_helper(obj1);
4619 if (arg2 == NULL) SWIG_fail;
4620 temp2 = true;
4621 }
4622 {
4623 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4624 if (SWIG_arg_fail(3)) SWIG_fail;
4625 }
4626 {
4627 PyThreadState* __tstate = wxPyBeginAllowThreads();
4628 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4629
4630 wxPyEndAllowThreads(__tstate);
4631 if (PyErr_Occurred()) SWIG_fail;
4632 }
4633 {
4634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4635 }
4636 {
4637 if (temp2)
4638 delete arg2;
4639 }
4640 return resultobj;
4641 fail:
4642 {
4643 if (temp2)
4644 delete arg2;
4645 }
4646 return NULL;
4647 }
4648
4649
4650 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj;
4652 wxBitmap *arg1 = (wxBitmap *) 0 ;
4653 wxPalette *result;
4654 PyObject * obj0 = 0 ;
4655 char *kwnames[] = {
4656 (char *) "self", NULL
4657 };
4658
4659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4661 if (SWIG_arg_fail(1)) SWIG_fail;
4662 {
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4665
4666 wxPyEndAllowThreads(__tstate);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj;
4678 wxBitmap *arg1 = (wxBitmap *) 0 ;
4679 wxIcon *arg2 = 0 ;
4680 bool result;
4681 PyObject * obj0 = 0 ;
4682 PyObject * obj1 = 0 ;
4683 char *kwnames[] = {
4684 (char *) "self",(char *) "icon", NULL
4685 };
4686
4687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4689 if (SWIG_arg_fail(1)) SWIG_fail;
4690 {
4691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4692 if (SWIG_arg_fail(2)) SWIG_fail;
4693 if (arg2 == NULL) {
4694 SWIG_null_ref("wxIcon");
4695 }
4696 if (SWIG_arg_fail(2)) SWIG_fail;
4697 }
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4701
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 {
4706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4707 }
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj;
4716 wxBitmap *arg1 = (wxBitmap *) 0 ;
4717 int arg2 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char *kwnames[] = {
4721 (char *) "self",(char *) "height", NULL
4722 };
4723
4724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4726 if (SWIG_arg_fail(1)) SWIG_fail;
4727 {
4728 arg2 = (int)(SWIG_As_int(obj1));
4729 if (SWIG_arg_fail(2)) SWIG_fail;
4730 }
4731 {
4732 PyThreadState* __tstate = wxPyBeginAllowThreads();
4733 (arg1)->SetHeight(arg2);
4734
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 Py_INCREF(Py_None); resultobj = Py_None;
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj;
4747 wxBitmap *arg1 = (wxBitmap *) 0 ;
4748 int arg2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "self",(char *) "width", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4757 if (SWIG_arg_fail(1)) SWIG_fail;
4758 {
4759 arg2 = (int)(SWIG_As_int(obj1));
4760 if (SWIG_arg_fail(2)) SWIG_fail;
4761 }
4762 {
4763 PyThreadState* __tstate = wxPyBeginAllowThreads();
4764 (arg1)->SetWidth(arg2);
4765
4766 wxPyEndAllowThreads(__tstate);
4767 if (PyErr_Occurred()) SWIG_fail;
4768 }
4769 Py_INCREF(Py_None); resultobj = Py_None;
4770 return resultobj;
4771 fail:
4772 return NULL;
4773 }
4774
4775
4776 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj;
4778 wxBitmap *arg1 = (wxBitmap *) 0 ;
4779 int arg2 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 char *kwnames[] = {
4783 (char *) "self",(char *) "depth", NULL
4784 };
4785
4786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4788 if (SWIG_arg_fail(1)) SWIG_fail;
4789 {
4790 arg2 = (int)(SWIG_As_int(obj1));
4791 if (SWIG_arg_fail(2)) SWIG_fail;
4792 }
4793 {
4794 PyThreadState* __tstate = wxPyBeginAllowThreads();
4795 (arg1)->SetDepth(arg2);
4796
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 Py_INCREF(Py_None); resultobj = Py_None;
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj;
4809 wxBitmap *arg1 = (wxBitmap *) 0 ;
4810 wxSize *arg2 = 0 ;
4811 wxSize temp2 ;
4812 PyObject * obj0 = 0 ;
4813 PyObject * obj1 = 0 ;
4814 char *kwnames[] = {
4815 (char *) "self",(char *) "size", NULL
4816 };
4817
4818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4820 if (SWIG_arg_fail(1)) SWIG_fail;
4821 {
4822 arg2 = &temp2;
4823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4828
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 Py_INCREF(Py_None); resultobj = Py_None;
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj;
4841 wxBitmap *arg1 = (wxBitmap *) 0 ;
4842 wxBitmap *arg2 = (wxBitmap *) 0 ;
4843 bool result;
4844 PyObject * obj0 = 0 ;
4845 PyObject * obj1 = 0 ;
4846 char *kwnames[] = {
4847 (char *) "self",(char *) "other", NULL
4848 };
4849
4850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4852 if (SWIG_arg_fail(1)) SWIG_fail;
4853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4854 if (SWIG_arg_fail(2)) SWIG_fail;
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4858
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 {
4863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4864 }
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj;
4873 wxBitmap *arg1 = (wxBitmap *) 0 ;
4874 wxBitmap *arg2 = (wxBitmap *) 0 ;
4875 bool result;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 char *kwnames[] = {
4879 (char *) "self",(char *) "other", NULL
4880 };
4881
4882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4884 if (SWIG_arg_fail(1)) SWIG_fail;
4885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4886 if (SWIG_arg_fail(2)) SWIG_fail;
4887 {
4888 PyThreadState* __tstate = wxPyBeginAllowThreads();
4889 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4890
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 {
4895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4896 }
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4904 PyObject *obj;
4905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4906 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4907 Py_INCREF(obj);
4908 return Py_BuildValue((char *)"");
4909 }
4910 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxBitmap *arg1 = 0 ;
4913 wxColour const &arg2_defvalue = wxNullColour ;
4914 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4915 wxMask *result;
4916 wxColour temp2 ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 char *kwnames[] = {
4920 (char *) "bitmap",(char *) "colour", NULL
4921 };
4922
4923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4924 {
4925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4926 if (SWIG_arg_fail(1)) SWIG_fail;
4927 if (arg1 == NULL) {
4928 SWIG_null_ref("wxBitmap");
4929 }
4930 if (SWIG_arg_fail(1)) SWIG_fail;
4931 }
4932 if (obj1) {
4933 {
4934 arg2 = &temp2;
4935 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4936 }
4937 }
4938 {
4939 if (!wxPyCheckForApp()) SWIG_fail;
4940 PyThreadState* __tstate = wxPyBeginAllowThreads();
4941 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4942
4943 wxPyEndAllowThreads(__tstate);
4944 if (PyErr_Occurred()) SWIG_fail;
4945 }
4946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4947 return resultobj;
4948 fail:
4949 return NULL;
4950 }
4951
4952
4953 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4954 PyObject *obj;
4955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4956 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4957 Py_INCREF(obj);
4958 return Py_BuildValue((char *)"");
4959 }
4960 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4961 PyObject *resultobj;
4962 wxString *arg1 = 0 ;
4963 wxBitmapType arg2 ;
4964 int arg3 = (int) -1 ;
4965 int arg4 = (int) -1 ;
4966 wxIcon *result;
4967 bool temp1 = false ;
4968 PyObject * obj0 = 0 ;
4969 PyObject * obj1 = 0 ;
4970 PyObject * obj2 = 0 ;
4971 PyObject * obj3 = 0 ;
4972 char *kwnames[] = {
4973 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4974 };
4975
4976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4977 {
4978 arg1 = wxString_in_helper(obj0);
4979 if (arg1 == NULL) SWIG_fail;
4980 temp1 = true;
4981 }
4982 {
4983 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4984 if (SWIG_arg_fail(2)) SWIG_fail;
4985 }
4986 if (obj2) {
4987 {
4988 arg3 = (int)(SWIG_As_int(obj2));
4989 if (SWIG_arg_fail(3)) SWIG_fail;
4990 }
4991 }
4992 if (obj3) {
4993 {
4994 arg4 = (int)(SWIG_As_int(obj3));
4995 if (SWIG_arg_fail(4)) SWIG_fail;
4996 }
4997 }
4998 {
4999 if (!wxPyCheckForApp()) SWIG_fail;
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5007 {
5008 if (temp1)
5009 delete arg1;
5010 }
5011 return resultobj;
5012 fail:
5013 {
5014 if (temp1)
5015 delete arg1;
5016 }
5017 return NULL;
5018 }
5019
5020
5021 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5022 PyObject *resultobj;
5023 wxIcon *arg1 = (wxIcon *) 0 ;
5024 PyObject * obj0 = 0 ;
5025 char *kwnames[] = {
5026 (char *) "self", NULL
5027 };
5028
5029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5031 if (SWIG_arg_fail(1)) SWIG_fail;
5032 {
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 delete arg1;
5035
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 Py_INCREF(Py_None); resultobj = Py_None;
5040 return resultobj;
5041 fail:
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxIcon *result;
5049 char *kwnames[] = {
5050 NULL
5051 };
5052
5053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5054 {
5055 if (!wxPyCheckForApp()) SWIG_fail;
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (wxIcon *)new wxIcon();
5058
5059 wxPyEndAllowThreads(__tstate);
5060 if (PyErr_Occurred()) SWIG_fail;
5061 }
5062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5063 return resultobj;
5064 fail:
5065 return NULL;
5066 }
5067
5068
5069 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5070 PyObject *resultobj;
5071 wxIconLocation *arg1 = 0 ;
5072 wxIcon *result;
5073 PyObject * obj0 = 0 ;
5074 char *kwnames[] = {
5075 (char *) "loc", NULL
5076 };
5077
5078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5079 {
5080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5081 if (SWIG_arg_fail(1)) SWIG_fail;
5082 if (arg1 == NULL) {
5083 SWIG_null_ref("wxIconLocation");
5084 }
5085 if (SWIG_arg_fail(1)) SWIG_fail;
5086 }
5087 {
5088 if (!wxPyCheckForApp()) SWIG_fail;
5089 PyThreadState* __tstate = wxPyBeginAllowThreads();
5090 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5091
5092 wxPyEndAllowThreads(__tstate);
5093 if (PyErr_Occurred()) SWIG_fail;
5094 }
5095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5096 return resultobj;
5097 fail:
5098 return NULL;
5099 }
5100
5101
5102 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5103 PyObject *resultobj;
5104 wxBitmap *arg1 = 0 ;
5105 wxIcon *result;
5106 PyObject * obj0 = 0 ;
5107 char *kwnames[] = {
5108 (char *) "bmp", NULL
5109 };
5110
5111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5112 {
5113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5114 if (SWIG_arg_fail(1)) SWIG_fail;
5115 if (arg1 == NULL) {
5116 SWIG_null_ref("wxBitmap");
5117 }
5118 if (SWIG_arg_fail(1)) SWIG_fail;
5119 }
5120 {
5121 if (!wxPyCheckForApp()) SWIG_fail;
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5124
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj;
5137 PyObject *arg1 = (PyObject *) 0 ;
5138 wxIcon *result;
5139 PyObject * obj0 = 0 ;
5140 char *kwnames[] = {
5141 (char *) "listOfStrings", NULL
5142 };
5143
5144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5145 arg1 = obj0;
5146 {
5147 if (!wxPyCheckForApp()) SWIG_fail;
5148 PyThreadState* __tstate = wxPyBeginAllowThreads();
5149 result = (wxIcon *)new_wxIcon(arg1);
5150
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj;
5163 wxIcon *arg1 = (wxIcon *) 0 ;
5164 wxString *arg2 = 0 ;
5165 wxBitmapType arg3 ;
5166 bool result;
5167 bool temp2 = false ;
5168 PyObject * obj0 = 0 ;
5169 PyObject * obj1 = 0 ;
5170 PyObject * obj2 = 0 ;
5171 char *kwnames[] = {
5172 (char *) "self",(char *) "name",(char *) "type", NULL
5173 };
5174
5175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5177 if (SWIG_arg_fail(1)) SWIG_fail;
5178 {
5179 arg2 = wxString_in_helper(obj1);
5180 if (arg2 == NULL) SWIG_fail;
5181 temp2 = true;
5182 }
5183 {
5184 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5185 if (SWIG_arg_fail(3)) SWIG_fail;
5186 }
5187 {
5188 PyThreadState* __tstate = wxPyBeginAllowThreads();
5189 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5190
5191 wxPyEndAllowThreads(__tstate);
5192 if (PyErr_Occurred()) SWIG_fail;
5193 }
5194 {
5195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5196 }
5197 {
5198 if (temp2)
5199 delete arg2;
5200 }
5201 return resultobj;
5202 fail:
5203 {
5204 if (temp2)
5205 delete arg2;
5206 }
5207 return NULL;
5208 }
5209
5210
5211 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj;
5213 wxIcon *arg1 = (wxIcon *) 0 ;
5214 bool result;
5215 PyObject * obj0 = 0 ;
5216 char *kwnames[] = {
5217 (char *) "self", NULL
5218 };
5219
5220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5222 if (SWIG_arg_fail(1)) SWIG_fail;
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 result = (bool)(arg1)->Ok();
5226
5227 wxPyEndAllowThreads(__tstate);
5228 if (PyErr_Occurred()) SWIG_fail;
5229 }
5230 {
5231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5232 }
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5240 PyObject *resultobj;
5241 wxIcon *arg1 = (wxIcon *) 0 ;
5242 int result;
5243 PyObject * obj0 = 0 ;
5244 char *kwnames[] = {
5245 (char *) "self", NULL
5246 };
5247
5248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5250 if (SWIG_arg_fail(1)) SWIG_fail;
5251 {
5252 PyThreadState* __tstate = wxPyBeginAllowThreads();
5253 result = (int)(arg1)->GetWidth();
5254
5255 wxPyEndAllowThreads(__tstate);
5256 if (PyErr_Occurred()) SWIG_fail;
5257 }
5258 {
5259 resultobj = SWIG_From_int((int)(result));
5260 }
5261 return resultobj;
5262 fail:
5263 return NULL;
5264 }
5265
5266
5267 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5268 PyObject *resultobj;
5269 wxIcon *arg1 = (wxIcon *) 0 ;
5270 int result;
5271 PyObject * obj0 = 0 ;
5272 char *kwnames[] = {
5273 (char *) "self", NULL
5274 };
5275
5276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5278 if (SWIG_arg_fail(1)) SWIG_fail;
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 result = (int)(arg1)->GetHeight();
5282
5283 wxPyEndAllowThreads(__tstate);
5284 if (PyErr_Occurred()) SWIG_fail;
5285 }
5286 {
5287 resultobj = SWIG_From_int((int)(result));
5288 }
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5296 PyObject *resultobj;
5297 wxIcon *arg1 = (wxIcon *) 0 ;
5298 int result;
5299 PyObject * obj0 = 0 ;
5300 char *kwnames[] = {
5301 (char *) "self", NULL
5302 };
5303
5304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5306 if (SWIG_arg_fail(1)) SWIG_fail;
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = (int)(arg1)->GetDepth();
5310
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 resultobj = SWIG_From_int((int)(result));
5316 }
5317 return resultobj;
5318 fail:
5319 return NULL;
5320 }
5321
5322
5323 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5324 PyObject *resultobj;
5325 wxIcon *arg1 = (wxIcon *) 0 ;
5326 int arg2 ;
5327 PyObject * obj0 = 0 ;
5328 PyObject * obj1 = 0 ;
5329 char *kwnames[] = {
5330 (char *) "self",(char *) "w", NULL
5331 };
5332
5333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5335 if (SWIG_arg_fail(1)) SWIG_fail;
5336 {
5337 arg2 = (int)(SWIG_As_int(obj1));
5338 if (SWIG_arg_fail(2)) SWIG_fail;
5339 }
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 (arg1)->SetWidth(arg2);
5343
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 Py_INCREF(Py_None); resultobj = Py_None;
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5355 PyObject *resultobj;
5356 wxIcon *arg1 = (wxIcon *) 0 ;
5357 int arg2 ;
5358 PyObject * obj0 = 0 ;
5359 PyObject * obj1 = 0 ;
5360 char *kwnames[] = {
5361 (char *) "self",(char *) "h", NULL
5362 };
5363
5364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5366 if (SWIG_arg_fail(1)) SWIG_fail;
5367 {
5368 arg2 = (int)(SWIG_As_int(obj1));
5369 if (SWIG_arg_fail(2)) SWIG_fail;
5370 }
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 (arg1)->SetHeight(arg2);
5374
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 Py_INCREF(Py_None); resultobj = Py_None;
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5386 PyObject *resultobj;
5387 wxIcon *arg1 = (wxIcon *) 0 ;
5388 int arg2 ;
5389 PyObject * obj0 = 0 ;
5390 PyObject * obj1 = 0 ;
5391 char *kwnames[] = {
5392 (char *) "self",(char *) "d", NULL
5393 };
5394
5395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5397 if (SWIG_arg_fail(1)) SWIG_fail;
5398 {
5399 arg2 = (int)(SWIG_As_int(obj1));
5400 if (SWIG_arg_fail(2)) SWIG_fail;
5401 }
5402 {
5403 PyThreadState* __tstate = wxPyBeginAllowThreads();
5404 (arg1)->SetDepth(arg2);
5405
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 Py_INCREF(Py_None); resultobj = Py_None;
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj;
5418 wxIcon *arg1 = (wxIcon *) 0 ;
5419 wxBitmap *arg2 = 0 ;
5420 PyObject * obj0 = 0 ;
5421 PyObject * obj1 = 0 ;
5422 char *kwnames[] = {
5423 (char *) "self",(char *) "bmp", NULL
5424 };
5425
5426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5428 if (SWIG_arg_fail(1)) SWIG_fail;
5429 {
5430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(2)) SWIG_fail;
5432 if (arg2 == NULL) {
5433 SWIG_null_ref("wxBitmap");
5434 }
5435 if (SWIG_arg_fail(2)) SWIG_fail;
5436 }
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5440
5441 wxPyEndAllowThreads(__tstate);
5442 if (PyErr_Occurred()) SWIG_fail;
5443 }
5444 Py_INCREF(Py_None); resultobj = Py_None;
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5452 PyObject *obj;
5453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5454 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5455 Py_INCREF(obj);
5456 return Py_BuildValue((char *)"");
5457 }
5458 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj;
5460 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5461 int arg2 = (int) 0 ;
5462 wxIconLocation *result;
5463 bool temp1 = false ;
5464 PyObject * obj0 = 0 ;
5465 PyObject * obj1 = 0 ;
5466 char *kwnames[] = {
5467 (char *) "filename",(char *) "num", NULL
5468 };
5469
5470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5471 if (obj0) {
5472 {
5473 arg1 = wxString_in_helper(obj0);
5474 if (arg1 == NULL) SWIG_fail;
5475 temp1 = true;
5476 }
5477 }
5478 if (obj1) {
5479 {
5480 arg2 = (int)(SWIG_As_int(obj1));
5481 if (SWIG_arg_fail(2)) SWIG_fail;
5482 }
5483 }
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5492 {
5493 if (temp1)
5494 delete arg1;
5495 }
5496 return resultobj;
5497 fail:
5498 {
5499 if (temp1)
5500 delete arg1;
5501 }
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5509 PyObject * obj0 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 delete arg1;
5520
5521 wxPyEndAllowThreads(__tstate);
5522 if (PyErr_Occurred()) SWIG_fail;
5523 }
5524 Py_INCREF(Py_None); resultobj = Py_None;
5525 return resultobj;
5526 fail:
5527 return NULL;
5528 }
5529
5530
5531 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5532 PyObject *resultobj;
5533 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5534 bool result;
5535 PyObject * obj0 = 0 ;
5536 char *kwnames[] = {
5537 (char *) "self", NULL
5538 };
5539
5540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5542 if (SWIG_arg_fail(1)) SWIG_fail;
5543 {
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5546
5547 wxPyEndAllowThreads(__tstate);
5548 if (PyErr_Occurred()) SWIG_fail;
5549 }
5550 {
5551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5552 }
5553 return resultobj;
5554 fail:
5555 return NULL;
5556 }
5557
5558
5559 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5560 PyObject *resultobj;
5561 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5562 wxString *arg2 = 0 ;
5563 bool temp2 = false ;
5564 PyObject * obj0 = 0 ;
5565 PyObject * obj1 = 0 ;
5566 char *kwnames[] = {
5567 (char *) "self",(char *) "filename", NULL
5568 };
5569
5570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5572 if (SWIG_arg_fail(1)) SWIG_fail;
5573 {
5574 arg2 = wxString_in_helper(obj1);
5575 if (arg2 == NULL) SWIG_fail;
5576 temp2 = true;
5577 }
5578 {
5579 PyThreadState* __tstate = wxPyBeginAllowThreads();
5580 (arg1)->SetFileName((wxString const &)*arg2);
5581
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 Py_INCREF(Py_None); resultobj = Py_None;
5586 {
5587 if (temp2)
5588 delete arg2;
5589 }
5590 return resultobj;
5591 fail:
5592 {
5593 if (temp2)
5594 delete arg2;
5595 }
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj;
5602 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5603 wxString *result;
5604 PyObject * obj0 = 0 ;
5605 char *kwnames[] = {
5606 (char *) "self", NULL
5607 };
5608
5609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5611 if (SWIG_arg_fail(1)) SWIG_fail;
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 {
5615 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5616 result = (wxString *) &_result_ref;
5617 }
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 {
5623 #if wxUSE_UNICODE
5624 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5625 #else
5626 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5627 #endif
5628 }
5629 return resultobj;
5630 fail:
5631 return NULL;
5632 }
5633
5634
5635 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5636 PyObject *resultobj;
5637 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5638 int arg2 ;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 char *kwnames[] = {
5642 (char *) "self",(char *) "num", NULL
5643 };
5644
5645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5647 if (SWIG_arg_fail(1)) SWIG_fail;
5648 {
5649 arg2 = (int)(SWIG_As_int(obj1));
5650 if (SWIG_arg_fail(2)) SWIG_fail;
5651 }
5652 {
5653 PyThreadState* __tstate = wxPyBeginAllowThreads();
5654 wxIconLocation_SetIndex(arg1,arg2);
5655
5656 wxPyEndAllowThreads(__tstate);
5657 if (PyErr_Occurred()) SWIG_fail;
5658 }
5659 Py_INCREF(Py_None); resultobj = Py_None;
5660 return resultobj;
5661 fail:
5662 return NULL;
5663 }
5664
5665
5666 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5667 PyObject *resultobj;
5668 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5669 int result;
5670 PyObject * obj0 = 0 ;
5671 char *kwnames[] = {
5672 (char *) "self", NULL
5673 };
5674
5675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5677 if (SWIG_arg_fail(1)) SWIG_fail;
5678 {
5679 PyThreadState* __tstate = wxPyBeginAllowThreads();
5680 result = (int)wxIconLocation_GetIndex(arg1);
5681
5682 wxPyEndAllowThreads(__tstate);
5683 if (PyErr_Occurred()) SWIG_fail;
5684 }
5685 {
5686 resultobj = SWIG_From_int((int)(result));
5687 }
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5695 PyObject *obj;
5696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5697 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5698 Py_INCREF(obj);
5699 return Py_BuildValue((char *)"");
5700 }
5701 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5702 PyObject *resultobj;
5703 wxIconBundle *result;
5704 char *kwnames[] = {
5705 NULL
5706 };
5707
5708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5709 {
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = (wxIconBundle *)new wxIconBundle();
5712
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5717 return resultobj;
5718 fail:
5719 return NULL;
5720 }
5721
5722
5723 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5724 PyObject *resultobj;
5725 wxString *arg1 = 0 ;
5726 long arg2 ;
5727 wxIconBundle *result;
5728 bool temp1 = false ;
5729 PyObject * obj0 = 0 ;
5730 PyObject * obj1 = 0 ;
5731 char *kwnames[] = {
5732 (char *) "file",(char *) "type", NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5736 {
5737 arg1 = wxString_in_helper(obj0);
5738 if (arg1 == NULL) SWIG_fail;
5739 temp1 = true;
5740 }
5741 {
5742 arg2 = (long)(SWIG_As_long(obj1));
5743 if (SWIG_arg_fail(2)) SWIG_fail;
5744 }
5745 {
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5753 {
5754 if (temp1)
5755 delete arg1;
5756 }
5757 return resultobj;
5758 fail:
5759 {
5760 if (temp1)
5761 delete arg1;
5762 }
5763 return NULL;
5764 }
5765
5766
5767 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5768 PyObject *resultobj;
5769 wxIcon *arg1 = 0 ;
5770 wxIconBundle *result;
5771 PyObject * obj0 = 0 ;
5772 char *kwnames[] = {
5773 (char *) "icon", NULL
5774 };
5775
5776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5777 {
5778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5779 if (SWIG_arg_fail(1)) SWIG_fail;
5780 if (arg1 == NULL) {
5781 SWIG_null_ref("wxIcon");
5782 }
5783 if (SWIG_arg_fail(1)) SWIG_fail;
5784 }
5785 {
5786 PyThreadState* __tstate = wxPyBeginAllowThreads();
5787 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5788
5789 wxPyEndAllowThreads(__tstate);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5800 PyObject *resultobj;
5801 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5802 PyObject * obj0 = 0 ;
5803 char *kwnames[] = {
5804 (char *) "self", NULL
5805 };
5806
5807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5809 if (SWIG_arg_fail(1)) SWIG_fail;
5810 {
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 delete arg1;
5813
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 Py_INCREF(Py_None); resultobj = Py_None;
5818 return resultobj;
5819 fail:
5820 return NULL;
5821 }
5822
5823
5824 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5825 PyObject *resultobj;
5826 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5827 wxIcon *arg2 = 0 ;
5828 PyObject * obj0 = 0 ;
5829 PyObject * obj1 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "self",(char *) "icon", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5836 if (SWIG_arg_fail(1)) SWIG_fail;
5837 {
5838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5839 if (SWIG_arg_fail(2)) SWIG_fail;
5840 if (arg2 == NULL) {
5841 SWIG_null_ref("wxIcon");
5842 }
5843 if (SWIG_arg_fail(2)) SWIG_fail;
5844 }
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 (arg1)->AddIcon((wxIcon const &)*arg2);
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 Py_INCREF(Py_None); resultobj = Py_None;
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj;
5861 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5862 wxString *arg2 = 0 ;
5863 long arg3 ;
5864 bool temp2 = false ;
5865 PyObject * obj0 = 0 ;
5866 PyObject * obj1 = 0 ;
5867 PyObject * obj2 = 0 ;
5868 char *kwnames[] = {
5869 (char *) "self",(char *) "file",(char *) "type", NULL
5870 };
5871
5872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5874 if (SWIG_arg_fail(1)) SWIG_fail;
5875 {
5876 arg2 = wxString_in_helper(obj1);
5877 if (arg2 == NULL) SWIG_fail;
5878 temp2 = true;
5879 }
5880 {
5881 arg3 = (long)(SWIG_As_long(obj2));
5882 if (SWIG_arg_fail(3)) SWIG_fail;
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 Py_INCREF(Py_None); resultobj = Py_None;
5892 {
5893 if (temp2)
5894 delete arg2;
5895 }
5896 return resultobj;
5897 fail:
5898 {
5899 if (temp2)
5900 delete arg2;
5901 }
5902 return NULL;
5903 }
5904
5905
5906 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj;
5908 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5909 wxSize *arg2 = 0 ;
5910 wxIcon *result;
5911 wxSize temp2 ;
5912 PyObject * obj0 = 0 ;
5913 PyObject * obj1 = 0 ;
5914 char *kwnames[] = {
5915 (char *) "self",(char *) "size", NULL
5916 };
5917
5918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5920 if (SWIG_arg_fail(1)) SWIG_fail;
5921 {
5922 arg2 = &temp2;
5923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5924 }
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 {
5928 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5929 result = (wxIcon *) &_result_ref;
5930 }
5931
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 {
5936 wxIcon* resultptr = new wxIcon(*result);
5937 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5938 }
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5946 PyObject *obj;
5947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5948 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5949 Py_INCREF(obj);
5950 return Py_BuildValue((char *)"");
5951 }
5952 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj;
5954 wxString *arg1 = 0 ;
5955 long arg2 ;
5956 int arg3 = (int) 0 ;
5957 int arg4 = (int) 0 ;
5958 wxCursor *result;
5959 bool temp1 = false ;
5960 PyObject * obj0 = 0 ;
5961 PyObject * obj1 = 0 ;
5962 PyObject * obj2 = 0 ;
5963 PyObject * obj3 = 0 ;
5964 char *kwnames[] = {
5965 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5966 };
5967
5968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5969 {
5970 arg1 = wxString_in_helper(obj0);
5971 if (arg1 == NULL) SWIG_fail;
5972 temp1 = true;
5973 }
5974 {
5975 arg2 = (long)(SWIG_As_long(obj1));
5976 if (SWIG_arg_fail(2)) SWIG_fail;
5977 }
5978 if (obj2) {
5979 {
5980 arg3 = (int)(SWIG_As_int(obj2));
5981 if (SWIG_arg_fail(3)) SWIG_fail;
5982 }
5983 }
5984 if (obj3) {
5985 {
5986 arg4 = (int)(SWIG_As_int(obj3));
5987 if (SWIG_arg_fail(4)) SWIG_fail;
5988 }
5989 }
5990 {
5991 if (!wxPyCheckForApp()) SWIG_fail;
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5999 {
6000 if (temp1)
6001 delete arg1;
6002 }
6003 return resultobj;
6004 fail:
6005 {
6006 if (temp1)
6007 delete arg1;
6008 }
6009 return NULL;
6010 }
6011
6012
6013 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj;
6015 wxCursor *arg1 = (wxCursor *) 0 ;
6016 PyObject * obj0 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "self", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6023 if (SWIG_arg_fail(1)) SWIG_fail;
6024 {
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 delete arg1;
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 Py_INCREF(Py_None); resultobj = Py_None;
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 int arg1 ;
6041 wxCursor *result;
6042 PyObject * obj0 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "id", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6048 {
6049 arg1 = (int)(SWIG_As_int(obj0));
6050 if (SWIG_arg_fail(1)) SWIG_fail;
6051 }
6052 {
6053 if (!wxPyCheckForApp()) SWIG_fail;
6054 PyThreadState* __tstate = wxPyBeginAllowThreads();
6055 result = (wxCursor *)new wxCursor(arg1);
6056
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6061 return resultobj;
6062 fail:
6063 return NULL;
6064 }
6065
6066
6067 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj;
6069 wxImage *arg1 = 0 ;
6070 wxCursor *result;
6071 PyObject * obj0 = 0 ;
6072 char *kwnames[] = {
6073 (char *) "image", NULL
6074 };
6075
6076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6077 {
6078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6079 if (SWIG_arg_fail(1)) SWIG_fail;
6080 if (arg1 == NULL) {
6081 SWIG_null_ref("wxImage");
6082 }
6083 if (SWIG_arg_fail(1)) SWIG_fail;
6084 }
6085 {
6086 if (!wxPyCheckForApp()) SWIG_fail;
6087 PyThreadState* __tstate = wxPyBeginAllowThreads();
6088 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6089
6090 wxPyEndAllowThreads(__tstate);
6091 if (PyErr_Occurred()) SWIG_fail;
6092 }
6093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj;
6102 wxCursor *arg1 = (wxCursor *) 0 ;
6103 bool result;
6104 PyObject * obj0 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "self", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6111 if (SWIG_arg_fail(1)) SWIG_fail;
6112 {
6113 PyThreadState* __tstate = wxPyBeginAllowThreads();
6114 result = (bool)(arg1)->Ok();
6115
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 {
6120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6121 }
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6129 PyObject *obj;
6130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6131 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6132 Py_INCREF(obj);
6133 return Py_BuildValue((char *)"");
6134 }
6135 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj;
6137 int arg1 = (int) 0 ;
6138 int arg2 = (int) 0 ;
6139 int arg3 = (int) 0 ;
6140 int arg4 = (int) 0 ;
6141 wxRegion *result;
6142 PyObject * obj0 = 0 ;
6143 PyObject * obj1 = 0 ;
6144 PyObject * obj2 = 0 ;
6145 PyObject * obj3 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6151 if (obj0) {
6152 {
6153 arg1 = (int)(SWIG_As_int(obj0));
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 }
6156 }
6157 if (obj1) {
6158 {
6159 arg2 = (int)(SWIG_As_int(obj1));
6160 if (SWIG_arg_fail(2)) SWIG_fail;
6161 }
6162 }
6163 if (obj2) {
6164 {
6165 arg3 = (int)(SWIG_As_int(obj2));
6166 if (SWIG_arg_fail(3)) SWIG_fail;
6167 }
6168 }
6169 if (obj3) {
6170 {
6171 arg4 = (int)(SWIG_As_int(obj3));
6172 if (SWIG_arg_fail(4)) SWIG_fail;
6173 }
6174 }
6175 {
6176 if (!wxPyCheckForApp()) SWIG_fail;
6177 PyThreadState* __tstate = wxPyBeginAllowThreads();
6178 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6179
6180 wxPyEndAllowThreads(__tstate);
6181 if (PyErr_Occurred()) SWIG_fail;
6182 }
6183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxBitmap *arg1 = 0 ;
6193 wxRegion *result;
6194 PyObject * obj0 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "bmp", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6200 {
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 if (arg1 == NULL) {
6204 SWIG_null_ref("wxBitmap");
6205 }
6206 if (SWIG_arg_fail(1)) SWIG_fail;
6207 }
6208 {
6209 if (!wxPyCheckForApp()) SWIG_fail;
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6212
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj;
6225 wxBitmap *arg1 = 0 ;
6226 wxColour *arg2 = 0 ;
6227 int arg3 = (int) 0 ;
6228 wxRegion *result;
6229 wxColour temp2 ;
6230 PyObject * obj0 = 0 ;
6231 PyObject * obj1 = 0 ;
6232 PyObject * obj2 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6238 {
6239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6240 if (SWIG_arg_fail(1)) SWIG_fail;
6241 if (arg1 == NULL) {
6242 SWIG_null_ref("wxBitmap");
6243 }
6244 if (SWIG_arg_fail(1)) SWIG_fail;
6245 }
6246 {
6247 arg2 = &temp2;
6248 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6249 }
6250 if (obj2) {
6251 {
6252 arg3 = (int)(SWIG_As_int(obj2));
6253 if (SWIG_arg_fail(3)) SWIG_fail;
6254 }
6255 }
6256 {
6257 if (!wxPyCheckForApp()) SWIG_fail;
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6260
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 int arg1 ;
6274 wxPoint *arg2 = (wxPoint *) 0 ;
6275 int arg3 = (int) wxWINDING_RULE ;
6276 wxRegion *result;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char *kwnames[] = {
6280 (char *) "points",(char *) "fillStyle", NULL
6281 };
6282
6283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6284 {
6285 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6286 if (arg2 == NULL) SWIG_fail;
6287 }
6288 if (obj1) {
6289 {
6290 arg3 = (int)(SWIG_As_int(obj1));
6291 if (SWIG_arg_fail(3)) SWIG_fail;
6292 }
6293 }
6294 {
6295 if (!wxPyCheckForApp()) SWIG_fail;
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6303 {
6304 if (arg2) delete [] arg2;
6305 }
6306 return resultobj;
6307 fail:
6308 {
6309 if (arg2) delete [] arg2;
6310 }
6311 return NULL;
6312 }
6313
6314
6315 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6316 PyObject *resultobj;
6317 wxRegion *arg1 = (wxRegion *) 0 ;
6318 PyObject * obj0 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 {
6327 PyThreadState* __tstate = wxPyBeginAllowThreads();
6328 delete arg1;
6329
6330 wxPyEndAllowThreads(__tstate);
6331 if (PyErr_Occurred()) SWIG_fail;
6332 }
6333 Py_INCREF(Py_None); resultobj = Py_None;
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj;
6342 wxRegion *arg1 = (wxRegion *) 0 ;
6343 PyObject * obj0 = 0 ;
6344 char *kwnames[] = {
6345 (char *) "self", NULL
6346 };
6347
6348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6350 if (SWIG_arg_fail(1)) SWIG_fail;
6351 {
6352 PyThreadState* __tstate = wxPyBeginAllowThreads();
6353 (arg1)->Clear();
6354
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 Py_INCREF(Py_None); resultobj = Py_None;
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxRegion *arg1 = (wxRegion *) 0 ;
6368 int arg2 ;
6369 int arg3 ;
6370 bool result;
6371 PyObject * obj0 = 0 ;
6372 PyObject * obj1 = 0 ;
6373 PyObject * obj2 = 0 ;
6374 char *kwnames[] = {
6375 (char *) "self",(char *) "x",(char *) "y", NULL
6376 };
6377
6378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6380 if (SWIG_arg_fail(1)) SWIG_fail;
6381 {
6382 arg2 = (int)(SWIG_As_int(obj1));
6383 if (SWIG_arg_fail(2)) SWIG_fail;
6384 }
6385 {
6386 arg3 = (int)(SWIG_As_int(obj2));
6387 if (SWIG_arg_fail(3)) SWIG_fail;
6388 }
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (bool)(arg1)->Offset(arg2,arg3);
6392
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 {
6397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6398 }
6399 return resultobj;
6400 fail:
6401 return NULL;
6402 }
6403
6404
6405 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj;
6407 wxRegion *arg1 = (wxRegion *) 0 ;
6408 int arg2 ;
6409 int arg3 ;
6410 wxRegionContain result;
6411 PyObject * obj0 = 0 ;
6412 PyObject * obj1 = 0 ;
6413 PyObject * obj2 = 0 ;
6414 char *kwnames[] = {
6415 (char *) "self",(char *) "x",(char *) "y", NULL
6416 };
6417
6418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6420 if (SWIG_arg_fail(1)) SWIG_fail;
6421 {
6422 arg2 = (int)(SWIG_As_int(obj1));
6423 if (SWIG_arg_fail(2)) SWIG_fail;
6424 }
6425 {
6426 arg3 = (int)(SWIG_As_int(obj2));
6427 if (SWIG_arg_fail(3)) SWIG_fail;
6428 }
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = SWIG_From_int((result));
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj;
6445 wxRegion *arg1 = (wxRegion *) 0 ;
6446 wxPoint *arg2 = 0 ;
6447 wxRegionContain result;
6448 wxPoint temp2 ;
6449 PyObject * obj0 = 0 ;
6450 PyObject * obj1 = 0 ;
6451 char *kwnames[] = {
6452 (char *) "self",(char *) "pt", NULL
6453 };
6454
6455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6457 if (SWIG_arg_fail(1)) SWIG_fail;
6458 {
6459 arg2 = &temp2;
6460 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6461 }
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6465
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int((result));
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxRegion *arg1 = (wxRegion *) 0 ;
6479 wxRect *arg2 = 0 ;
6480 wxRegionContain result;
6481 wxRect temp2 ;
6482 PyObject * obj0 = 0 ;
6483 PyObject * obj1 = 0 ;
6484 char *kwnames[] = {
6485 (char *) "self",(char *) "rect", NULL
6486 };
6487
6488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6490 if (SWIG_arg_fail(1)) SWIG_fail;
6491 {
6492 arg2 = &temp2;
6493 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6494 }
6495 {
6496 PyThreadState* __tstate = wxPyBeginAllowThreads();
6497 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6498
6499 wxPyEndAllowThreads(__tstate);
6500 if (PyErr_Occurred()) SWIG_fail;
6501 }
6502 resultobj = SWIG_From_int((result));
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6510 PyObject *resultobj;
6511 wxRegion *arg1 = (wxRegion *) 0 ;
6512 int arg2 ;
6513 int arg3 ;
6514 int arg4 ;
6515 int arg5 ;
6516 wxRegionContain result;
6517 PyObject * obj0 = 0 ;
6518 PyObject * obj1 = 0 ;
6519 PyObject * obj2 = 0 ;
6520 PyObject * obj3 = 0 ;
6521 PyObject * obj4 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6528 if (SWIG_arg_fail(1)) SWIG_fail;
6529 {
6530 arg2 = (int)(SWIG_As_int(obj1));
6531 if (SWIG_arg_fail(2)) SWIG_fail;
6532 }
6533 {
6534 arg3 = (int)(SWIG_As_int(obj2));
6535 if (SWIG_arg_fail(3)) SWIG_fail;
6536 }
6537 {
6538 arg4 = (int)(SWIG_As_int(obj3));
6539 if (SWIG_arg_fail(4)) SWIG_fail;
6540 }
6541 {
6542 arg5 = (int)(SWIG_As_int(obj4));
6543 if (SWIG_arg_fail(5)) SWIG_fail;
6544 }
6545 {
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6548
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_From_int((result));
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj;
6561 wxRegion *arg1 = (wxRegion *) 0 ;
6562 wxRect result;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self", NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6570 if (SWIG_arg_fail(1)) SWIG_fail;
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (arg1)->GetBox();
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 {
6579 wxRect * resultptr;
6580 resultptr = new wxRect((wxRect &)(result));
6581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6582 }
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxRegion *arg1 = (wxRegion *) 0 ;
6592 int arg2 ;
6593 int arg3 ;
6594 int arg4 ;
6595 int arg5 ;
6596 bool result;
6597 PyObject * obj0 = 0 ;
6598 PyObject * obj1 = 0 ;
6599 PyObject * obj2 = 0 ;
6600 PyObject * obj3 = 0 ;
6601 PyObject * obj4 = 0 ;
6602 char *kwnames[] = {
6603 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6604 };
6605
6606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6608 if (SWIG_arg_fail(1)) SWIG_fail;
6609 {
6610 arg2 = (int)(SWIG_As_int(obj1));
6611 if (SWIG_arg_fail(2)) SWIG_fail;
6612 }
6613 {
6614 arg3 = (int)(SWIG_As_int(obj2));
6615 if (SWIG_arg_fail(3)) SWIG_fail;
6616 }
6617 {
6618 arg4 = (int)(SWIG_As_int(obj3));
6619 if (SWIG_arg_fail(4)) SWIG_fail;
6620 }
6621 {
6622 arg5 = (int)(SWIG_As_int(obj4));
6623 if (SWIG_arg_fail(5)) SWIG_fail;
6624 }
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6628
6629 wxPyEndAllowThreads(__tstate);
6630 if (PyErr_Occurred()) SWIG_fail;
6631 }
6632 {
6633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6634 }
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj;
6643 wxRegion *arg1 = (wxRegion *) 0 ;
6644 wxRect *arg2 = 0 ;
6645 bool result;
6646 wxRect temp2 ;
6647 PyObject * obj0 = 0 ;
6648 PyObject * obj1 = 0 ;
6649 char *kwnames[] = {
6650 (char *) "self",(char *) "rect", NULL
6651 };
6652
6653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6655 if (SWIG_arg_fail(1)) SWIG_fail;
6656 {
6657 arg2 = &temp2;
6658 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6659 }
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 {
6668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6669 }
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxRegion *arg1 = (wxRegion *) 0 ;
6679 wxRegion *arg2 = 0 ;
6680 bool result;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 char *kwnames[] = {
6684 (char *) "self",(char *) "region", NULL
6685 };
6686
6687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6689 if (SWIG_arg_fail(1)) SWIG_fail;
6690 {
6691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6692 if (SWIG_arg_fail(2)) SWIG_fail;
6693 if (arg2 == NULL) {
6694 SWIG_null_ref("wxRegion");
6695 }
6696 if (SWIG_arg_fail(2)) SWIG_fail;
6697 }
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6701
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 {
6706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6707 }
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj;
6716 wxRegion *arg1 = (wxRegion *) 0 ;
6717 bool result;
6718 PyObject * obj0 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (bool)(arg1)->IsEmpty();
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxRegion *arg1 = (wxRegion *) 0 ;
6745 int arg2 ;
6746 int arg3 ;
6747 int arg4 ;
6748 int arg5 ;
6749 bool result;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 PyObject * obj2 = 0 ;
6753 PyObject * obj3 = 0 ;
6754 PyObject * obj4 = 0 ;
6755 char *kwnames[] = {
6756 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6757 };
6758
6759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6761 if (SWIG_arg_fail(1)) SWIG_fail;
6762 {
6763 arg2 = (int)(SWIG_As_int(obj1));
6764 if (SWIG_arg_fail(2)) SWIG_fail;
6765 }
6766 {
6767 arg3 = (int)(SWIG_As_int(obj2));
6768 if (SWIG_arg_fail(3)) SWIG_fail;
6769 }
6770 {
6771 arg4 = (int)(SWIG_As_int(obj3));
6772 if (SWIG_arg_fail(4)) SWIG_fail;
6773 }
6774 {
6775 arg5 = (int)(SWIG_As_int(obj4));
6776 if (SWIG_arg_fail(5)) SWIG_fail;
6777 }
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6781
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 {
6786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6787 }
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj;
6796 wxRegion *arg1 = (wxRegion *) 0 ;
6797 wxRect *arg2 = 0 ;
6798 bool result;
6799 wxRect temp2 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char *kwnames[] = {
6803 (char *) "self",(char *) "rect", NULL
6804 };
6805
6806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6808 if (SWIG_arg_fail(1)) SWIG_fail;
6809 {
6810 arg2 = &temp2;
6811 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6812 }
6813 {
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6816
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 {
6821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6822 }
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6830 PyObject *resultobj;
6831 wxRegion *arg1 = (wxRegion *) 0 ;
6832 wxRegion *arg2 = 0 ;
6833 bool result;
6834 PyObject * obj0 = 0 ;
6835 PyObject * obj1 = 0 ;
6836 char *kwnames[] = {
6837 (char *) "self",(char *) "region", NULL
6838 };
6839
6840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6842 if (SWIG_arg_fail(1)) SWIG_fail;
6843 {
6844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6845 if (SWIG_arg_fail(2)) SWIG_fail;
6846 if (arg2 == NULL) {
6847 SWIG_null_ref("wxRegion");
6848 }
6849 if (SWIG_arg_fail(2)) SWIG_fail;
6850 }
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 {
6859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6868 PyObject *resultobj;
6869 wxRegion *arg1 = (wxRegion *) 0 ;
6870 int arg2 ;
6871 int arg3 ;
6872 int arg4 ;
6873 int arg5 ;
6874 bool result;
6875 PyObject * obj0 = 0 ;
6876 PyObject * obj1 = 0 ;
6877 PyObject * obj2 = 0 ;
6878 PyObject * obj3 = 0 ;
6879 PyObject * obj4 = 0 ;
6880 char *kwnames[] = {
6881 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6882 };
6883
6884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6886 if (SWIG_arg_fail(1)) SWIG_fail;
6887 {
6888 arg2 = (int)(SWIG_As_int(obj1));
6889 if (SWIG_arg_fail(2)) SWIG_fail;
6890 }
6891 {
6892 arg3 = (int)(SWIG_As_int(obj2));
6893 if (SWIG_arg_fail(3)) SWIG_fail;
6894 }
6895 {
6896 arg4 = (int)(SWIG_As_int(obj3));
6897 if (SWIG_arg_fail(4)) SWIG_fail;
6898 }
6899 {
6900 arg5 = (int)(SWIG_As_int(obj4));
6901 if (SWIG_arg_fail(5)) SWIG_fail;
6902 }
6903 {
6904 PyThreadState* __tstate = wxPyBeginAllowThreads();
6905 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 {
6911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6912 }
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj;
6921 wxRegion *arg1 = (wxRegion *) 0 ;
6922 wxRect *arg2 = 0 ;
6923 bool result;
6924 wxRect temp2 ;
6925 PyObject * obj0 = 0 ;
6926 PyObject * obj1 = 0 ;
6927 char *kwnames[] = {
6928 (char *) "self",(char *) "rect", NULL
6929 };
6930
6931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 {
6935 arg2 = &temp2;
6936 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6937 }
6938 {
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6941
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 {
6946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6947 }
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj;
6956 wxRegion *arg1 = (wxRegion *) 0 ;
6957 wxRegion *arg2 = 0 ;
6958 bool result;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self",(char *) "region", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6970 if (SWIG_arg_fail(2)) SWIG_fail;
6971 if (arg2 == NULL) {
6972 SWIG_null_ref("wxRegion");
6973 }
6974 if (SWIG_arg_fail(2)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 {
6984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6985 }
6986 return resultobj;
6987 fail:
6988 return NULL;
6989 }
6990
6991
6992 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6993 PyObject *resultobj;
6994 wxRegion *arg1 = (wxRegion *) 0 ;
6995 int arg2 ;
6996 int arg3 ;
6997 int arg4 ;
6998 int arg5 ;
6999 bool result;
7000 PyObject * obj0 = 0 ;
7001 PyObject * obj1 = 0 ;
7002 PyObject * obj2 = 0 ;
7003 PyObject * obj3 = 0 ;
7004 PyObject * obj4 = 0 ;
7005 char *kwnames[] = {
7006 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7007 };
7008
7009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7011 if (SWIG_arg_fail(1)) SWIG_fail;
7012 {
7013 arg2 = (int)(SWIG_As_int(obj1));
7014 if (SWIG_arg_fail(2)) SWIG_fail;
7015 }
7016 {
7017 arg3 = (int)(SWIG_As_int(obj2));
7018 if (SWIG_arg_fail(3)) SWIG_fail;
7019 }
7020 {
7021 arg4 = (int)(SWIG_As_int(obj3));
7022 if (SWIG_arg_fail(4)) SWIG_fail;
7023 }
7024 {
7025 arg5 = (int)(SWIG_As_int(obj4));
7026 if (SWIG_arg_fail(5)) SWIG_fail;
7027 }
7028 {
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7031
7032 wxPyEndAllowThreads(__tstate);
7033 if (PyErr_Occurred()) SWIG_fail;
7034 }
7035 {
7036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7037 }
7038 return resultobj;
7039 fail:
7040 return NULL;
7041 }
7042
7043
7044 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7045 PyObject *resultobj;
7046 wxRegion *arg1 = (wxRegion *) 0 ;
7047 wxRect *arg2 = 0 ;
7048 bool result;
7049 wxRect temp2 ;
7050 PyObject * obj0 = 0 ;
7051 PyObject * obj1 = 0 ;
7052 char *kwnames[] = {
7053 (char *) "self",(char *) "rect", NULL
7054 };
7055
7056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7058 if (SWIG_arg_fail(1)) SWIG_fail;
7059 {
7060 arg2 = &temp2;
7061 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7062 }
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7066
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 {
7071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7072 }
7073 return resultobj;
7074 fail:
7075 return NULL;
7076 }
7077
7078
7079 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7080 PyObject *resultobj;
7081 wxRegion *arg1 = (wxRegion *) 0 ;
7082 wxRegion *arg2 = 0 ;
7083 bool result;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 char *kwnames[] = {
7087 (char *) "self",(char *) "region", NULL
7088 };
7089
7090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7092 if (SWIG_arg_fail(1)) SWIG_fail;
7093 {
7094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7095 if (SWIG_arg_fail(2)) SWIG_fail;
7096 if (arg2 == NULL) {
7097 SWIG_null_ref("wxRegion");
7098 }
7099 if (SWIG_arg_fail(2)) SWIG_fail;
7100 }
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7104
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 {
7109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7110 }
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj;
7119 wxRegion *arg1 = (wxRegion *) 0 ;
7120 SwigValueWrapper<wxBitmap > result;
7121 PyObject * obj0 = 0 ;
7122 char *kwnames[] = {
7123 (char *) "self", NULL
7124 };
7125
7126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7128 if (SWIG_arg_fail(1)) SWIG_fail;
7129 {
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (arg1)->ConvertToBitmap();
7132
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 {
7137 wxBitmap * resultptr;
7138 resultptr = new wxBitmap((wxBitmap &)(result));
7139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7140 }
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj;
7149 wxRegion *arg1 = (wxRegion *) 0 ;
7150 wxBitmap *arg2 = 0 ;
7151 bool result;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char *kwnames[] = {
7155 (char *) "self",(char *) "bmp", NULL
7156 };
7157
7158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7160 if (SWIG_arg_fail(1)) SWIG_fail;
7161 {
7162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7163 if (SWIG_arg_fail(2)) SWIG_fail;
7164 if (arg2 == NULL) {
7165 SWIG_null_ref("wxBitmap");
7166 }
7167 if (SWIG_arg_fail(2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7172
7173 wxPyEndAllowThreads(__tstate);
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 {
7177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7178 }
7179 return resultobj;
7180 fail:
7181 return NULL;
7182 }
7183
7184
7185 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7186 PyObject *resultobj;
7187 wxRegion *arg1 = (wxRegion *) 0 ;
7188 wxBitmap *arg2 = 0 ;
7189 wxColour *arg3 = 0 ;
7190 int arg4 = (int) 0 ;
7191 bool result;
7192 wxColour temp3 ;
7193 PyObject * obj0 = 0 ;
7194 PyObject * obj1 = 0 ;
7195 PyObject * obj2 = 0 ;
7196 PyObject * obj3 = 0 ;
7197 char *kwnames[] = {
7198 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7199 };
7200
7201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7203 if (SWIG_arg_fail(1)) SWIG_fail;
7204 {
7205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(2)) SWIG_fail;
7207 if (arg2 == NULL) {
7208 SWIG_null_ref("wxBitmap");
7209 }
7210 if (SWIG_arg_fail(2)) SWIG_fail;
7211 }
7212 {
7213 arg3 = &temp3;
7214 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7215 }
7216 if (obj3) {
7217 {
7218 arg4 = (int)(SWIG_As_int(obj3));
7219 if (SWIG_arg_fail(4)) SWIG_fail;
7220 }
7221 }
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7225
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 {
7230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7231 }
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7239 PyObject *obj;
7240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7241 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7242 Py_INCREF(obj);
7243 return Py_BuildValue((char *)"");
7244 }
7245 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxRegion *arg1 = 0 ;
7248 wxRegionIterator *result;
7249 PyObject * obj0 = 0 ;
7250 char *kwnames[] = {
7251 (char *) "region", NULL
7252 };
7253
7254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7255 {
7256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7257 if (SWIG_arg_fail(1)) SWIG_fail;
7258 if (arg1 == NULL) {
7259 SWIG_null_ref("wxRegion");
7260 }
7261 if (SWIG_arg_fail(1)) SWIG_fail;
7262 }
7263 {
7264 if (!wxPyCheckForApp()) SWIG_fail;
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7267
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj;
7280 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7281 PyObject * obj0 = 0 ;
7282 char *kwnames[] = {
7283 (char *) "self", NULL
7284 };
7285
7286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7288 if (SWIG_arg_fail(1)) SWIG_fail;
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 delete arg1;
7292
7293 wxPyEndAllowThreads(__tstate);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 Py_INCREF(Py_None); resultobj = Py_None;
7297 return resultobj;
7298 fail:
7299 return NULL;
7300 }
7301
7302
7303 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7304 PyObject *resultobj;
7305 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7306 int result;
7307 PyObject * obj0 = 0 ;
7308 char *kwnames[] = {
7309 (char *) "self", NULL
7310 };
7311
7312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7314 if (SWIG_arg_fail(1)) SWIG_fail;
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 result = (int)(arg1)->GetX();
7318
7319 wxPyEndAllowThreads(__tstate);
7320 if (PyErr_Occurred()) SWIG_fail;
7321 }
7322 {
7323 resultobj = SWIG_From_int((int)(result));
7324 }
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj;
7333 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7334 int result;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 result = (int)(arg1)->GetY();
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 {
7351 resultobj = SWIG_From_int((int)(result));
7352 }
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7362 int result;
7363 PyObject * obj0 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 {
7372 PyThreadState* __tstate = wxPyBeginAllowThreads();
7373 result = (int)(arg1)->GetW();
7374
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = SWIG_From_int((int)(result));
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7390 int result;
7391 PyObject * obj0 = 0 ;
7392 char *kwnames[] = {
7393 (char *) "self", NULL
7394 };
7395
7396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(1)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 result = (int)(arg1)->GetWidth();
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = SWIG_From_int((int)(result));
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj;
7417 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7418 int result;
7419 PyObject * obj0 = 0 ;
7420 char *kwnames[] = {
7421 (char *) "self", NULL
7422 };
7423
7424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7426 if (SWIG_arg_fail(1)) SWIG_fail;
7427 {
7428 PyThreadState* __tstate = wxPyBeginAllowThreads();
7429 result = (int)(arg1)->GetH();
7430
7431 wxPyEndAllowThreads(__tstate);
7432 if (PyErr_Occurred()) SWIG_fail;
7433 }
7434 {
7435 resultobj = SWIG_From_int((int)(result));
7436 }
7437 return resultobj;
7438 fail:
7439 return NULL;
7440 }
7441
7442
7443 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7444 PyObject *resultobj;
7445 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7446 int result;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 result = (int)(arg1)->GetHeight();
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 {
7463 resultobj = SWIG_From_int((int)(result));
7464 }
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7474 wxRect result;
7475 PyObject * obj0 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7482 if (SWIG_arg_fail(1)) SWIG_fail;
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (arg1)->GetRect();
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 {
7491 wxRect * resultptr;
7492 resultptr = new wxRect((wxRect &)(result));
7493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7494 }
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj;
7503 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7504 bool result;
7505 PyObject * obj0 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (bool)(arg1)->HaveRects();
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 {
7521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7522 }
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj;
7531 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7532 PyObject * obj0 = 0 ;
7533 char *kwnames[] = {
7534 (char *) "self", NULL
7535 };
7536
7537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7539 if (SWIG_arg_fail(1)) SWIG_fail;
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 (arg1)->Reset();
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 Py_INCREF(Py_None); resultobj = Py_None;
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj;
7556 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7557 PyObject * obj0 = 0 ;
7558 char *kwnames[] = {
7559 (char *) "self", NULL
7560 };
7561
7562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(1)) SWIG_fail;
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 wxRegionIterator_Next(arg1);
7568
7569 wxPyEndAllowThreads(__tstate);
7570 if (PyErr_Occurred()) SWIG_fail;
7571 }
7572 Py_INCREF(Py_None); resultobj = Py_None;
7573 return resultobj;
7574 fail:
7575 return NULL;
7576 }
7577
7578
7579 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7580 PyObject *resultobj;
7581 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7582 bool result;
7583 PyObject * obj0 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)wxRegionIterator___nonzero__(arg1);
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7608 PyObject *obj;
7609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7610 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7611 Py_INCREF(obj);
7612 return Py_BuildValue((char *)"");
7613 }
7614 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7615 PyObject *resultobj;
7616 wxNativeFontInfo *result;
7617 char *kwnames[] = {
7618 NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7625
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj;
7638 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7639 PyObject * obj0 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 delete arg1;
7650
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 Py_INCREF(Py_None); resultobj = Py_None;
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj;
7663 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7664 PyObject * obj0 = 0 ;
7665 char *kwnames[] = {
7666 (char *) "self", NULL
7667 };
7668
7669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7671 if (SWIG_arg_fail(1)) SWIG_fail;
7672 {
7673 PyThreadState* __tstate = wxPyBeginAllowThreads();
7674 (arg1)->Init();
7675
7676 wxPyEndAllowThreads(__tstate);
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 Py_INCREF(Py_None); resultobj = Py_None;
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj;
7688 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7689 wxFont *arg2 = 0 ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char *kwnames[] = {
7693 (char *) "self",(char *) "font", NULL
7694 };
7695
7696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7698 if (SWIG_arg_fail(1)) SWIG_fail;
7699 {
7700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7701 if (SWIG_arg_fail(2)) SWIG_fail;
7702 if (arg2 == NULL) {
7703 SWIG_null_ref("wxFont");
7704 }
7705 if (SWIG_arg_fail(2)) SWIG_fail;
7706 }
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 (arg1)->InitFromFont((wxFont const &)*arg2);
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 Py_INCREF(Py_None); resultobj = Py_None;
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj;
7723 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7724 int result;
7725 PyObject * obj0 = 0 ;
7726 char *kwnames[] = {
7727 (char *) "self", NULL
7728 };
7729
7730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7732 if (SWIG_arg_fail(1)) SWIG_fail;
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7736
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 {
7741 resultobj = SWIG_From_int((int)(result));
7742 }
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj;
7751 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7752 wxFontStyle result;
7753 PyObject * obj0 = 0 ;
7754 char *kwnames[] = {
7755 (char *) "self", NULL
7756 };
7757
7758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7760 if (SWIG_arg_fail(1)) SWIG_fail;
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 resultobj = SWIG_From_int((result));
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj;
7777 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7778 wxFontWeight result;
7779 PyObject * obj0 = 0 ;
7780 char *kwnames[] = {
7781 (char *) "self", NULL
7782 };
7783
7784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7786 if (SWIG_arg_fail(1)) SWIG_fail;
7787 {
7788 PyThreadState* __tstate = wxPyBeginAllowThreads();
7789 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7790
7791 wxPyEndAllowThreads(__tstate);
7792 if (PyErr_Occurred()) SWIG_fail;
7793 }
7794 resultobj = SWIG_From_int((result));
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj;
7803 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7804 bool result;
7805 PyObject * obj0 = 0 ;
7806 char *kwnames[] = {
7807 (char *) "self", NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7812 if (SWIG_arg_fail(1)) SWIG_fail;
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 {
7821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7822 }
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7830 PyObject *resultobj;
7831 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7832 wxString result;
7833 PyObject * obj0 = 0 ;
7834 char *kwnames[] = {
7835 (char *) "self", NULL
7836 };
7837
7838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7840 if (SWIG_arg_fail(1)) SWIG_fail;
7841 {
7842 PyThreadState* __tstate = wxPyBeginAllowThreads();
7843 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7844
7845 wxPyEndAllowThreads(__tstate);
7846 if (PyErr_Occurred()) SWIG_fail;
7847 }
7848 {
7849 #if wxUSE_UNICODE
7850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7851 #else
7852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7853 #endif
7854 }
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj;
7863 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7864 wxFontFamily result;
7865 PyObject * obj0 = 0 ;
7866 char *kwnames[] = {
7867 (char *) "self", NULL
7868 };
7869
7870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7872 if (SWIG_arg_fail(1)) SWIG_fail;
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7876
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_From_int((result));
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj;
7889 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7890 wxFontEncoding result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 resultobj = SWIG_From_int((result));
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj;
7915 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7916 int arg2 ;
7917 PyObject * obj0 = 0 ;
7918 PyObject * obj1 = 0 ;
7919 char *kwnames[] = {
7920 (char *) "self",(char *) "pointsize", NULL
7921 };
7922
7923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7925 if (SWIG_arg_fail(1)) SWIG_fail;
7926 {
7927 arg2 = (int)(SWIG_As_int(obj1));
7928 if (SWIG_arg_fail(2)) SWIG_fail;
7929 }
7930 {
7931 PyThreadState* __tstate = wxPyBeginAllowThreads();
7932 (arg1)->SetPointSize(arg2);
7933
7934 wxPyEndAllowThreads(__tstate);
7935 if (PyErr_Occurred()) SWIG_fail;
7936 }
7937 Py_INCREF(Py_None); resultobj = Py_None;
7938 return resultobj;
7939 fail:
7940 return NULL;
7941 }
7942
7943
7944 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7945 PyObject *resultobj;
7946 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7947 wxFontStyle arg2 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char *kwnames[] = {
7951 (char *) "self",(char *) "style", NULL
7952 };
7953
7954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7956 if (SWIG_arg_fail(1)) SWIG_fail;
7957 {
7958 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7959 if (SWIG_arg_fail(2)) SWIG_fail;
7960 }
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 (arg1)->SetStyle((wxFontStyle )arg2);
7964
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 Py_INCREF(Py_None); resultobj = Py_None;
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj;
7977 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7978 wxFontWeight arg2 ;
7979 PyObject * obj0 = 0 ;
7980 PyObject * obj1 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "self",(char *) "weight", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7987 if (SWIG_arg_fail(1)) SWIG_fail;
7988 {
7989 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7990 if (SWIG_arg_fail(2)) SWIG_fail;
7991 }
7992 {
7993 PyThreadState* __tstate = wxPyBeginAllowThreads();
7994 (arg1)->SetWeight((wxFontWeight )arg2);
7995
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 Py_INCREF(Py_None); resultobj = Py_None;
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8007 PyObject *resultobj;
8008 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8009 bool arg2 ;
8010 PyObject * obj0 = 0 ;
8011 PyObject * obj1 = 0 ;
8012 char *kwnames[] = {
8013 (char *) "self",(char *) "underlined", NULL
8014 };
8015
8016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8018 if (SWIG_arg_fail(1)) SWIG_fail;
8019 {
8020 arg2 = (bool)(SWIG_As_bool(obj1));
8021 if (SWIG_arg_fail(2)) SWIG_fail;
8022 }
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 (arg1)->SetUnderlined(arg2);
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 Py_INCREF(Py_None); resultobj = Py_None;
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj;
8039 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8040 wxString arg2 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 char *kwnames[] = {
8044 (char *) "self",(char *) "facename", NULL
8045 };
8046
8047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8049 if (SWIG_arg_fail(1)) SWIG_fail;
8050 {
8051 wxString* sptr = wxString_in_helper(obj1);
8052 if (sptr == NULL) SWIG_fail;
8053 arg2 = *sptr;
8054 delete sptr;
8055 }
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 (arg1)->SetFaceName(arg2);
8059
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 Py_INCREF(Py_None); resultobj = Py_None;
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj;
8072 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8073 wxFontFamily arg2 ;
8074 PyObject * obj0 = 0 ;
8075 PyObject * obj1 = 0 ;
8076 char *kwnames[] = {
8077 (char *) "self",(char *) "family", NULL
8078 };
8079
8080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8082 if (SWIG_arg_fail(1)) SWIG_fail;
8083 {
8084 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8085 if (SWIG_arg_fail(2)) SWIG_fail;
8086 }
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 (arg1)->SetFamily((wxFontFamily )arg2);
8090
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 Py_INCREF(Py_None); resultobj = Py_None;
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj;
8103 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8104 wxFontEncoding arg2 ;
8105 PyObject * obj0 = 0 ;
8106 PyObject * obj1 = 0 ;
8107 char *kwnames[] = {
8108 (char *) "self",(char *) "encoding", NULL
8109 };
8110
8111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8113 if (SWIG_arg_fail(1)) SWIG_fail;
8114 {
8115 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8116 if (SWIG_arg_fail(2)) SWIG_fail;
8117 }
8118 {
8119 PyThreadState* __tstate = wxPyBeginAllowThreads();
8120 (arg1)->SetEncoding((wxFontEncoding )arg2);
8121
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 Py_INCREF(Py_None); resultobj = Py_None;
8126 return resultobj;
8127 fail:
8128 return NULL;
8129 }
8130
8131
8132 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8133 PyObject *resultobj;
8134 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8135 wxString *arg2 = 0 ;
8136 bool result;
8137 bool temp2 = false ;
8138 PyObject * obj0 = 0 ;
8139 PyObject * obj1 = 0 ;
8140 char *kwnames[] = {
8141 (char *) "self",(char *) "s", NULL
8142 };
8143
8144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8146 if (SWIG_arg_fail(1)) SWIG_fail;
8147 {
8148 arg2 = wxString_in_helper(obj1);
8149 if (arg2 == NULL) SWIG_fail;
8150 temp2 = true;
8151 }
8152 {
8153 PyThreadState* __tstate = wxPyBeginAllowThreads();
8154 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8155
8156 wxPyEndAllowThreads(__tstate);
8157 if (PyErr_Occurred()) SWIG_fail;
8158 }
8159 {
8160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8161 }
8162 {
8163 if (temp2)
8164 delete arg2;
8165 }
8166 return resultobj;
8167 fail:
8168 {
8169 if (temp2)
8170 delete arg2;
8171 }
8172 return NULL;
8173 }
8174
8175
8176 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8177 PyObject *resultobj;
8178 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8179 wxString result;
8180 PyObject * obj0 = 0 ;
8181 char *kwnames[] = {
8182 (char *) "self", NULL
8183 };
8184
8185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8187 if (SWIG_arg_fail(1)) SWIG_fail;
8188 {
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 result = ((wxNativeFontInfo const *)arg1)->ToString();
8191
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 {
8196 #if wxUSE_UNICODE
8197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8198 #else
8199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8200 #endif
8201 }
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8211 wxString result;
8212 PyObject * obj0 = 0 ;
8213 char *kwnames[] = {
8214 (char *) "self", NULL
8215 };
8216
8217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8219 if (SWIG_arg_fail(1)) SWIG_fail;
8220 {
8221 PyThreadState* __tstate = wxPyBeginAllowThreads();
8222 result = wxNativeFontInfo___str__(arg1);
8223
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 {
8228 #if wxUSE_UNICODE
8229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8230 #else
8231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8232 #endif
8233 }
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8241 PyObject *resultobj;
8242 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8243 wxString *arg2 = 0 ;
8244 bool result;
8245 bool temp2 = false ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char *kwnames[] = {
8249 (char *) "self",(char *) "s", NULL
8250 };
8251
8252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8254 if (SWIG_arg_fail(1)) SWIG_fail;
8255 {
8256 arg2 = wxString_in_helper(obj1);
8257 if (arg2 == NULL) SWIG_fail;
8258 temp2 = true;
8259 }
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8263
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 {
8268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8269 }
8270 {
8271 if (temp2)
8272 delete arg2;
8273 }
8274 return resultobj;
8275 fail:
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return NULL;
8281 }
8282
8283
8284 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8285 PyObject *resultobj;
8286 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8287 wxString result;
8288 PyObject * obj0 = 0 ;
8289 char *kwnames[] = {
8290 (char *) "self", NULL
8291 };
8292
8293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8295 if (SWIG_arg_fail(1)) SWIG_fail;
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8299
8300 wxPyEndAllowThreads(__tstate);
8301 if (PyErr_Occurred()) SWIG_fail;
8302 }
8303 {
8304 #if wxUSE_UNICODE
8305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8306 #else
8307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8308 #endif
8309 }
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8317 PyObject *obj;
8318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8319 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8320 Py_INCREF(obj);
8321 return Py_BuildValue((char *)"");
8322 }
8323 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8326 wxString *arg2 = (wxString *) 0 ;
8327 bool temp2 = false ;
8328 PyObject * obj0 = 0 ;
8329 PyObject * obj1 = 0 ;
8330 char *kwnames[] = {
8331 (char *) "self",(char *) "facename", NULL
8332 };
8333
8334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8336 if (SWIG_arg_fail(1)) SWIG_fail;
8337 {
8338 arg2 = wxString_in_helper(obj1);
8339 if (arg2 == NULL) SWIG_fail;
8340 temp2 = true;
8341 }
8342 if (arg1) (arg1)->facename = *arg2;
8343
8344 Py_INCREF(Py_None); resultobj = Py_None;
8345 {
8346 if (temp2)
8347 delete arg2;
8348 }
8349 return resultobj;
8350 fail:
8351 {
8352 if (temp2)
8353 delete arg2;
8354 }
8355 return NULL;
8356 }
8357
8358
8359 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj;
8361 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8362 wxString *result;
8363 PyObject * obj0 = 0 ;
8364 char *kwnames[] = {
8365 (char *) "self", NULL
8366 };
8367
8368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8370 if (SWIG_arg_fail(1)) SWIG_fail;
8371 result = (wxString *)& ((arg1)->facename);
8372
8373 {
8374 #if wxUSE_UNICODE
8375 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8376 #else
8377 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8378 #endif
8379 }
8380 return resultobj;
8381 fail:
8382 return NULL;
8383 }
8384
8385
8386 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8387 PyObject *resultobj;
8388 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8389 wxFontEncoding arg2 ;
8390 PyObject * obj0 = 0 ;
8391 PyObject * obj1 = 0 ;
8392 char *kwnames[] = {
8393 (char *) "self",(char *) "encoding", NULL
8394 };
8395
8396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8398 if (SWIG_arg_fail(1)) SWIG_fail;
8399 {
8400 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8401 if (SWIG_arg_fail(2)) SWIG_fail;
8402 }
8403 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8404
8405 Py_INCREF(Py_None); resultobj = Py_None;
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj;
8414 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8415 wxFontEncoding result;
8416 PyObject * obj0 = 0 ;
8417 char *kwnames[] = {
8418 (char *) "self", NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(1)) SWIG_fail;
8424 result = (wxFontEncoding) ((arg1)->encoding);
8425
8426 resultobj = SWIG_From_int((result));
8427 return resultobj;
8428 fail:
8429 return NULL;
8430 }
8431
8432
8433 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8434 PyObject *resultobj;
8435 wxNativeEncodingInfo *result;
8436 char *kwnames[] = {
8437 NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8444
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8456 PyObject *resultobj;
8457 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8458 PyObject * obj0 = 0 ;
8459 char *kwnames[] = {
8460 (char *) "self", NULL
8461 };
8462
8463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8465 if (SWIG_arg_fail(1)) SWIG_fail;
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 delete arg1;
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 Py_INCREF(Py_None); resultobj = Py_None;
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8481 PyObject *resultobj;
8482 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8483 wxString *arg2 = 0 ;
8484 bool result;
8485 bool temp2 = false ;
8486 PyObject * obj0 = 0 ;
8487 PyObject * obj1 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "self",(char *) "s", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 {
8496 arg2 = wxString_in_helper(obj1);
8497 if (arg2 == NULL) SWIG_fail;
8498 temp2 = true;
8499 }
8500 {
8501 PyThreadState* __tstate = wxPyBeginAllowThreads();
8502 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8503
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 {
8508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8509 }
8510 {
8511 if (temp2)
8512 delete arg2;
8513 }
8514 return resultobj;
8515 fail:
8516 {
8517 if (temp2)
8518 delete arg2;
8519 }
8520 return NULL;
8521 }
8522
8523
8524 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8525 PyObject *resultobj;
8526 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8527 wxString result;
8528 PyObject * obj0 = 0 ;
8529 char *kwnames[] = {
8530 (char *) "self", NULL
8531 };
8532
8533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8535 if (SWIG_arg_fail(1)) SWIG_fail;
8536 {
8537 PyThreadState* __tstate = wxPyBeginAllowThreads();
8538 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8539
8540 wxPyEndAllowThreads(__tstate);
8541 if (PyErr_Occurred()) SWIG_fail;
8542 }
8543 {
8544 #if wxUSE_UNICODE
8545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8546 #else
8547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8548 #endif
8549 }
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8557 PyObject *obj;
8558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8559 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8560 Py_INCREF(obj);
8561 return Py_BuildValue((char *)"");
8562 }
8563 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj;
8565 wxFontEncoding arg1 ;
8566 wxNativeEncodingInfo *result;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "encoding", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8573 {
8574 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8575 if (SWIG_arg_fail(1)) SWIG_fail;
8576 }
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8580
8581 wxPyEndAllowThreads(__tstate);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj;
8593 wxNativeEncodingInfo *arg1 = 0 ;
8594 bool result;
8595 PyObject * obj0 = 0 ;
8596 char *kwnames[] = {
8597 (char *) "info", NULL
8598 };
8599
8600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8601 {
8602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8603 if (SWIG_arg_fail(1)) SWIG_fail;
8604 if (arg1 == NULL) {
8605 SWIG_null_ref("wxNativeEncodingInfo");
8606 }
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 }
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8612
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 {
8617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8618 }
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxFontMapper *result;
8628 char *kwnames[] = {
8629 NULL
8630 };
8631
8632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8633 {
8634 PyThreadState* __tstate = wxPyBeginAllowThreads();
8635 result = (wxFontMapper *)new wxFontMapper();
8636
8637 wxPyEndAllowThreads(__tstate);
8638 if (PyErr_Occurred()) SWIG_fail;
8639 }
8640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj;
8649 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8650 PyObject * obj0 = 0 ;
8651 char *kwnames[] = {
8652 (char *) "self", NULL
8653 };
8654
8655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8657 if (SWIG_arg_fail(1)) SWIG_fail;
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 delete arg1;
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 Py_INCREF(Py_None); resultobj = Py_None;
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj;
8674 wxFontMapper *result;
8675 char *kwnames[] = {
8676 NULL
8677 };
8678
8679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8680 {
8681 PyThreadState* __tstate = wxPyBeginAllowThreads();
8682 result = (wxFontMapper *)wxFontMapper::Get();
8683
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj;
8696 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8697 wxFontMapper *result;
8698 PyObject * obj0 = 0 ;
8699 char *kwnames[] = {
8700 (char *) "mapper", NULL
8701 };
8702
8703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8705 if (SWIG_arg_fail(1)) SWIG_fail;
8706 {
8707 PyThreadState* __tstate = wxPyBeginAllowThreads();
8708 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8709
8710 wxPyEndAllowThreads(__tstate);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj;
8722 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8723 wxString *arg2 = 0 ;
8724 bool arg3 = (bool) true ;
8725 wxFontEncoding result;
8726 bool temp2 = false ;
8727 PyObject * obj0 = 0 ;
8728 PyObject * obj1 = 0 ;
8729 PyObject * obj2 = 0 ;
8730 char *kwnames[] = {
8731 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8732 };
8733
8734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8736 if (SWIG_arg_fail(1)) SWIG_fail;
8737 {
8738 arg2 = wxString_in_helper(obj1);
8739 if (arg2 == NULL) SWIG_fail;
8740 temp2 = true;
8741 }
8742 if (obj2) {
8743 {
8744 arg3 = (bool)(SWIG_As_bool(obj2));
8745 if (SWIG_arg_fail(3)) SWIG_fail;
8746 }
8747 }
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8751
8752 wxPyEndAllowThreads(__tstate);
8753 if (PyErr_Occurred()) SWIG_fail;
8754 }
8755 resultobj = SWIG_From_int((result));
8756 {
8757 if (temp2)
8758 delete arg2;
8759 }
8760 return resultobj;
8761 fail:
8762 {
8763 if (temp2)
8764 delete arg2;
8765 }
8766 return NULL;
8767 }
8768
8769
8770 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj;
8772 size_t result;
8773 char *kwnames[] = {
8774 NULL
8775 };
8776
8777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8778 {
8779 PyThreadState* __tstate = wxPyBeginAllowThreads();
8780 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8781
8782 wxPyEndAllowThreads(__tstate);
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 {
8786 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8787 }
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj;
8796 size_t arg1 ;
8797 wxFontEncoding result;
8798 PyObject * obj0 = 0 ;
8799 char *kwnames[] = {
8800 (char *) "n", NULL
8801 };
8802
8803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8804 {
8805 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8806 if (SWIG_arg_fail(1)) SWIG_fail;
8807 }
8808 {
8809 PyThreadState* __tstate = wxPyBeginAllowThreads();
8810 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8811
8812 wxPyEndAllowThreads(__tstate);
8813 if (PyErr_Occurred()) SWIG_fail;
8814 }
8815 resultobj = SWIG_From_int((result));
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8823 PyObject *resultobj;
8824 wxFontEncoding arg1 ;
8825 wxString result;
8826 PyObject * obj0 = 0 ;
8827 char *kwnames[] = {
8828 (char *) "encoding", NULL
8829 };
8830
8831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8832 {
8833 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8834 if (SWIG_arg_fail(1)) SWIG_fail;
8835 }
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8839
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 {
8844 #if wxUSE_UNICODE
8845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8846 #else
8847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8848 #endif
8849 }
8850 return resultobj;
8851 fail:
8852 return NULL;
8853 }
8854
8855
8856 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8857 PyObject *resultobj;
8858 wxFontEncoding arg1 ;
8859 wxString result;
8860 PyObject * obj0 = 0 ;
8861 char *kwnames[] = {
8862 (char *) "encoding", NULL
8863 };
8864
8865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8866 {
8867 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8868 if (SWIG_arg_fail(1)) SWIG_fail;
8869 }
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8873
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 {
8878 #if wxUSE_UNICODE
8879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8880 #else
8881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8882 #endif
8883 }
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj;
8892 wxString *arg1 = 0 ;
8893 wxFontEncoding result;
8894 bool temp1 = false ;
8895 PyObject * obj0 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "name", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8901 {
8902 arg1 = wxString_in_helper(obj0);
8903 if (arg1 == NULL) SWIG_fail;
8904 temp1 = true;
8905 }
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8909
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_From_int((result));
8914 {
8915 if (temp1)
8916 delete arg1;
8917 }
8918 return resultobj;
8919 fail:
8920 {
8921 if (temp1)
8922 delete arg1;
8923 }
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8931 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8932 PyObject * obj0 = 0 ;
8933 PyObject * obj1 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "config", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8940 if (SWIG_arg_fail(1)) SWIG_fail;
8941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8942 if (SWIG_arg_fail(2)) SWIG_fail;
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->SetConfig(arg2);
8946
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 Py_INCREF(Py_None); resultobj = Py_None;
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj;
8959 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8960 wxString *arg2 = 0 ;
8961 bool temp2 = false ;
8962 PyObject * obj0 = 0 ;
8963 PyObject * obj1 = 0 ;
8964 char *kwnames[] = {
8965 (char *) "self",(char *) "prefix", NULL
8966 };
8967
8968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8970 if (SWIG_arg_fail(1)) SWIG_fail;
8971 {
8972 arg2 = wxString_in_helper(obj1);
8973 if (arg2 == NULL) SWIG_fail;
8974 temp2 = true;
8975 }
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 (arg1)->SetConfigPath((wxString const &)*arg2);
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 Py_INCREF(Py_None); resultobj = Py_None;
8984 {
8985 if (temp2)
8986 delete arg2;
8987 }
8988 return resultobj;
8989 fail:
8990 {
8991 if (temp2)
8992 delete arg2;
8993 }
8994 return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj;
9000 wxString result;
9001 char *kwnames[] = {
9002 NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 result = wxFontMapper::GetDefaultConfigPath();
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 {
9014 #if wxUSE_UNICODE
9015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9016 #else
9017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9018 #endif
9019 }
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj;
9028 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9029 wxFontEncoding arg2 ;
9030 wxString const &arg3_defvalue = wxPyEmptyString ;
9031 wxString *arg3 = (wxString *) &arg3_defvalue ;
9032 bool arg4 = (bool) true ;
9033 PyObject *result;
9034 bool temp3 = false ;
9035 PyObject * obj0 = 0 ;
9036 PyObject * obj1 = 0 ;
9037 PyObject * obj2 = 0 ;
9038 PyObject * obj3 = 0 ;
9039 char *kwnames[] = {
9040 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9041 };
9042
9043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9045 if (SWIG_arg_fail(1)) SWIG_fail;
9046 {
9047 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9048 if (SWIG_arg_fail(2)) SWIG_fail;
9049 }
9050 if (obj2) {
9051 {
9052 arg3 = wxString_in_helper(obj2);
9053 if (arg3 == NULL) SWIG_fail;
9054 temp3 = true;
9055 }
9056 }
9057 if (obj3) {
9058 {
9059 arg4 = (bool)(SWIG_As_bool(obj3));
9060 if (SWIG_arg_fail(4)) SWIG_fail;
9061 }
9062 }
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 resultobj = result;
9071 {
9072 if (temp3)
9073 delete arg3;
9074 }
9075 return resultobj;
9076 fail:
9077 {
9078 if (temp3)
9079 delete arg3;
9080 }
9081 return NULL;
9082 }
9083
9084
9085 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj;
9087 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9088 wxFontEncoding arg2 ;
9089 wxString const &arg3_defvalue = wxPyEmptyString ;
9090 wxString *arg3 = (wxString *) &arg3_defvalue ;
9091 bool result;
9092 bool temp3 = false ;
9093 PyObject * obj0 = 0 ;
9094 PyObject * obj1 = 0 ;
9095 PyObject * obj2 = 0 ;
9096 char *kwnames[] = {
9097 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9098 };
9099
9100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9102 if (SWIG_arg_fail(1)) SWIG_fail;
9103 {
9104 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9105 if (SWIG_arg_fail(2)) SWIG_fail;
9106 }
9107 if (obj2) {
9108 {
9109 arg3 = wxString_in_helper(obj2);
9110 if (arg3 == NULL) SWIG_fail;
9111 temp3 = true;
9112 }
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9117
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 {
9122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9123 }
9124 {
9125 if (temp3)
9126 delete arg3;
9127 }
9128 return resultobj;
9129 fail:
9130 {
9131 if (temp3)
9132 delete arg3;
9133 }
9134 return NULL;
9135 }
9136
9137
9138 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9139 PyObject *resultobj;
9140 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9141 wxWindow *arg2 = (wxWindow *) 0 ;
9142 PyObject * obj0 = 0 ;
9143 PyObject * obj1 = 0 ;
9144 char *kwnames[] = {
9145 (char *) "self",(char *) "parent", NULL
9146 };
9147
9148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9150 if (SWIG_arg_fail(1)) SWIG_fail;
9151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9152 if (SWIG_arg_fail(2)) SWIG_fail;
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 (arg1)->SetDialogParent(arg2);
9156
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 Py_INCREF(Py_None); resultobj = Py_None;
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj;
9169 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9170 wxString *arg2 = 0 ;
9171 bool temp2 = false ;
9172 PyObject * obj0 = 0 ;
9173 PyObject * obj1 = 0 ;
9174 char *kwnames[] = {
9175 (char *) "self",(char *) "title", NULL
9176 };
9177
9178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9180 if (SWIG_arg_fail(1)) SWIG_fail;
9181 {
9182 arg2 = wxString_in_helper(obj1);
9183 if (arg2 == NULL) SWIG_fail;
9184 temp2 = true;
9185 }
9186 {
9187 PyThreadState* __tstate = wxPyBeginAllowThreads();
9188 (arg1)->SetDialogTitle((wxString const &)*arg2);
9189
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 Py_INCREF(Py_None); resultobj = Py_None;
9194 {
9195 if (temp2)
9196 delete arg2;
9197 }
9198 return resultobj;
9199 fail:
9200 {
9201 if (temp2)
9202 delete arg2;
9203 }
9204 return NULL;
9205 }
9206
9207
9208 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9209 PyObject *obj;
9210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9211 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9212 Py_INCREF(obj);
9213 return Py_BuildValue((char *)"");
9214 }
9215 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj;
9217 int arg1 ;
9218 int arg2 ;
9219 int arg3 ;
9220 int arg4 ;
9221 bool arg5 = (bool) false ;
9222 wxString const &arg6_defvalue = wxPyEmptyString ;
9223 wxString *arg6 = (wxString *) &arg6_defvalue ;
9224 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9225 wxFont *result;
9226 bool temp6 = false ;
9227 PyObject * obj0 = 0 ;
9228 PyObject * obj1 = 0 ;
9229 PyObject * obj2 = 0 ;
9230 PyObject * obj3 = 0 ;
9231 PyObject * obj4 = 0 ;
9232 PyObject * obj5 = 0 ;
9233 PyObject * obj6 = 0 ;
9234 char *kwnames[] = {
9235 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9236 };
9237
9238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9239 {
9240 arg1 = (int)(SWIG_As_int(obj0));
9241 if (SWIG_arg_fail(1)) SWIG_fail;
9242 }
9243 {
9244 arg2 = (int)(SWIG_As_int(obj1));
9245 if (SWIG_arg_fail(2)) SWIG_fail;
9246 }
9247 {
9248 arg3 = (int)(SWIG_As_int(obj2));
9249 if (SWIG_arg_fail(3)) SWIG_fail;
9250 }
9251 {
9252 arg4 = (int)(SWIG_As_int(obj3));
9253 if (SWIG_arg_fail(4)) SWIG_fail;
9254 }
9255 if (obj4) {
9256 {
9257 arg5 = (bool)(SWIG_As_bool(obj4));
9258 if (SWIG_arg_fail(5)) SWIG_fail;
9259 }
9260 }
9261 if (obj5) {
9262 {
9263 arg6 = wxString_in_helper(obj5);
9264 if (arg6 == NULL) SWIG_fail;
9265 temp6 = true;
9266 }
9267 }
9268 if (obj6) {
9269 {
9270 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9271 if (SWIG_arg_fail(7)) SWIG_fail;
9272 }
9273 }
9274 {
9275 if (!wxPyCheckForApp()) SWIG_fail;
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9283 {
9284 if (temp6)
9285 delete arg6;
9286 }
9287 return resultobj;
9288 fail:
9289 {
9290 if (temp6)
9291 delete arg6;
9292 }
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxFont *arg1 = (wxFont *) 0 ;
9300 PyObject * obj0 = 0 ;
9301 char *kwnames[] = {
9302 (char *) "self", NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9307 if (SWIG_arg_fail(1)) SWIG_fail;
9308 {
9309 PyThreadState* __tstate = wxPyBeginAllowThreads();
9310 delete arg1;
9311
9312 wxPyEndAllowThreads(__tstate);
9313 if (PyErr_Occurred()) SWIG_fail;
9314 }
9315 Py_INCREF(Py_None); resultobj = Py_None;
9316 return resultobj;
9317 fail:
9318 return NULL;
9319 }
9320
9321
9322 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9323 PyObject *resultobj;
9324 wxNativeFontInfo *arg1 = 0 ;
9325 wxFont *result;
9326 PyObject * obj0 = 0 ;
9327 char *kwnames[] = {
9328 (char *) "info", NULL
9329 };
9330
9331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9332 {
9333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9334 if (SWIG_arg_fail(1)) SWIG_fail;
9335 if (arg1 == NULL) {
9336 SWIG_null_ref("wxNativeFontInfo");
9337 }
9338 if (SWIG_arg_fail(1)) SWIG_fail;
9339 }
9340 {
9341 if (!wxPyCheckForApp()) SWIG_fail;
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9344
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj;
9357 wxString *arg1 = 0 ;
9358 wxFont *result;
9359 bool temp1 = false ;
9360 PyObject * obj0 = 0 ;
9361 char *kwnames[] = {
9362 (char *) "info", NULL
9363 };
9364
9365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9366 {
9367 arg1 = wxString_in_helper(obj0);
9368 if (arg1 == NULL) SWIG_fail;
9369 temp1 = true;
9370 }
9371 {
9372 if (!wxPyCheckForApp()) SWIG_fail;
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9375
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9380 {
9381 if (temp1)
9382 delete arg1;
9383 }
9384 return resultobj;
9385 fail:
9386 {
9387 if (temp1)
9388 delete arg1;
9389 }
9390 return NULL;
9391 }
9392
9393
9394 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj;
9396 int arg1 ;
9397 wxFontFamily arg2 ;
9398 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9399 wxString const &arg4_defvalue = wxPyEmptyString ;
9400 wxString *arg4 = (wxString *) &arg4_defvalue ;
9401 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9402 wxFont *result;
9403 bool temp4 = false ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 PyObject * obj2 = 0 ;
9407 PyObject * obj3 = 0 ;
9408 PyObject * obj4 = 0 ;
9409 char *kwnames[] = {
9410 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9414 {
9415 arg1 = (int)(SWIG_As_int(obj0));
9416 if (SWIG_arg_fail(1)) SWIG_fail;
9417 }
9418 {
9419 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9420 if (SWIG_arg_fail(2)) SWIG_fail;
9421 }
9422 if (obj2) {
9423 {
9424 arg3 = (int)(SWIG_As_int(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 }
9428 if (obj3) {
9429 {
9430 arg4 = wxString_in_helper(obj3);
9431 if (arg4 == NULL) SWIG_fail;
9432 temp4 = true;
9433 }
9434 }
9435 if (obj4) {
9436 {
9437 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9438 if (SWIG_arg_fail(5)) SWIG_fail;
9439 }
9440 }
9441 {
9442 if (!wxPyCheckForApp()) SWIG_fail;
9443 PyThreadState* __tstate = wxPyBeginAllowThreads();
9444 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9445
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9450 {
9451 if (temp4)
9452 delete arg4;
9453 }
9454 return resultobj;
9455 fail:
9456 {
9457 if (temp4)
9458 delete arg4;
9459 }
9460 return NULL;
9461 }
9462
9463
9464 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj;
9466 wxSize *arg1 = 0 ;
9467 int arg2 ;
9468 int arg3 ;
9469 int arg4 ;
9470 bool arg5 = (bool) false ;
9471 wxString const &arg6_defvalue = wxEmptyString ;
9472 wxString *arg6 = (wxString *) &arg6_defvalue ;
9473 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9474 wxFont *result;
9475 wxSize temp1 ;
9476 bool temp6 = false ;
9477 PyObject * obj0 = 0 ;
9478 PyObject * obj1 = 0 ;
9479 PyObject * obj2 = 0 ;
9480 PyObject * obj3 = 0 ;
9481 PyObject * obj4 = 0 ;
9482 PyObject * obj5 = 0 ;
9483 PyObject * obj6 = 0 ;
9484 char *kwnames[] = {
9485 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9489 {
9490 arg1 = &temp1;
9491 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9492 }
9493 {
9494 arg2 = (int)(SWIG_As_int(obj1));
9495 if (SWIG_arg_fail(2)) SWIG_fail;
9496 }
9497 {
9498 arg3 = (int)(SWIG_As_int(obj2));
9499 if (SWIG_arg_fail(3)) SWIG_fail;
9500 }
9501 {
9502 arg4 = (int)(SWIG_As_int(obj3));
9503 if (SWIG_arg_fail(4)) SWIG_fail;
9504 }
9505 if (obj4) {
9506 {
9507 arg5 = (bool)(SWIG_As_bool(obj4));
9508 if (SWIG_arg_fail(5)) SWIG_fail;
9509 }
9510 }
9511 if (obj5) {
9512 {
9513 arg6 = wxString_in_helper(obj5);
9514 if (arg6 == NULL) SWIG_fail;
9515 temp6 = true;
9516 }
9517 }
9518 if (obj6) {
9519 {
9520 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9521 if (SWIG_arg_fail(7)) SWIG_fail;
9522 }
9523 }
9524 {
9525 if (!wxPyCheckForApp()) SWIG_fail;
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9528
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9533 {
9534 if (temp6)
9535 delete arg6;
9536 }
9537 return resultobj;
9538 fail:
9539 {
9540 if (temp6)
9541 delete arg6;
9542 }
9543 return NULL;
9544 }
9545
9546
9547 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj;
9549 wxSize *arg1 = 0 ;
9550 wxFontFamily arg2 ;
9551 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9552 wxString const &arg4_defvalue = wxEmptyString ;
9553 wxString *arg4 = (wxString *) &arg4_defvalue ;
9554 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9555 wxFont *result;
9556 wxSize temp1 ;
9557 bool temp4 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 PyObject * obj3 = 0 ;
9562 PyObject * obj4 = 0 ;
9563 char *kwnames[] = {
9564 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9565 };
9566
9567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9568 {
9569 arg1 = &temp1;
9570 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9571 }
9572 {
9573 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9574 if (SWIG_arg_fail(2)) SWIG_fail;
9575 }
9576 if (obj2) {
9577 {
9578 arg3 = (int)(SWIG_As_int(obj2));
9579 if (SWIG_arg_fail(3)) SWIG_fail;
9580 }
9581 }
9582 if (obj3) {
9583 {
9584 arg4 = wxString_in_helper(obj3);
9585 if (arg4 == NULL) SWIG_fail;
9586 temp4 = true;
9587 }
9588 }
9589 if (obj4) {
9590 {
9591 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9592 if (SWIG_arg_fail(5)) SWIG_fail;
9593 }
9594 }
9595 {
9596 if (!wxPyCheckForApp()) SWIG_fail;
9597 PyThreadState* __tstate = wxPyBeginAllowThreads();
9598 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9599
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9604 {
9605 if (temp4)
9606 delete arg4;
9607 }
9608 return resultobj;
9609 fail:
9610 {
9611 if (temp4)
9612 delete arg4;
9613 }
9614 return NULL;
9615 }
9616
9617
9618 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj;
9620 wxFont *arg1 = (wxFont *) 0 ;
9621 bool result;
9622 PyObject * obj0 = 0 ;
9623 char *kwnames[] = {
9624 (char *) "self", NULL
9625 };
9626
9627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9629 if (SWIG_arg_fail(1)) SWIG_fail;
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (bool)((wxFont const *)arg1)->Ok();
9633
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 {
9638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9639 }
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj;
9648 wxFont *arg1 = (wxFont *) 0 ;
9649 wxFont *arg2 = (wxFont *) 0 ;
9650 bool result;
9651 PyObject * obj0 = 0 ;
9652 PyObject * obj1 = 0 ;
9653 char *kwnames[] = {
9654 (char *) "self",(char *) "other", NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9659 if (SWIG_arg_fail(1)) SWIG_fail;
9660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9661 if (SWIG_arg_fail(2)) SWIG_fail;
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9665
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 {
9670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9671 }
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxFont *arg1 = (wxFont *) 0 ;
9681 wxFont *arg2 = (wxFont *) 0 ;
9682 bool result;
9683 PyObject * obj0 = 0 ;
9684 PyObject * obj1 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "self",(char *) "other", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9691 if (SWIG_arg_fail(1)) SWIG_fail;
9692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9693 if (SWIG_arg_fail(2)) SWIG_fail;
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9697
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 {
9702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9703 }
9704 return resultobj;
9705 fail:
9706 return NULL;
9707 }
9708
9709
9710 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9711 PyObject *resultobj;
9712 wxFont *arg1 = (wxFont *) 0 ;
9713 int result;
9714 PyObject * obj0 = 0 ;
9715 char *kwnames[] = {
9716 (char *) "self", NULL
9717 };
9718
9719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9721 if (SWIG_arg_fail(1)) SWIG_fail;
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 result = (int)((wxFont const *)arg1)->GetPointSize();
9725
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 {
9730 resultobj = SWIG_From_int((int)(result));
9731 }
9732 return resultobj;
9733 fail:
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxFont *arg1 = (wxFont *) 0 ;
9741 wxSize result;
9742 PyObject * obj0 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 result = ((wxFont const *)arg1)->GetPixelSize();
9753
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 {
9758 wxSize * resultptr;
9759 resultptr = new wxSize((wxSize &)(result));
9760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9761 }
9762 return resultobj;
9763 fail:
9764 return NULL;
9765 }
9766
9767
9768 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 wxFont *arg1 = (wxFont *) 0 ;
9771 bool result;
9772 PyObject * obj0 = 0 ;
9773 char *kwnames[] = {
9774 (char *) "self", NULL
9775 };
9776
9777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9779 if (SWIG_arg_fail(1)) SWIG_fail;
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 {
9788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9789 }
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj;
9798 wxFont *arg1 = (wxFont *) 0 ;
9799 int result;
9800 PyObject * obj0 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "self", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (int)((wxFont const *)arg1)->GetFamily();
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 resultobj = SWIG_From_int((int)(result));
9817 }
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxFont *arg1 = (wxFont *) 0 ;
9827 int result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (int)((wxFont const *)arg1)->GetStyle();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 resultobj = SWIG_From_int((int)(result));
9845 }
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj;
9854 wxFont *arg1 = (wxFont *) 0 ;
9855 int result;
9856 PyObject * obj0 = 0 ;
9857 char *kwnames[] = {
9858 (char *) "self", NULL
9859 };
9860
9861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9863 if (SWIG_arg_fail(1)) SWIG_fail;
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 result = (int)((wxFont const *)arg1)->GetWeight();
9867
9868 wxPyEndAllowThreads(__tstate);
9869 if (PyErr_Occurred()) SWIG_fail;
9870 }
9871 {
9872 resultobj = SWIG_From_int((int)(result));
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj;
9882 wxFont *arg1 = (wxFont *) 0 ;
9883 bool result;
9884 PyObject * obj0 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9895
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 {
9900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9901 }
9902 return resultobj;
9903 fail:
9904 return NULL;
9905 }
9906
9907
9908 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9909 PyObject *resultobj;
9910 wxFont *arg1 = (wxFont *) 0 ;
9911 wxString result;
9912 PyObject * obj0 = 0 ;
9913 char *kwnames[] = {
9914 (char *) "self", NULL
9915 };
9916
9917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9919 if (SWIG_arg_fail(1)) SWIG_fail;
9920 {
9921 PyThreadState* __tstate = wxPyBeginAllowThreads();
9922 result = ((wxFont const *)arg1)->GetFaceName();
9923
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 {
9928 #if wxUSE_UNICODE
9929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9930 #else
9931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9932 #endif
9933 }
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9941 PyObject *resultobj;
9942 wxFont *arg1 = (wxFont *) 0 ;
9943 wxFontEncoding result;
9944 PyObject * obj0 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "self", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9951 if (SWIG_arg_fail(1)) SWIG_fail;
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9955
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 resultobj = SWIG_From_int((result));
9960 return resultobj;
9961 fail:
9962 return NULL;
9963 }
9964
9965
9966 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9967 PyObject *resultobj;
9968 wxFont *arg1 = (wxFont *) 0 ;
9969 wxNativeFontInfo *result;
9970 PyObject * obj0 = 0 ;
9971 char *kwnames[] = {
9972 (char *) "self", NULL
9973 };
9974
9975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9977 if (SWIG_arg_fail(1)) SWIG_fail;
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxFont *arg1 = (wxFont *) 0 ;
9995 bool result;
9996 PyObject * obj0 = 0 ;
9997 char *kwnames[] = {
9998 (char *) "self", NULL
9999 };
10000
10001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10003 if (SWIG_arg_fail(1)) SWIG_fail;
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10007
10008 wxPyEndAllowThreads(__tstate);
10009 if (PyErr_Occurred()) SWIG_fail;
10010 }
10011 {
10012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10013 }
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10021 PyObject *resultobj;
10022 wxFont *arg1 = (wxFont *) 0 ;
10023 wxString result;
10024 PyObject * obj0 = 0 ;
10025 char *kwnames[] = {
10026 (char *) "self", NULL
10027 };
10028
10029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10031 if (SWIG_arg_fail(1)) SWIG_fail;
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10035
10036 wxPyEndAllowThreads(__tstate);
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 {
10040 #if wxUSE_UNICODE
10041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10042 #else
10043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10044 #endif
10045 }
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
10052 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10053 PyObject *resultobj;
10054 wxFont *arg1 = (wxFont *) 0 ;
10055 wxString result;
10056 PyObject * obj0 = 0 ;
10057 char *kwnames[] = {
10058 (char *) "self", NULL
10059 };
10060
10061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10063 if (SWIG_arg_fail(1)) SWIG_fail;
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 {
10072 #if wxUSE_UNICODE
10073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10074 #else
10075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10076 #endif
10077 }
10078 return resultobj;
10079 fail:
10080 return NULL;
10081 }
10082
10083
10084 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj;
10086 wxFont *arg1 = (wxFont *) 0 ;
10087 int arg2 ;
10088 PyObject * obj0 = 0 ;
10089 PyObject * obj1 = 0 ;
10090 char *kwnames[] = {
10091 (char *) "self",(char *) "pointSize", NULL
10092 };
10093
10094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10096 if (SWIG_arg_fail(1)) SWIG_fail;
10097 {
10098 arg2 = (int)(SWIG_As_int(obj1));
10099 if (SWIG_arg_fail(2)) SWIG_fail;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 (arg1)->SetPointSize(arg2);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj;
10117 wxFont *arg1 = (wxFont *) 0 ;
10118 wxSize *arg2 = 0 ;
10119 wxSize temp2 ;
10120 PyObject * obj0 = 0 ;
10121 PyObject * obj1 = 0 ;
10122 char *kwnames[] = {
10123 (char *) "self",(char *) "pixelSize", NULL
10124 };
10125
10126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10128 if (SWIG_arg_fail(1)) SWIG_fail;
10129 {
10130 arg2 = &temp2;
10131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10132 }
10133 {
10134 PyThreadState* __tstate = wxPyBeginAllowThreads();
10135 (arg1)->SetPixelSize((wxSize const &)*arg2);
10136
10137 wxPyEndAllowThreads(__tstate);
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 Py_INCREF(Py_None); resultobj = Py_None;
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj;
10149 wxFont *arg1 = (wxFont *) 0 ;
10150 int arg2 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self",(char *) "family", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 arg2 = (int)(SWIG_As_int(obj1));
10162 if (SWIG_arg_fail(2)) SWIG_fail;
10163 }
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 (arg1)->SetFamily(arg2);
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 Py_INCREF(Py_None); resultobj = Py_None;
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxFont *arg1 = (wxFont *) 0 ;
10181 int arg2 ;
10182 PyObject * obj0 = 0 ;
10183 PyObject * obj1 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "self",(char *) "style", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10190 if (SWIG_arg_fail(1)) SWIG_fail;
10191 {
10192 arg2 = (int)(SWIG_As_int(obj1));
10193 if (SWIG_arg_fail(2)) SWIG_fail;
10194 }
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 (arg1)->SetStyle(arg2);
10198
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 Py_INCREF(Py_None); resultobj = Py_None;
10203 return resultobj;
10204 fail:
10205 return NULL;
10206 }
10207
10208
10209 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj;
10211 wxFont *arg1 = (wxFont *) 0 ;
10212 int arg2 ;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "self",(char *) "weight", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10221 if (SWIG_arg_fail(1)) SWIG_fail;
10222 {
10223 arg2 = (int)(SWIG_As_int(obj1));
10224 if (SWIG_arg_fail(2)) SWIG_fail;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 (arg1)->SetWeight(arg2);
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 Py_INCREF(Py_None); resultobj = Py_None;
10234 return resultobj;
10235 fail:
10236 return NULL;
10237 }
10238
10239
10240 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10241 PyObject *resultobj;
10242 wxFont *arg1 = (wxFont *) 0 ;
10243 wxString *arg2 = 0 ;
10244 bool temp2 = false ;
10245 PyObject * obj0 = 0 ;
10246 PyObject * obj1 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "self",(char *) "faceName", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10253 if (SWIG_arg_fail(1)) SWIG_fail;
10254 {
10255 arg2 = wxString_in_helper(obj1);
10256 if (arg2 == NULL) SWIG_fail;
10257 temp2 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 (arg1)->SetFaceName((wxString const &)*arg2);
10262
10263 wxPyEndAllowThreads(__tstate);
10264 if (PyErr_Occurred()) SWIG_fail;
10265 }
10266 Py_INCREF(Py_None); resultobj = Py_None;
10267 {
10268 if (temp2)
10269 delete arg2;
10270 }
10271 return resultobj;
10272 fail:
10273 {
10274 if (temp2)
10275 delete arg2;
10276 }
10277 return NULL;
10278 }
10279
10280
10281 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj;
10283 wxFont *arg1 = (wxFont *) 0 ;
10284 bool arg2 ;
10285 PyObject * obj0 = 0 ;
10286 PyObject * obj1 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "self",(char *) "underlined", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 {
10295 arg2 = (bool)(SWIG_As_bool(obj1));
10296 if (SWIG_arg_fail(2)) SWIG_fail;
10297 }
10298 {
10299 PyThreadState* __tstate = wxPyBeginAllowThreads();
10300 (arg1)->SetUnderlined(arg2);
10301
10302 wxPyEndAllowThreads(__tstate);
10303 if (PyErr_Occurred()) SWIG_fail;
10304 }
10305 Py_INCREF(Py_None); resultobj = Py_None;
10306 return resultobj;
10307 fail:
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10313 PyObject *resultobj;
10314 wxFont *arg1 = (wxFont *) 0 ;
10315 wxFontEncoding arg2 ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 char *kwnames[] = {
10319 (char *) "self",(char *) "encoding", NULL
10320 };
10321
10322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10324 if (SWIG_arg_fail(1)) SWIG_fail;
10325 {
10326 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10327 if (SWIG_arg_fail(2)) SWIG_fail;
10328 }
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 (arg1)->SetEncoding((wxFontEncoding )arg2);
10332
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 Py_INCREF(Py_None); resultobj = Py_None;
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10344 PyObject *resultobj;
10345 wxFont *arg1 = (wxFont *) 0 ;
10346 wxNativeFontInfo *arg2 = 0 ;
10347 PyObject * obj0 = 0 ;
10348 PyObject * obj1 = 0 ;
10349 char *kwnames[] = {
10350 (char *) "self",(char *) "info", NULL
10351 };
10352
10353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10355 if (SWIG_arg_fail(1)) SWIG_fail;
10356 {
10357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(2)) SWIG_fail;
10359 if (arg2 == NULL) {
10360 SWIG_null_ref("wxNativeFontInfo");
10361 }
10362 if (SWIG_arg_fail(2)) SWIG_fail;
10363 }
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10367
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 Py_INCREF(Py_None); resultobj = Py_None;
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10379 PyObject *resultobj;
10380 wxFont *arg1 = (wxFont *) 0 ;
10381 wxString *arg2 = 0 ;
10382 bool temp2 = false ;
10383 PyObject * obj0 = 0 ;
10384 PyObject * obj1 = 0 ;
10385 char *kwnames[] = {
10386 (char *) "self",(char *) "info", NULL
10387 };
10388
10389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10391 if (SWIG_arg_fail(1)) SWIG_fail;
10392 {
10393 arg2 = wxString_in_helper(obj1);
10394 if (arg2 == NULL) SWIG_fail;
10395 temp2 = true;
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10400
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 Py_INCREF(Py_None); resultobj = Py_None;
10405 {
10406 if (temp2)
10407 delete arg2;
10408 }
10409 return resultobj;
10410 fail:
10411 {
10412 if (temp2)
10413 delete arg2;
10414 }
10415 return NULL;
10416 }
10417
10418
10419 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10420 PyObject *resultobj;
10421 wxFont *arg1 = (wxFont *) 0 ;
10422 wxString *arg2 = 0 ;
10423 bool temp2 = false ;
10424 PyObject * obj0 = 0 ;
10425 PyObject * obj1 = 0 ;
10426 char *kwnames[] = {
10427 (char *) "self",(char *) "info", NULL
10428 };
10429
10430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10432 if (SWIG_arg_fail(1)) SWIG_fail;
10433 {
10434 arg2 = wxString_in_helper(obj1);
10435 if (arg2 == NULL) SWIG_fail;
10436 temp2 = true;
10437 }
10438 {
10439 PyThreadState* __tstate = wxPyBeginAllowThreads();
10440 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10441
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 Py_INCREF(Py_None); resultobj = Py_None;
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return resultobj;
10451 fail:
10452 {
10453 if (temp2)
10454 delete arg2;
10455 }
10456 return NULL;
10457 }
10458
10459
10460 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj;
10462 wxFont *arg1 = (wxFont *) 0 ;
10463 wxString result;
10464 PyObject * obj0 = 0 ;
10465 char *kwnames[] = {
10466 (char *) "self", NULL
10467 };
10468
10469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10471 if (SWIG_arg_fail(1)) SWIG_fail;
10472 {
10473 PyThreadState* __tstate = wxPyBeginAllowThreads();
10474 result = ((wxFont const *)arg1)->GetFamilyString();
10475
10476 wxPyEndAllowThreads(__tstate);
10477 if (PyErr_Occurred()) SWIG_fail;
10478 }
10479 {
10480 #if wxUSE_UNICODE
10481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10482 #else
10483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10484 #endif
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj;
10494 wxFont *arg1 = (wxFont *) 0 ;
10495 wxString result;
10496 PyObject * obj0 = 0 ;
10497 char *kwnames[] = {
10498 (char *) "self", NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10503 if (SWIG_arg_fail(1)) SWIG_fail;
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = ((wxFont const *)arg1)->GetStyleString();
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 {
10512 #if wxUSE_UNICODE
10513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10514 #else
10515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10516 #endif
10517 }
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj;
10526 wxFont *arg1 = (wxFont *) 0 ;
10527 wxString result;
10528 PyObject * obj0 = 0 ;
10529 char *kwnames[] = {
10530 (char *) "self", NULL
10531 };
10532
10533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10535 if (SWIG_arg_fail(1)) SWIG_fail;
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 result = ((wxFont const *)arg1)->GetWeightString();
10539
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 {
10544 #if wxUSE_UNICODE
10545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10546 #else
10547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10548 #endif
10549 }
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj;
10558 wxFont *arg1 = (wxFont *) 0 ;
10559 bool arg2 = (bool) true ;
10560 PyObject * obj0 = 0 ;
10561 PyObject * obj1 = 0 ;
10562 char *kwnames[] = {
10563 (char *) "self",(char *) "no", NULL
10564 };
10565
10566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10568 if (SWIG_arg_fail(1)) SWIG_fail;
10569 if (obj1) {
10570 {
10571 arg2 = (bool)(SWIG_As_bool(obj1));
10572 if (SWIG_arg_fail(2)) SWIG_fail;
10573 }
10574 }
10575 {
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 (arg1)->SetNoAntiAliasing(arg2);
10578
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 Py_INCREF(Py_None); resultobj = Py_None;
10583 return resultobj;
10584 fail:
10585 return NULL;
10586 }
10587
10588
10589 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10590 PyObject *resultobj;
10591 wxFont *arg1 = (wxFont *) 0 ;
10592 bool result;
10593 PyObject * obj0 = 0 ;
10594 char *kwnames[] = {
10595 (char *) "self", NULL
10596 };
10597
10598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10600 if (SWIG_arg_fail(1)) SWIG_fail;
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 {
10609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10610 }
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxFontEncoding result;
10620 char *kwnames[] = {
10621 NULL
10622 };
10623
10624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10625 {
10626 if (!wxPyCheckForApp()) SWIG_fail;
10627 PyThreadState* __tstate = wxPyBeginAllowThreads();
10628 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10629
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 resultobj = SWIG_From_int((result));
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10641 PyObject *resultobj;
10642 wxFontEncoding arg1 ;
10643 PyObject * obj0 = 0 ;
10644 char *kwnames[] = {
10645 (char *) "encoding", NULL
10646 };
10647
10648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10649 {
10650 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10651 if (SWIG_arg_fail(1)) SWIG_fail;
10652 }
10653 {
10654 if (!wxPyCheckForApp()) SWIG_fail;
10655 PyThreadState* __tstate = wxPyBeginAllowThreads();
10656 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10657
10658 wxPyEndAllowThreads(__tstate);
10659 if (PyErr_Occurred()) SWIG_fail;
10660 }
10661 Py_INCREF(Py_None); resultobj = Py_None;
10662 return resultobj;
10663 fail:
10664 return NULL;
10665 }
10666
10667
10668 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10669 PyObject *obj;
10670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10671 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10672 Py_INCREF(obj);
10673 return Py_BuildValue((char *)"");
10674 }
10675 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxPyFontEnumerator *result;
10678 char *kwnames[] = {
10679 NULL
10680 };
10681
10682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10683 {
10684 if (!wxPyCheckForApp()) SWIG_fail;
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10687
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj;
10700 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10701 PyObject * obj0 = 0 ;
10702 char *kwnames[] = {
10703 (char *) "self", NULL
10704 };
10705
10706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10708 if (SWIG_arg_fail(1)) SWIG_fail;
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 delete arg1;
10712
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 Py_INCREF(Py_None); resultobj = Py_None;
10717 return resultobj;
10718 fail:
10719 return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10724 PyObject *resultobj;
10725 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10726 PyObject *arg2 = (PyObject *) 0 ;
10727 PyObject *arg3 = (PyObject *) 0 ;
10728 bool arg4 ;
10729 PyObject * obj0 = 0 ;
10730 PyObject * obj1 = 0 ;
10731 PyObject * obj2 = 0 ;
10732 PyObject * obj3 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 arg2 = obj1;
10741 arg3 = obj2;
10742 {
10743 arg4 = (bool)(SWIG_As_bool(obj3));
10744 if (SWIG_arg_fail(4)) SWIG_fail;
10745 }
10746 {
10747 PyThreadState* __tstate = wxPyBeginAllowThreads();
10748 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10749
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 Py_INCREF(Py_None); resultobj = Py_None;
10754 return resultobj;
10755 fail:
10756 return NULL;
10757 }
10758
10759
10760 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10761 PyObject *resultobj;
10762 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10763 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10764 bool arg3 = (bool) false ;
10765 bool result;
10766 PyObject * obj0 = 0 ;
10767 PyObject * obj1 = 0 ;
10768 PyObject * obj2 = 0 ;
10769 char *kwnames[] = {
10770 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10771 };
10772
10773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10775 if (SWIG_arg_fail(1)) SWIG_fail;
10776 if (obj1) {
10777 {
10778 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10779 if (SWIG_arg_fail(2)) SWIG_fail;
10780 }
10781 }
10782 if (obj2) {
10783 {
10784 arg3 = (bool)(SWIG_As_bool(obj2));
10785 if (SWIG_arg_fail(3)) SWIG_fail;
10786 }
10787 }
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10797 }
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj;
10806 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10807 wxString const &arg2_defvalue = wxPyEmptyString ;
10808 wxString *arg2 = (wxString *) &arg2_defvalue ;
10809 bool result;
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 *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 if (obj1) {
10821 {
10822 arg2 = wxString_in_helper(obj1);
10823 if (arg2 == NULL) SWIG_fail;
10824 temp2 = true;
10825 }
10826 }
10827 {
10828 PyThreadState* __tstate = wxPyBeginAllowThreads();
10829 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10830
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 {
10835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10836 }
10837 {
10838 if (temp2)
10839 delete arg2;
10840 }
10841 return resultobj;
10842 fail:
10843 {
10844 if (temp2)
10845 delete arg2;
10846 }
10847 return NULL;
10848 }
10849
10850
10851 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10852 PyObject *resultobj;
10853 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10854 PyObject *result;
10855 PyObject * obj0 = 0 ;
10856 char *kwnames[] = {
10857 (char *) "self", NULL
10858 };
10859
10860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10862 if (SWIG_arg_fail(1)) SWIG_fail;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 resultobj = result;
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10880 PyObject *result;
10881 PyObject * obj0 = 0 ;
10882 char *kwnames[] = {
10883 (char *) "self", NULL
10884 };
10885
10886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10888 if (SWIG_arg_fail(1)) SWIG_fail;
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = result;
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10904 PyObject *obj;
10905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10906 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10907 Py_INCREF(obj);
10908 return Py_BuildValue((char *)"");
10909 }
10910 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10913 int arg2 ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 char *kwnames[] = {
10917 (char *) "self",(char *) "Language", NULL
10918 };
10919
10920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10922 if (SWIG_arg_fail(1)) SWIG_fail;
10923 {
10924 arg2 = (int)(SWIG_As_int(obj1));
10925 if (SWIG_arg_fail(2)) SWIG_fail;
10926 }
10927 if (arg1) (arg1)->Language = arg2;
10928
10929 Py_INCREF(Py_None); resultobj = Py_None;
10930 return resultobj;
10931 fail:
10932 return NULL;
10933 }
10934
10935
10936 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj;
10938 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10939 int result;
10940 PyObject * obj0 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 result = (int) ((arg1)->Language);
10949
10950 {
10951 resultobj = SWIG_From_int((int)(result));
10952 }
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj;
10961 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10962 wxString *arg2 = (wxString *) 0 ;
10963 bool temp2 = false ;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 char *kwnames[] = {
10967 (char *) "self",(char *) "CanonicalName", NULL
10968 };
10969
10970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10972 if (SWIG_arg_fail(1)) SWIG_fail;
10973 {
10974 arg2 = wxString_in_helper(obj1);
10975 if (arg2 == NULL) SWIG_fail;
10976 temp2 = true;
10977 }
10978 if (arg1) (arg1)->CanonicalName = *arg2;
10979
10980 Py_INCREF(Py_None); resultobj = Py_None;
10981 {
10982 if (temp2)
10983 delete arg2;
10984 }
10985 return resultobj;
10986 fail:
10987 {
10988 if (temp2)
10989 delete arg2;
10990 }
10991 return NULL;
10992 }
10993
10994
10995 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj;
10997 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10998 wxString *result;
10999 PyObject * obj0 = 0 ;
11000 char *kwnames[] = {
11001 (char *) "self", NULL
11002 };
11003
11004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11006 if (SWIG_arg_fail(1)) SWIG_fail;
11007 result = (wxString *)& ((arg1)->CanonicalName);
11008
11009 {
11010 #if wxUSE_UNICODE
11011 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11012 #else
11013 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11014 #endif
11015 }
11016 return resultobj;
11017 fail:
11018 return NULL;
11019 }
11020
11021
11022 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj;
11024 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11025 wxString *arg2 = (wxString *) 0 ;
11026 bool temp2 = false ;
11027 PyObject * obj0 = 0 ;
11028 PyObject * obj1 = 0 ;
11029 char *kwnames[] = {
11030 (char *) "self",(char *) "Description", NULL
11031 };
11032
11033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11035 if (SWIG_arg_fail(1)) SWIG_fail;
11036 {
11037 arg2 = wxString_in_helper(obj1);
11038 if (arg2 == NULL) SWIG_fail;
11039 temp2 = true;
11040 }
11041 if (arg1) (arg1)->Description = *arg2;
11042
11043 Py_INCREF(Py_None); resultobj = Py_None;
11044 {
11045 if (temp2)
11046 delete arg2;
11047 }
11048 return resultobj;
11049 fail:
11050 {
11051 if (temp2)
11052 delete arg2;
11053 }
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxLanguageInfo *arg1 = (wxLanguageInfo *) 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:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 result = (wxString *)& ((arg1)->Description);
11071
11072 {
11073 #if wxUSE_UNICODE
11074 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11075 #else
11076 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11077 #endif
11078 }
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11086 PyObject *obj;
11087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11088 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11089 Py_INCREF(obj);
11090 return Py_BuildValue((char *)"");
11091 }
11092 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj;
11094 int arg1 = (int) -1 ;
11095 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11096 wxLocale *result;
11097 PyObject * obj0 = 0 ;
11098 PyObject * obj1 = 0 ;
11099 char *kwnames[] = {
11100 (char *) "language",(char *) "flags", NULL
11101 };
11102
11103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11104 if (obj0) {
11105 {
11106 arg1 = (int)(SWIG_As_int(obj0));
11107 if (SWIG_arg_fail(1)) SWIG_fail;
11108 }
11109 }
11110 if (obj1) {
11111 {
11112 arg2 = (int)(SWIG_As_int(obj1));
11113 if (SWIG_arg_fail(2)) SWIG_fail;
11114 }
11115 }
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (wxLocale *)new_wxLocale(arg1,arg2);
11119
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj;
11132 wxLocale *arg1 = (wxLocale *) 0 ;
11133 PyObject * obj0 = 0 ;
11134 char *kwnames[] = {
11135 (char *) "self", NULL
11136 };
11137
11138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11140 if (SWIG_arg_fail(1)) SWIG_fail;
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 delete arg1;
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_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxLocale *arg1 = (wxLocale *) 0 ;
11158 wxString *arg2 = 0 ;
11159 wxString const &arg3_defvalue = wxPyEmptyString ;
11160 wxString *arg3 = (wxString *) &arg3_defvalue ;
11161 wxString const &arg4_defvalue = wxPyEmptyString ;
11162 wxString *arg4 = (wxString *) &arg4_defvalue ;
11163 bool arg5 = (bool) true ;
11164 bool arg6 = (bool) false ;
11165 bool result;
11166 bool temp2 = false ;
11167 bool temp3 = false ;
11168 bool temp4 = false ;
11169 PyObject * obj0 = 0 ;
11170 PyObject * obj1 = 0 ;
11171 PyObject * obj2 = 0 ;
11172 PyObject * obj3 = 0 ;
11173 PyObject * obj4 = 0 ;
11174 PyObject * obj5 = 0 ;
11175 char *kwnames[] = {
11176 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11177 };
11178
11179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11181 if (SWIG_arg_fail(1)) SWIG_fail;
11182 {
11183 arg2 = wxString_in_helper(obj1);
11184 if (arg2 == NULL) SWIG_fail;
11185 temp2 = true;
11186 }
11187 if (obj2) {
11188 {
11189 arg3 = wxString_in_helper(obj2);
11190 if (arg3 == NULL) SWIG_fail;
11191 temp3 = true;
11192 }
11193 }
11194 if (obj3) {
11195 {
11196 arg4 = wxString_in_helper(obj3);
11197 if (arg4 == NULL) SWIG_fail;
11198 temp4 = true;
11199 }
11200 }
11201 if (obj4) {
11202 {
11203 arg5 = (bool)(SWIG_As_bool(obj4));
11204 if (SWIG_arg_fail(5)) SWIG_fail;
11205 }
11206 }
11207 if (obj5) {
11208 {
11209 arg6 = (bool)(SWIG_As_bool(obj5));
11210 if (SWIG_arg_fail(6)) SWIG_fail;
11211 }
11212 }
11213 {
11214 PyThreadState* __tstate = wxPyBeginAllowThreads();
11215 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11216
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 {
11221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11222 }
11223 {
11224 if (temp2)
11225 delete arg2;
11226 }
11227 {
11228 if (temp3)
11229 delete arg3;
11230 }
11231 {
11232 if (temp4)
11233 delete arg4;
11234 }
11235 return resultobj;
11236 fail:
11237 {
11238 if (temp2)
11239 delete arg2;
11240 }
11241 {
11242 if (temp3)
11243 delete arg3;
11244 }
11245 {
11246 if (temp4)
11247 delete arg4;
11248 }
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxLocale *arg1 = (wxLocale *) 0 ;
11256 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11257 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11258 bool result;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char *kwnames[] = {
11263 (char *) "self",(char *) "language",(char *) "flags", NULL
11264 };
11265
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11268 if (SWIG_arg_fail(1)) SWIG_fail;
11269 if (obj1) {
11270 {
11271 arg2 = (int)(SWIG_As_int(obj1));
11272 if (SWIG_arg_fail(2)) SWIG_fail;
11273 }
11274 }
11275 if (obj2) {
11276 {
11277 arg3 = (int)(SWIG_As_int(obj2));
11278 if (SWIG_arg_fail(3)) SWIG_fail;
11279 }
11280 }
11281 {
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11284
11285 wxPyEndAllowThreads(__tstate);
11286 if (PyErr_Occurred()) SWIG_fail;
11287 }
11288 {
11289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11290 }
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj;
11299 int result;
11300 char *kwnames[] = {
11301 NULL
11302 };
11303
11304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (int)wxLocale::GetSystemLanguage();
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 {
11313 resultobj = SWIG_From_int((int)(result));
11314 }
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 wxFontEncoding result;
11324 char *kwnames[] = {
11325 NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11332
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 resultobj = SWIG_From_int((result));
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj;
11345 wxString result;
11346 char *kwnames[] = {
11347 NULL
11348 };
11349
11350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = wxLocale::GetSystemEncodingName();
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 #if wxUSE_UNICODE
11360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11361 #else
11362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11363 #endif
11364 }
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj;
11373 wxLocale *arg1 = (wxLocale *) 0 ;
11374 bool result;
11375 PyObject * obj0 = 0 ;
11376 char *kwnames[] = {
11377 (char *) "self", NULL
11378 };
11379
11380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11382 if (SWIG_arg_fail(1)) SWIG_fail;
11383 {
11384 PyThreadState* __tstate = wxPyBeginAllowThreads();
11385 result = (bool)((wxLocale const *)arg1)->IsOk();
11386
11387 wxPyEndAllowThreads(__tstate);
11388 if (PyErr_Occurred()) SWIG_fail;
11389 }
11390 {
11391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11392 }
11393 return resultobj;
11394 fail:
11395 return NULL;
11396 }
11397
11398
11399 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11400 PyObject *resultobj;
11401 wxLocale *arg1 = (wxLocale *) 0 ;
11402 wxString result;
11403 PyObject * obj0 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 result = ((wxLocale const *)arg1)->GetLocale();
11414
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 {
11419 #if wxUSE_UNICODE
11420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11421 #else
11422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11423 #endif
11424 }
11425 return resultobj;
11426 fail:
11427 return NULL;
11428 }
11429
11430
11431 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj;
11433 wxLocale *arg1 = (wxLocale *) 0 ;
11434 int result;
11435 PyObject * obj0 = 0 ;
11436 char *kwnames[] = {
11437 (char *) "self", NULL
11438 };
11439
11440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11442 if (SWIG_arg_fail(1)) SWIG_fail;
11443 {
11444 PyThreadState* __tstate = wxPyBeginAllowThreads();
11445 result = (int)((wxLocale const *)arg1)->GetLanguage();
11446
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 {
11451 resultobj = SWIG_From_int((int)(result));
11452 }
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj;
11461 wxLocale *arg1 = (wxLocale *) 0 ;
11462 wxString result;
11463 PyObject * obj0 = 0 ;
11464 char *kwnames[] = {
11465 (char *) "self", NULL
11466 };
11467
11468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11470 if (SWIG_arg_fail(1)) SWIG_fail;
11471 {
11472 PyThreadState* __tstate = wxPyBeginAllowThreads();
11473 result = ((wxLocale const *)arg1)->GetSysName();
11474
11475 wxPyEndAllowThreads(__tstate);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 {
11479 #if wxUSE_UNICODE
11480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11481 #else
11482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11483 #endif
11484 }
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxLocale *arg1 = (wxLocale *) 0 ;
11494 wxString result;
11495 PyObject * obj0 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "self", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11502 if (SWIG_arg_fail(1)) SWIG_fail;
11503 {
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 result = ((wxLocale const *)arg1)->GetCanonicalName();
11506
11507 wxPyEndAllowThreads(__tstate);
11508 if (PyErr_Occurred()) SWIG_fail;
11509 }
11510 {
11511 #if wxUSE_UNICODE
11512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11513 #else
11514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11515 #endif
11516 }
11517 return resultobj;
11518 fail:
11519 return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj;
11525 wxString *arg1 = 0 ;
11526 bool temp1 = false ;
11527 PyObject * obj0 = 0 ;
11528 char *kwnames[] = {
11529 (char *) "prefix", NULL
11530 };
11531
11532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11533 {
11534 arg1 = wxString_in_helper(obj0);
11535 if (arg1 == NULL) SWIG_fail;
11536 temp1 = true;
11537 }
11538 {
11539 PyThreadState* __tstate = wxPyBeginAllowThreads();
11540 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11541
11542 wxPyEndAllowThreads(__tstate);
11543 if (PyErr_Occurred()) SWIG_fail;
11544 }
11545 Py_INCREF(Py_None); resultobj = Py_None;
11546 {
11547 if (temp1)
11548 delete arg1;
11549 }
11550 return resultobj;
11551 fail:
11552 {
11553 if (temp1)
11554 delete arg1;
11555 }
11556 return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11561 PyObject *resultobj;
11562 wxLocale *arg1 = (wxLocale *) 0 ;
11563 wxString *arg2 = 0 ;
11564 bool result;
11565 bool temp2 = false ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 char *kwnames[] = {
11569 (char *) "self",(char *) "szDomain", NULL
11570 };
11571
11572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11574 if (SWIG_arg_fail(1)) SWIG_fail;
11575 {
11576 arg2 = wxString_in_helper(obj1);
11577 if (arg2 == NULL) SWIG_fail;
11578 temp2 = true;
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11583
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 {
11588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11589 }
11590 {
11591 if (temp2)
11592 delete arg2;
11593 }
11594 return resultobj;
11595 fail:
11596 {
11597 if (temp2)
11598 delete arg2;
11599 }
11600 return NULL;
11601 }
11602
11603
11604 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj;
11606 wxLocale *arg1 = (wxLocale *) 0 ;
11607 wxString *arg2 = 0 ;
11608 bool result;
11609 bool temp2 = false ;
11610 PyObject * obj0 = 0 ;
11611 PyObject * obj1 = 0 ;
11612 char *kwnames[] = {
11613 (char *) "self",(char *) "szDomain", NULL
11614 };
11615
11616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11618 if (SWIG_arg_fail(1)) SWIG_fail;
11619 {
11620 arg2 = wxString_in_helper(obj1);
11621 if (arg2 == NULL) SWIG_fail;
11622 temp2 = true;
11623 }
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11627
11628 wxPyEndAllowThreads(__tstate);
11629 if (PyErr_Occurred()) SWIG_fail;
11630 }
11631 {
11632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11633 }
11634 {
11635 if (temp2)
11636 delete arg2;
11637 }
11638 return resultobj;
11639 fail:
11640 {
11641 if (temp2)
11642 delete arg2;
11643 }
11644 return NULL;
11645 }
11646
11647
11648 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj;
11650 int arg1 ;
11651 wxLanguageInfo *result;
11652 PyObject * obj0 = 0 ;
11653 char *kwnames[] = {
11654 (char *) "lang", NULL
11655 };
11656
11657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11658 {
11659 arg1 = (int)(SWIG_As_int(obj0));
11660 if (SWIG_arg_fail(1)) SWIG_fail;
11661 }
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11665
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11677 PyObject *resultobj;
11678 int arg1 ;
11679 wxString result;
11680 PyObject * obj0 = 0 ;
11681 char *kwnames[] = {
11682 (char *) "lang", NULL
11683 };
11684
11685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11686 {
11687 arg1 = (int)(SWIG_As_int(obj0));
11688 if (SWIG_arg_fail(1)) SWIG_fail;
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = wxLocale::GetLanguageName(arg1);
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 #if wxUSE_UNICODE
11699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11700 #else
11701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11702 #endif
11703 }
11704 return resultobj;
11705 fail:
11706 return NULL;
11707 }
11708
11709
11710 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11711 PyObject *resultobj;
11712 wxString *arg1 = 0 ;
11713 wxLanguageInfo *result;
11714 bool temp1 = false ;
11715 PyObject * obj0 = 0 ;
11716 char *kwnames[] = {
11717 (char *) "locale", NULL
11718 };
11719
11720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11721 {
11722 arg1 = wxString_in_helper(obj0);
11723 if (arg1 == NULL) SWIG_fail;
11724 temp1 = true;
11725 }
11726 {
11727 PyThreadState* __tstate = wxPyBeginAllowThreads();
11728 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11729
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11734 {
11735 if (temp1)
11736 delete arg1;
11737 }
11738 return resultobj;
11739 fail:
11740 {
11741 if (temp1)
11742 delete arg1;
11743 }
11744 return NULL;
11745 }
11746
11747
11748 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj;
11750 wxLanguageInfo *arg1 = 0 ;
11751 PyObject * obj0 = 0 ;
11752 char *kwnames[] = {
11753 (char *) "info", NULL
11754 };
11755
11756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11757 {
11758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11759 if (SWIG_arg_fail(1)) SWIG_fail;
11760 if (arg1 == NULL) {
11761 SWIG_null_ref("wxLanguageInfo");
11762 }
11763 if (SWIG_arg_fail(1)) SWIG_fail;
11764 }
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 Py_INCREF(Py_None); resultobj = Py_None;
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11780 PyObject *resultobj;
11781 wxLocale *arg1 = (wxLocale *) 0 ;
11782 wxString *arg2 = 0 ;
11783 wxString const &arg3_defvalue = wxPyEmptyString ;
11784 wxString *arg3 = (wxString *) &arg3_defvalue ;
11785 wxString result;
11786 bool temp2 = false ;
11787 bool temp3 = false ;
11788 PyObject * obj0 = 0 ;
11789 PyObject * obj1 = 0 ;
11790 PyObject * obj2 = 0 ;
11791 char *kwnames[] = {
11792 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11793 };
11794
11795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11797 if (SWIG_arg_fail(1)) SWIG_fail;
11798 {
11799 arg2 = wxString_in_helper(obj1);
11800 if (arg2 == NULL) SWIG_fail;
11801 temp2 = true;
11802 }
11803 if (obj2) {
11804 {
11805 arg3 = wxString_in_helper(obj2);
11806 if (arg3 == NULL) SWIG_fail;
11807 temp3 = true;
11808 }
11809 }
11810 {
11811 PyThreadState* __tstate = wxPyBeginAllowThreads();
11812 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11813
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 #if wxUSE_UNICODE
11819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11820 #else
11821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11822 #endif
11823 }
11824 {
11825 if (temp2)
11826 delete arg2;
11827 }
11828 {
11829 if (temp3)
11830 delete arg3;
11831 }
11832 return resultobj;
11833 fail:
11834 {
11835 if (temp2)
11836 delete arg2;
11837 }
11838 {
11839 if (temp3)
11840 delete arg3;
11841 }
11842 return NULL;
11843 }
11844
11845
11846 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj;
11848 wxLocale *arg1 = (wxLocale *) 0 ;
11849 wxString *result;
11850 PyObject * obj0 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 PyThreadState* __tstate = wxPyBeginAllowThreads();
11860 {
11861 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11862 result = (wxString *) &_result_ref;
11863 }
11864
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 #if wxUSE_UNICODE
11870 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11871 #else
11872 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11873 #endif
11874 }
11875 return resultobj;
11876 fail:
11877 return NULL;
11878 }
11879
11880
11881 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11882 PyObject *obj;
11883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11884 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11885 Py_INCREF(obj);
11886 return Py_BuildValue((char *)"");
11887 }
11888 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj;
11890 wxLocale *result;
11891 char *kwnames[] = {
11892 NULL
11893 };
11894
11895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11896 {
11897 PyThreadState* __tstate = wxPyBeginAllowThreads();
11898 result = (wxLocale *)wxGetLocale();
11899
11900 wxPyEndAllowThreads(__tstate);
11901 if (PyErr_Occurred()) SWIG_fail;
11902 }
11903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11911 PyObject *resultobj;
11912 wxString *arg1 = 0 ;
11913 wxString result;
11914 bool temp1 = false ;
11915 PyObject * obj0 = 0 ;
11916
11917 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11918 {
11919 arg1 = wxString_in_helper(obj0);
11920 if (arg1 == NULL) SWIG_fail;
11921 temp1 = true;
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = wxGetTranslation((wxString const &)*arg1);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 #if wxUSE_UNICODE
11932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11933 #else
11934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11935 #endif
11936 }
11937 {
11938 if (temp1)
11939 delete arg1;
11940 }
11941 return resultobj;
11942 fail:
11943 {
11944 if (temp1)
11945 delete arg1;
11946 }
11947 return NULL;
11948 }
11949
11950
11951 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11952 PyObject *resultobj;
11953 wxString *arg1 = 0 ;
11954 wxString *arg2 = 0 ;
11955 size_t arg3 ;
11956 wxString result;
11957 bool temp1 = false ;
11958 bool temp2 = false ;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 PyObject * obj2 = 0 ;
11962
11963 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11964 {
11965 arg1 = wxString_in_helper(obj0);
11966 if (arg1 == NULL) SWIG_fail;
11967 temp1 = true;
11968 }
11969 {
11970 arg2 = wxString_in_helper(obj1);
11971 if (arg2 == NULL) SWIG_fail;
11972 temp2 = true;
11973 }
11974 {
11975 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11976 if (SWIG_arg_fail(3)) SWIG_fail;
11977 }
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11981
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 {
11986 #if wxUSE_UNICODE
11987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11988 #else
11989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11990 #endif
11991 }
11992 {
11993 if (temp1)
11994 delete arg1;
11995 }
11996 {
11997 if (temp2)
11998 delete arg2;
11999 }
12000 return resultobj;
12001 fail:
12002 {
12003 if (temp1)
12004 delete arg1;
12005 }
12006 {
12007 if (temp2)
12008 delete arg2;
12009 }
12010 return NULL;
12011 }
12012
12013
12014 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12015 int argc;
12016 PyObject *argv[4];
12017 int ii;
12018
12019 argc = PyObject_Length(args);
12020 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12021 argv[ii] = PyTuple_GetItem(args,ii);
12022 }
12023 if (argc == 1) {
12024 int _v;
12025 {
12026 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12027 }
12028 if (_v) {
12029 return _wrap_GetTranslation__SWIG_0(self,args);
12030 }
12031 }
12032 if (argc == 3) {
12033 int _v;
12034 {
12035 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12036 }
12037 if (_v) {
12038 {
12039 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12040 }
12041 if (_v) {
12042 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12043 if (_v) {
12044 return _wrap_GetTranslation__SWIG_1(self,args);
12045 }
12046 }
12047 }
12048 }
12049
12050 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12051 return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj;
12057 wxEncodingConverter *result;
12058 char *kwnames[] = {
12059 NULL
12060 };
12061
12062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 result = (wxEncodingConverter *)new wxEncodingConverter();
12066
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12078 PyObject *resultobj;
12079 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12080 PyObject * obj0 = 0 ;
12081 char *kwnames[] = {
12082 (char *) "self", NULL
12083 };
12084
12085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12087 if (SWIG_arg_fail(1)) SWIG_fail;
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 delete arg1;
12091
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 Py_INCREF(Py_None); resultobj = Py_None;
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj;
12104 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12105 wxFontEncoding arg2 ;
12106 wxFontEncoding arg3 ;
12107 int arg4 = (int) wxCONVERT_STRICT ;
12108 bool result;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12111 PyObject * obj2 = 0 ;
12112 PyObject * obj3 = 0 ;
12113 char *kwnames[] = {
12114 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12115 };
12116
12117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12119 if (SWIG_arg_fail(1)) SWIG_fail;
12120 {
12121 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12122 if (SWIG_arg_fail(2)) SWIG_fail;
12123 }
12124 {
12125 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12126 if (SWIG_arg_fail(3)) SWIG_fail;
12127 }
12128 if (obj3) {
12129 {
12130 arg4 = (int)(SWIG_As_int(obj3));
12131 if (SWIG_arg_fail(4)) SWIG_fail;
12132 }
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12143 }
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12151 PyObject *resultobj;
12152 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12153 wxString *arg2 = 0 ;
12154 wxString result;
12155 bool temp2 = false ;
12156 PyObject * obj0 = 0 ;
12157 PyObject * obj1 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "self",(char *) "input", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 {
12166 arg2 = wxString_in_helper(obj1);
12167 if (arg2 == NULL) SWIG_fail;
12168 temp2 = true;
12169 }
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (arg1)->Convert((wxString const &)*arg2);
12173
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 {
12178 #if wxUSE_UNICODE
12179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12180 #else
12181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12182 #endif
12183 }
12184 {
12185 if (temp2)
12186 delete arg2;
12187 }
12188 return resultobj;
12189 fail:
12190 {
12191 if (temp2)
12192 delete arg2;
12193 }
12194 return NULL;
12195 }
12196
12197
12198 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj;
12200 wxFontEncoding arg1 ;
12201 int arg2 = (int) wxPLATFORM_CURRENT ;
12202 wxFontEncodingArray result;
12203 PyObject * obj0 = 0 ;
12204 PyObject * obj1 = 0 ;
12205 char *kwnames[] = {
12206 (char *) "enc",(char *) "platform", NULL
12207 };
12208
12209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12210 {
12211 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12212 if (SWIG_arg_fail(1)) SWIG_fail;
12213 }
12214 if (obj1) {
12215 {
12216 arg2 = (int)(SWIG_As_int(obj1));
12217 if (SWIG_arg_fail(2)) SWIG_fail;
12218 }
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = PyList_New(0);
12229 for (size_t i=0; i < (&result)->GetCount(); i++) {
12230 PyObject* number = PyInt_FromLong((&result)->Item(i));
12231 PyList_Append(resultobj, number);
12232 Py_DECREF(number);
12233 }
12234 }
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxFontEncoding arg1 ;
12244 wxFontEncodingArray result;
12245 PyObject * obj0 = 0 ;
12246 char *kwnames[] = {
12247 (char *) "enc", NULL
12248 };
12249
12250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12251 {
12252 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12253 if (SWIG_arg_fail(1)) SWIG_fail;
12254 }
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 {
12263 resultobj = PyList_New(0);
12264 for (size_t i=0; i < (&result)->GetCount(); i++) {
12265 PyObject* number = PyInt_FromLong((&result)->Item(i));
12266 PyList_Append(resultobj, number);
12267 Py_DECREF(number);
12268 }
12269 }
12270 return resultobj;
12271 fail:
12272 return NULL;
12273 }
12274
12275
12276 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12277 PyObject *resultobj;
12278 wxFontEncoding arg1 ;
12279 wxFontEncoding arg2 ;
12280 bool result;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 char *kwnames[] = {
12284 (char *) "encIn",(char *) "encOut", NULL
12285 };
12286
12287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12288 {
12289 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12290 if (SWIG_arg_fail(1)) SWIG_fail;
12291 }
12292 {
12293 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12294 if (SWIG_arg_fail(2)) SWIG_fail;
12295 }
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12299
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 {
12304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12305 }
12306 return resultobj;
12307 fail:
12308 return NULL;
12309 }
12310
12311
12312 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12313 PyObject *obj;
12314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12315 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12316 Py_INCREF(obj);
12317 return Py_BuildValue((char *)"");
12318 }
12319 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12320 PyObject *resultobj;
12321 wxDC *arg1 = (wxDC *) 0 ;
12322 PyObject * obj0 = 0 ;
12323 char *kwnames[] = {
12324 (char *) "self", NULL
12325 };
12326
12327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12329 if (SWIG_arg_fail(1)) SWIG_fail;
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 delete arg1;
12333
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 Py_INCREF(Py_None); resultobj = Py_None;
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj;
12346 wxDC *arg1 = (wxDC *) 0 ;
12347 PyObject * obj0 = 0 ;
12348 char *kwnames[] = {
12349 (char *) "self", NULL
12350 };
12351
12352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12354 if (SWIG_arg_fail(1)) SWIG_fail;
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 (arg1)->BeginDrawing();
12358
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 Py_INCREF(Py_None); resultobj = Py_None;
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj;
12371 wxDC *arg1 = (wxDC *) 0 ;
12372 PyObject * obj0 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 (arg1)->EndDrawing();
12383
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 Py_INCREF(Py_None); resultobj = Py_None;
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj;
12396 wxDC *arg1 = (wxDC *) 0 ;
12397 int arg2 ;
12398 int arg3 ;
12399 wxColour *arg4 = 0 ;
12400 int arg5 = (int) wxFLOOD_SURFACE ;
12401 bool result;
12402 wxColour temp4 ;
12403 PyObject * obj0 = 0 ;
12404 PyObject * obj1 = 0 ;
12405 PyObject * obj2 = 0 ;
12406 PyObject * obj3 = 0 ;
12407 PyObject * obj4 = 0 ;
12408 char *kwnames[] = {
12409 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12410 };
12411
12412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12414 if (SWIG_arg_fail(1)) SWIG_fail;
12415 {
12416 arg2 = (int)(SWIG_As_int(obj1));
12417 if (SWIG_arg_fail(2)) SWIG_fail;
12418 }
12419 {
12420 arg3 = (int)(SWIG_As_int(obj2));
12421 if (SWIG_arg_fail(3)) SWIG_fail;
12422 }
12423 {
12424 arg4 = &temp4;
12425 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12426 }
12427 if (obj4) {
12428 {
12429 arg5 = (int)(SWIG_As_int(obj4));
12430 if (SWIG_arg_fail(5)) SWIG_fail;
12431 }
12432 }
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12442 }
12443 return resultobj;
12444 fail:
12445 return NULL;
12446 }
12447
12448
12449 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12450 PyObject *resultobj;
12451 wxDC *arg1 = (wxDC *) 0 ;
12452 wxPoint *arg2 = 0 ;
12453 wxColour *arg3 = 0 ;
12454 int arg4 = (int) wxFLOOD_SURFACE ;
12455 bool result;
12456 wxPoint temp2 ;
12457 wxColour temp3 ;
12458 PyObject * obj0 = 0 ;
12459 PyObject * obj1 = 0 ;
12460 PyObject * obj2 = 0 ;
12461 PyObject * obj3 = 0 ;
12462 char *kwnames[] = {
12463 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12464 };
12465
12466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12468 if (SWIG_arg_fail(1)) SWIG_fail;
12469 {
12470 arg2 = &temp2;
12471 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12472 }
12473 {
12474 arg3 = &temp3;
12475 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12476 }
12477 if (obj3) {
12478 {
12479 arg4 = (int)(SWIG_As_int(obj3));
12480 if (SWIG_arg_fail(4)) SWIG_fail;
12481 }
12482 }
12483 {
12484 PyThreadState* __tstate = wxPyBeginAllowThreads();
12485 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12486
12487 wxPyEndAllowThreads(__tstate);
12488 if (PyErr_Occurred()) SWIG_fail;
12489 }
12490 {
12491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12492 }
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12500 PyObject *resultobj;
12501 wxDC *arg1 = (wxDC *) 0 ;
12502 int arg2 ;
12503 int arg3 ;
12504 wxColour result;
12505 PyObject * obj0 = 0 ;
12506 PyObject * obj1 = 0 ;
12507 PyObject * obj2 = 0 ;
12508 char *kwnames[] = {
12509 (char *) "self",(char *) "x",(char *) "y", NULL
12510 };
12511
12512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12514 if (SWIG_arg_fail(1)) SWIG_fail;
12515 {
12516 arg2 = (int)(SWIG_As_int(obj1));
12517 if (SWIG_arg_fail(2)) SWIG_fail;
12518 }
12519 {
12520 arg3 = (int)(SWIG_As_int(obj2));
12521 if (SWIG_arg_fail(3)) SWIG_fail;
12522 }
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = wxDC_GetPixel(arg1,arg2,arg3);
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 {
12531 wxColour * resultptr;
12532 resultptr = new wxColour((wxColour &)(result));
12533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12534 }
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxDC *arg1 = (wxDC *) 0 ;
12544 wxPoint *arg2 = 0 ;
12545 wxColour result;
12546 wxPoint temp2 ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self",(char *) "pt", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 arg2 = &temp2;
12558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12563
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 {
12568 wxColour * resultptr;
12569 resultptr = new wxColour((wxColour &)(result));
12570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12571 }
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12579 PyObject *resultobj;
12580 wxDC *arg1 = (wxDC *) 0 ;
12581 int arg2 ;
12582 int arg3 ;
12583 int arg4 ;
12584 int arg5 ;
12585 PyObject * obj0 = 0 ;
12586 PyObject * obj1 = 0 ;
12587 PyObject * obj2 = 0 ;
12588 PyObject * obj3 = 0 ;
12589 PyObject * obj4 = 0 ;
12590 char *kwnames[] = {
12591 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12596 if (SWIG_arg_fail(1)) SWIG_fail;
12597 {
12598 arg2 = (int)(SWIG_As_int(obj1));
12599 if (SWIG_arg_fail(2)) SWIG_fail;
12600 }
12601 {
12602 arg3 = (int)(SWIG_As_int(obj2));
12603 if (SWIG_arg_fail(3)) SWIG_fail;
12604 }
12605 {
12606 arg4 = (int)(SWIG_As_int(obj3));
12607 if (SWIG_arg_fail(4)) SWIG_fail;
12608 }
12609 {
12610 arg5 = (int)(SWIG_As_int(obj4));
12611 if (SWIG_arg_fail(5)) SWIG_fail;
12612 }
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12616
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 Py_INCREF(Py_None); resultobj = Py_None;
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj;
12629 wxDC *arg1 = (wxDC *) 0 ;
12630 wxPoint *arg2 = 0 ;
12631 wxPoint *arg3 = 0 ;
12632 wxPoint temp2 ;
12633 wxPoint temp3 ;
12634 PyObject * obj0 = 0 ;
12635 PyObject * obj1 = 0 ;
12636 PyObject * obj2 = 0 ;
12637 char *kwnames[] = {
12638 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12639 };
12640
12641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12643 if (SWIG_arg_fail(1)) SWIG_fail;
12644 {
12645 arg2 = &temp2;
12646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12647 }
12648 {
12649 arg3 = &temp3;
12650 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12651 }
12652 {
12653 PyThreadState* __tstate = wxPyBeginAllowThreads();
12654 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12655
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 Py_INCREF(Py_None); resultobj = Py_None;
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxDC *arg1 = (wxDC *) 0 ;
12669 int arg2 ;
12670 int arg3 ;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 PyObject * obj2 = 0 ;
12674 char *kwnames[] = {
12675 (char *) "self",(char *) "x",(char *) "y", NULL
12676 };
12677
12678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12680 if (SWIG_arg_fail(1)) SWIG_fail;
12681 {
12682 arg2 = (int)(SWIG_As_int(obj1));
12683 if (SWIG_arg_fail(2)) SWIG_fail;
12684 }
12685 {
12686 arg3 = (int)(SWIG_As_int(obj2));
12687 if (SWIG_arg_fail(3)) SWIG_fail;
12688 }
12689 {
12690 PyThreadState* __tstate = wxPyBeginAllowThreads();
12691 (arg1)->CrossHair(arg2,arg3);
12692
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 Py_INCREF(Py_None); resultobj = Py_None;
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxDC *arg1 = (wxDC *) 0 ;
12706 wxPoint *arg2 = 0 ;
12707 wxPoint temp2 ;
12708 PyObject * obj0 = 0 ;
12709 PyObject * obj1 = 0 ;
12710 char *kwnames[] = {
12711 (char *) "self",(char *) "pt", NULL
12712 };
12713
12714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12716 if (SWIG_arg_fail(1)) SWIG_fail;
12717 {
12718 arg2 = &temp2;
12719 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12720 }
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 (arg1)->CrossHair((wxPoint const &)*arg2);
12724
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 Py_INCREF(Py_None); resultobj = Py_None;
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxDC *arg1 = (wxDC *) 0 ;
12738 int arg2 ;
12739 int arg3 ;
12740 int arg4 ;
12741 int arg5 ;
12742 int arg6 ;
12743 int arg7 ;
12744 PyObject * obj0 = 0 ;
12745 PyObject * obj1 = 0 ;
12746 PyObject * obj2 = 0 ;
12747 PyObject * obj3 = 0 ;
12748 PyObject * obj4 = 0 ;
12749 PyObject * obj5 = 0 ;
12750 PyObject * obj6 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 arg2 = (int)(SWIG_As_int(obj1));
12760 if (SWIG_arg_fail(2)) SWIG_fail;
12761 }
12762 {
12763 arg3 = (int)(SWIG_As_int(obj2));
12764 if (SWIG_arg_fail(3)) SWIG_fail;
12765 }
12766 {
12767 arg4 = (int)(SWIG_As_int(obj3));
12768 if (SWIG_arg_fail(4)) SWIG_fail;
12769 }
12770 {
12771 arg5 = (int)(SWIG_As_int(obj4));
12772 if (SWIG_arg_fail(5)) SWIG_fail;
12773 }
12774 {
12775 arg6 = (int)(SWIG_As_int(obj5));
12776 if (SWIG_arg_fail(6)) SWIG_fail;
12777 }
12778 {
12779 arg7 = (int)(SWIG_As_int(obj6));
12780 if (SWIG_arg_fail(7)) SWIG_fail;
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12785
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 Py_INCREF(Py_None); resultobj = Py_None;
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj;
12798 wxDC *arg1 = (wxDC *) 0 ;
12799 wxPoint *arg2 = 0 ;
12800 wxPoint *arg3 = 0 ;
12801 wxPoint *arg4 = 0 ;
12802 wxPoint temp2 ;
12803 wxPoint temp3 ;
12804 wxPoint temp4 ;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 PyObject * obj2 = 0 ;
12808 PyObject * obj3 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 arg2 = &temp2;
12818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12819 }
12820 {
12821 arg3 = &temp3;
12822 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12823 }
12824 {
12825 arg4 = &temp4;
12826 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12827 }
12828 {
12829 PyThreadState* __tstate = wxPyBeginAllowThreads();
12830 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12831
12832 wxPyEndAllowThreads(__tstate);
12833 if (PyErr_Occurred()) SWIG_fail;
12834 }
12835 Py_INCREF(Py_None); resultobj = Py_None;
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj;
12844 wxDC *arg1 = (wxDC *) 0 ;
12845 int arg2 ;
12846 int arg3 ;
12847 int arg4 ;
12848 int arg5 ;
12849 PyObject * obj0 = 0 ;
12850 PyObject * obj1 = 0 ;
12851 PyObject * obj2 = 0 ;
12852 PyObject * obj3 = 0 ;
12853 PyObject * obj4 = 0 ;
12854 char *kwnames[] = {
12855 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12856 };
12857
12858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12860 if (SWIG_arg_fail(1)) SWIG_fail;
12861 {
12862 arg2 = (int)(SWIG_As_int(obj1));
12863 if (SWIG_arg_fail(2)) SWIG_fail;
12864 }
12865 {
12866 arg3 = (int)(SWIG_As_int(obj2));
12867 if (SWIG_arg_fail(3)) SWIG_fail;
12868 }
12869 {
12870 arg4 = (int)(SWIG_As_int(obj3));
12871 if (SWIG_arg_fail(4)) SWIG_fail;
12872 }
12873 {
12874 arg5 = (int)(SWIG_As_int(obj4));
12875 if (SWIG_arg_fail(5)) SWIG_fail;
12876 }
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12880
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 Py_INCREF(Py_None); resultobj = Py_None;
12885 return resultobj;
12886 fail:
12887 return NULL;
12888 }
12889
12890
12891 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12892 PyObject *resultobj;
12893 wxDC *arg1 = (wxDC *) 0 ;
12894 wxRect *arg2 = 0 ;
12895 wxRect temp2 ;
12896 PyObject * obj0 = 0 ;
12897 PyObject * obj1 = 0 ;
12898 char *kwnames[] = {
12899 (char *) "self",(char *) "rect", NULL
12900 };
12901
12902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12904 if (SWIG_arg_fail(1)) SWIG_fail;
12905 {
12906 arg2 = &temp2;
12907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12908 }
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 Py_INCREF(Py_None); resultobj = Py_None;
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj;
12925 wxDC *arg1 = (wxDC *) 0 ;
12926 int arg2 ;
12927 int arg3 ;
12928 int arg4 ;
12929 int arg5 ;
12930 double arg6 ;
12931 double arg7 ;
12932 PyObject * obj0 = 0 ;
12933 PyObject * obj1 = 0 ;
12934 PyObject * obj2 = 0 ;
12935 PyObject * obj3 = 0 ;
12936 PyObject * obj4 = 0 ;
12937 PyObject * obj5 = 0 ;
12938 PyObject * obj6 = 0 ;
12939 char *kwnames[] = {
12940 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12941 };
12942
12943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 arg2 = (int)(SWIG_As_int(obj1));
12948 if (SWIG_arg_fail(2)) SWIG_fail;
12949 }
12950 {
12951 arg3 = (int)(SWIG_As_int(obj2));
12952 if (SWIG_arg_fail(3)) SWIG_fail;
12953 }
12954 {
12955 arg4 = (int)(SWIG_As_int(obj3));
12956 if (SWIG_arg_fail(4)) SWIG_fail;
12957 }
12958 {
12959 arg5 = (int)(SWIG_As_int(obj4));
12960 if (SWIG_arg_fail(5)) SWIG_fail;
12961 }
12962 {
12963 arg6 = (double)(SWIG_As_double(obj5));
12964 if (SWIG_arg_fail(6)) SWIG_fail;
12965 }
12966 {
12967 arg7 = (double)(SWIG_As_double(obj6));
12968 if (SWIG_arg_fail(7)) SWIG_fail;
12969 }
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12973
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 Py_INCREF(Py_None); resultobj = Py_None;
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12985 PyObject *resultobj;
12986 wxDC *arg1 = (wxDC *) 0 ;
12987 wxPoint *arg2 = 0 ;
12988 wxSize *arg3 = 0 ;
12989 double arg4 ;
12990 double arg5 ;
12991 wxPoint temp2 ;
12992 wxSize temp3 ;
12993 PyObject * obj0 = 0 ;
12994 PyObject * obj1 = 0 ;
12995 PyObject * obj2 = 0 ;
12996 PyObject * obj3 = 0 ;
12997 PyObject * obj4 = 0 ;
12998 char *kwnames[] = {
12999 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13000 };
13001
13002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13004 if (SWIG_arg_fail(1)) SWIG_fail;
13005 {
13006 arg2 = &temp2;
13007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13008 }
13009 {
13010 arg3 = &temp3;
13011 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13012 }
13013 {
13014 arg4 = (double)(SWIG_As_double(obj3));
13015 if (SWIG_arg_fail(4)) SWIG_fail;
13016 }
13017 {
13018 arg5 = (double)(SWIG_As_double(obj4));
13019 if (SWIG_arg_fail(5)) SWIG_fail;
13020 }
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13024
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 Py_INCREF(Py_None); resultobj = Py_None;
13029 return resultobj;
13030 fail:
13031 return NULL;
13032 }
13033
13034
13035 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13036 PyObject *resultobj;
13037 wxDC *arg1 = (wxDC *) 0 ;
13038 int arg2 ;
13039 int arg3 ;
13040 PyObject * obj0 = 0 ;
13041 PyObject * obj1 = 0 ;
13042 PyObject * obj2 = 0 ;
13043 char *kwnames[] = {
13044 (char *) "self",(char *) "x",(char *) "y", NULL
13045 };
13046
13047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13049 if (SWIG_arg_fail(1)) SWIG_fail;
13050 {
13051 arg2 = (int)(SWIG_As_int(obj1));
13052 if (SWIG_arg_fail(2)) SWIG_fail;
13053 }
13054 {
13055 arg3 = (int)(SWIG_As_int(obj2));
13056 if (SWIG_arg_fail(3)) SWIG_fail;
13057 }
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 (arg1)->DrawPoint(arg2,arg3);
13061
13062 wxPyEndAllowThreads(__tstate);
13063 if (PyErr_Occurred()) SWIG_fail;
13064 }
13065 Py_INCREF(Py_None); resultobj = Py_None;
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj;
13074 wxDC *arg1 = (wxDC *) 0 ;
13075 wxPoint *arg2 = 0 ;
13076 wxPoint temp2 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 char *kwnames[] = {
13080 (char *) "self",(char *) "pt", NULL
13081 };
13082
13083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13085 if (SWIG_arg_fail(1)) SWIG_fail;
13086 {
13087 arg2 = &temp2;
13088 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 (arg1)->DrawPoint((wxPoint const &)*arg2);
13093
13094 wxPyEndAllowThreads(__tstate);
13095 if (PyErr_Occurred()) SWIG_fail;
13096 }
13097 Py_INCREF(Py_None); resultobj = Py_None;
13098 return resultobj;
13099 fail:
13100 return NULL;
13101 }
13102
13103
13104 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13105 PyObject *resultobj;
13106 wxDC *arg1 = (wxDC *) 0 ;
13107 int arg2 ;
13108 int arg3 ;
13109 int arg4 ;
13110 int arg5 ;
13111 PyObject * obj0 = 0 ;
13112 PyObject * obj1 = 0 ;
13113 PyObject * obj2 = 0 ;
13114 PyObject * obj3 = 0 ;
13115 PyObject * obj4 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 arg2 = (int)(SWIG_As_int(obj1));
13125 if (SWIG_arg_fail(2)) SWIG_fail;
13126 }
13127 {
13128 arg3 = (int)(SWIG_As_int(obj2));
13129 if (SWIG_arg_fail(3)) SWIG_fail;
13130 }
13131 {
13132 arg4 = (int)(SWIG_As_int(obj3));
13133 if (SWIG_arg_fail(4)) SWIG_fail;
13134 }
13135 {
13136 arg5 = (int)(SWIG_As_int(obj4));
13137 if (SWIG_arg_fail(5)) SWIG_fail;
13138 }
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13142
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 Py_INCREF(Py_None); resultobj = Py_None;
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13154 PyObject *resultobj;
13155 wxDC *arg1 = (wxDC *) 0 ;
13156 wxRect *arg2 = 0 ;
13157 wxRect temp2 ;
13158 PyObject * obj0 = 0 ;
13159 PyObject * obj1 = 0 ;
13160 char *kwnames[] = {
13161 (char *) "self",(char *) "rect", NULL
13162 };
13163
13164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13166 if (SWIG_arg_fail(1)) SWIG_fail;
13167 {
13168 arg2 = &temp2;
13169 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13170 }
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 (arg1)->DrawRectangle((wxRect const &)*arg2);
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 Py_INCREF(Py_None); resultobj = Py_None;
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj;
13187 wxDC *arg1 = (wxDC *) 0 ;
13188 wxPoint *arg2 = 0 ;
13189 wxSize *arg3 = 0 ;
13190 wxPoint temp2 ;
13191 wxSize temp3 ;
13192 PyObject * obj0 = 0 ;
13193 PyObject * obj1 = 0 ;
13194 PyObject * obj2 = 0 ;
13195 char *kwnames[] = {
13196 (char *) "self",(char *) "pt",(char *) "sz", NULL
13197 };
13198
13199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13201 if (SWIG_arg_fail(1)) SWIG_fail;
13202 {
13203 arg2 = &temp2;
13204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13205 }
13206 {
13207 arg3 = &temp3;
13208 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13209 }
13210 {
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13213
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 Py_INCREF(Py_None); resultobj = Py_None;
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13225 PyObject *resultobj;
13226 wxDC *arg1 = (wxDC *) 0 ;
13227 int arg2 ;
13228 int arg3 ;
13229 int arg4 ;
13230 int arg5 ;
13231 double arg6 ;
13232 PyObject * obj0 = 0 ;
13233 PyObject * obj1 = 0 ;
13234 PyObject * obj2 = 0 ;
13235 PyObject * obj3 = 0 ;
13236 PyObject * obj4 = 0 ;
13237 PyObject * obj5 = 0 ;
13238 char *kwnames[] = {
13239 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13240 };
13241
13242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13244 if (SWIG_arg_fail(1)) SWIG_fail;
13245 {
13246 arg2 = (int)(SWIG_As_int(obj1));
13247 if (SWIG_arg_fail(2)) SWIG_fail;
13248 }
13249 {
13250 arg3 = (int)(SWIG_As_int(obj2));
13251 if (SWIG_arg_fail(3)) SWIG_fail;
13252 }
13253 {
13254 arg4 = (int)(SWIG_As_int(obj3));
13255 if (SWIG_arg_fail(4)) SWIG_fail;
13256 }
13257 {
13258 arg5 = (int)(SWIG_As_int(obj4));
13259 if (SWIG_arg_fail(5)) SWIG_fail;
13260 }
13261 {
13262 arg6 = (double)(SWIG_As_double(obj5));
13263 if (SWIG_arg_fail(6)) SWIG_fail;
13264 }
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13268
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 Py_INCREF(Py_None); resultobj = Py_None;
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13280 PyObject *resultobj;
13281 wxDC *arg1 = (wxDC *) 0 ;
13282 wxRect *arg2 = 0 ;
13283 double arg3 ;
13284 wxRect temp2 ;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 PyObject * obj2 = 0 ;
13288 char *kwnames[] = {
13289 (char *) "self",(char *) "r",(char *) "radius", NULL
13290 };
13291
13292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13294 if (SWIG_arg_fail(1)) SWIG_fail;
13295 {
13296 arg2 = &temp2;
13297 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13298 }
13299 {
13300 arg3 = (double)(SWIG_As_double(obj2));
13301 if (SWIG_arg_fail(3)) SWIG_fail;
13302 }
13303 {
13304 PyThreadState* __tstate = wxPyBeginAllowThreads();
13305 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13306
13307 wxPyEndAllowThreads(__tstate);
13308 if (PyErr_Occurred()) SWIG_fail;
13309 }
13310 Py_INCREF(Py_None); resultobj = Py_None;
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj;
13319 wxDC *arg1 = (wxDC *) 0 ;
13320 wxPoint *arg2 = 0 ;
13321 wxSize *arg3 = 0 ;
13322 double arg4 ;
13323 wxPoint temp2 ;
13324 wxSize temp3 ;
13325 PyObject * obj0 = 0 ;
13326 PyObject * obj1 = 0 ;
13327 PyObject * obj2 = 0 ;
13328 PyObject * obj3 = 0 ;
13329 char *kwnames[] = {
13330 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13331 };
13332
13333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13335 if (SWIG_arg_fail(1)) SWIG_fail;
13336 {
13337 arg2 = &temp2;
13338 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13339 }
13340 {
13341 arg3 = &temp3;
13342 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13343 }
13344 {
13345 arg4 = (double)(SWIG_As_double(obj3));
13346 if (SWIG_arg_fail(4)) SWIG_fail;
13347 }
13348 {
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
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_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13363 PyObject *resultobj;
13364 wxDC *arg1 = (wxDC *) 0 ;
13365 int arg2 ;
13366 int arg3 ;
13367 int arg4 ;
13368 PyObject * obj0 = 0 ;
13369 PyObject * obj1 = 0 ;
13370 PyObject * obj2 = 0 ;
13371 PyObject * obj3 = 0 ;
13372 char *kwnames[] = {
13373 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13374 };
13375
13376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13378 if (SWIG_arg_fail(1)) SWIG_fail;
13379 {
13380 arg2 = (int)(SWIG_As_int(obj1));
13381 if (SWIG_arg_fail(2)) SWIG_fail;
13382 }
13383 {
13384 arg3 = (int)(SWIG_As_int(obj2));
13385 if (SWIG_arg_fail(3)) SWIG_fail;
13386 }
13387 {
13388 arg4 = (int)(SWIG_As_int(obj3));
13389 if (SWIG_arg_fail(4)) SWIG_fail;
13390 }
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 (arg1)->DrawCircle(arg2,arg3,arg4);
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 Py_INCREF(Py_None); resultobj = Py_None;
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj;
13407 wxDC *arg1 = (wxDC *) 0 ;
13408 wxPoint *arg2 = 0 ;
13409 int arg3 ;
13410 wxPoint temp2 ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 PyObject * obj2 = 0 ;
13414 char *kwnames[] = {
13415 (char *) "self",(char *) "pt",(char *) "radius", NULL
13416 };
13417
13418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13420 if (SWIG_arg_fail(1)) SWIG_fail;
13421 {
13422 arg2 = &temp2;
13423 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13424 }
13425 {
13426 arg3 = (int)(SWIG_As_int(obj2));
13427 if (SWIG_arg_fail(3)) SWIG_fail;
13428 }
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 Py_INCREF(Py_None); resultobj = Py_None;
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj;
13445 wxDC *arg1 = (wxDC *) 0 ;
13446 int arg2 ;
13447 int arg3 ;
13448 int arg4 ;
13449 int arg5 ;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 PyObject * obj2 = 0 ;
13453 PyObject * obj3 = 0 ;
13454 PyObject * obj4 = 0 ;
13455 char *kwnames[] = {
13456 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13457 };
13458
13459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13461 if (SWIG_arg_fail(1)) SWIG_fail;
13462 {
13463 arg2 = (int)(SWIG_As_int(obj1));
13464 if (SWIG_arg_fail(2)) SWIG_fail;
13465 }
13466 {
13467 arg3 = (int)(SWIG_As_int(obj2));
13468 if (SWIG_arg_fail(3)) SWIG_fail;
13469 }
13470 {
13471 arg4 = (int)(SWIG_As_int(obj3));
13472 if (SWIG_arg_fail(4)) SWIG_fail;
13473 }
13474 {
13475 arg5 = (int)(SWIG_As_int(obj4));
13476 if (SWIG_arg_fail(5)) SWIG_fail;
13477 }
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13481
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 Py_INCREF(Py_None); resultobj = Py_None;
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj;
13494 wxDC *arg1 = (wxDC *) 0 ;
13495 wxRect *arg2 = 0 ;
13496 wxRect temp2 ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 char *kwnames[] = {
13500 (char *) "self",(char *) "rect", NULL
13501 };
13502
13503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13505 if (SWIG_arg_fail(1)) SWIG_fail;
13506 {
13507 arg2 = &temp2;
13508 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13509 }
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 (arg1)->DrawEllipse((wxRect const &)*arg2);
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 Py_INCREF(Py_None); resultobj = Py_None;
13518 return resultobj;
13519 fail:
13520 return NULL;
13521 }
13522
13523
13524 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13525 PyObject *resultobj;
13526 wxDC *arg1 = (wxDC *) 0 ;
13527 wxPoint *arg2 = 0 ;
13528 wxSize *arg3 = 0 ;
13529 wxPoint temp2 ;
13530 wxSize temp3 ;
13531 PyObject * obj0 = 0 ;
13532 PyObject * obj1 = 0 ;
13533 PyObject * obj2 = 0 ;
13534 char *kwnames[] = {
13535 (char *) "self",(char *) "pt",(char *) "sz", NULL
13536 };
13537
13538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13540 if (SWIG_arg_fail(1)) SWIG_fail;
13541 {
13542 arg2 = &temp2;
13543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13544 }
13545 {
13546 arg3 = &temp3;
13547 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 Py_INCREF(Py_None); resultobj = Py_None;
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj;
13565 wxDC *arg1 = (wxDC *) 0 ;
13566 wxIcon *arg2 = 0 ;
13567 int arg3 ;
13568 int arg4 ;
13569 PyObject * obj0 = 0 ;
13570 PyObject * obj1 = 0 ;
13571 PyObject * obj2 = 0 ;
13572 PyObject * obj3 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13579 if (SWIG_arg_fail(1)) SWIG_fail;
13580 {
13581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13582 if (SWIG_arg_fail(2)) SWIG_fail;
13583 if (arg2 == NULL) {
13584 SWIG_null_ref("wxIcon");
13585 }
13586 if (SWIG_arg_fail(2)) SWIG_fail;
13587 }
13588 {
13589 arg3 = (int)(SWIG_As_int(obj2));
13590 if (SWIG_arg_fail(3)) SWIG_fail;
13591 }
13592 {
13593 arg4 = (int)(SWIG_As_int(obj3));
13594 if (SWIG_arg_fail(4)) SWIG_fail;
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 Py_INCREF(Py_None); resultobj = Py_None;
13604 return resultobj;
13605 fail:
13606 return NULL;
13607 }
13608
13609
13610 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj;
13612 wxDC *arg1 = (wxDC *) 0 ;
13613 wxIcon *arg2 = 0 ;
13614 wxPoint *arg3 = 0 ;
13615 wxPoint temp3 ;
13616 PyObject * obj0 = 0 ;
13617 PyObject * obj1 = 0 ;
13618 PyObject * obj2 = 0 ;
13619 char *kwnames[] = {
13620 (char *) "self",(char *) "icon",(char *) "pt", NULL
13621 };
13622
13623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13625 if (SWIG_arg_fail(1)) SWIG_fail;
13626 {
13627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13628 if (SWIG_arg_fail(2)) SWIG_fail;
13629 if (arg2 == NULL) {
13630 SWIG_null_ref("wxIcon");
13631 }
13632 if (SWIG_arg_fail(2)) SWIG_fail;
13633 }
13634 {
13635 arg3 = &temp3;
13636 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13637 }
13638 {
13639 PyThreadState* __tstate = wxPyBeginAllowThreads();
13640 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13641
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 Py_INCREF(Py_None); resultobj = Py_None;
13646 return resultobj;
13647 fail:
13648 return NULL;
13649 }
13650
13651
13652 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj;
13654 wxDC *arg1 = (wxDC *) 0 ;
13655 wxBitmap *arg2 = 0 ;
13656 int arg3 ;
13657 int arg4 ;
13658 bool arg5 = (bool) false ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 PyObject * obj2 = 0 ;
13662 PyObject * obj3 = 0 ;
13663 PyObject * obj4 = 0 ;
13664 char *kwnames[] = {
13665 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13666 };
13667
13668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13670 if (SWIG_arg_fail(1)) SWIG_fail;
13671 {
13672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13673 if (SWIG_arg_fail(2)) SWIG_fail;
13674 if (arg2 == NULL) {
13675 SWIG_null_ref("wxBitmap");
13676 }
13677 if (SWIG_arg_fail(2)) SWIG_fail;
13678 }
13679 {
13680 arg3 = (int)(SWIG_As_int(obj2));
13681 if (SWIG_arg_fail(3)) SWIG_fail;
13682 }
13683 {
13684 arg4 = (int)(SWIG_As_int(obj3));
13685 if (SWIG_arg_fail(4)) SWIG_fail;
13686 }
13687 if (obj4) {
13688 {
13689 arg5 = (bool)(SWIG_As_bool(obj4));
13690 if (SWIG_arg_fail(5)) SWIG_fail;
13691 }
13692 }
13693 {
13694 PyThreadState* __tstate = wxPyBeginAllowThreads();
13695 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13696
13697 wxPyEndAllowThreads(__tstate);
13698 if (PyErr_Occurred()) SWIG_fail;
13699 }
13700 Py_INCREF(Py_None); resultobj = Py_None;
13701 return resultobj;
13702 fail:
13703 return NULL;
13704 }
13705
13706
13707 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13708 PyObject *resultobj;
13709 wxDC *arg1 = (wxDC *) 0 ;
13710 wxBitmap *arg2 = 0 ;
13711 wxPoint *arg3 = 0 ;
13712 bool arg4 = (bool) false ;
13713 wxPoint temp3 ;
13714 PyObject * obj0 = 0 ;
13715 PyObject * obj1 = 0 ;
13716 PyObject * obj2 = 0 ;
13717 PyObject * obj3 = 0 ;
13718 char *kwnames[] = {
13719 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13720 };
13721
13722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13724 if (SWIG_arg_fail(1)) SWIG_fail;
13725 {
13726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13727 if (SWIG_arg_fail(2)) SWIG_fail;
13728 if (arg2 == NULL) {
13729 SWIG_null_ref("wxBitmap");
13730 }
13731 if (SWIG_arg_fail(2)) SWIG_fail;
13732 }
13733 {
13734 arg3 = &temp3;
13735 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13736 }
13737 if (obj3) {
13738 {
13739 arg4 = (bool)(SWIG_As_bool(obj3));
13740 if (SWIG_arg_fail(4)) SWIG_fail;
13741 }
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13746
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 Py_INCREF(Py_None); resultobj = Py_None;
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj;
13759 wxDC *arg1 = (wxDC *) 0 ;
13760 wxString *arg2 = 0 ;
13761 int arg3 ;
13762 int arg4 ;
13763 bool temp2 = false ;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 PyObject * obj2 = 0 ;
13767 PyObject * obj3 = 0 ;
13768 char *kwnames[] = {
13769 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13770 };
13771
13772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13774 if (SWIG_arg_fail(1)) SWIG_fail;
13775 {
13776 arg2 = wxString_in_helper(obj1);
13777 if (arg2 == NULL) SWIG_fail;
13778 temp2 = true;
13779 }
13780 {
13781 arg3 = (int)(SWIG_As_int(obj2));
13782 if (SWIG_arg_fail(3)) SWIG_fail;
13783 }
13784 {
13785 arg4 = (int)(SWIG_As_int(obj3));
13786 if (SWIG_arg_fail(4)) SWIG_fail;
13787 }
13788 {
13789 PyThreadState* __tstate = wxPyBeginAllowThreads();
13790 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13791
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 Py_INCREF(Py_None); resultobj = Py_None;
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 return resultobj;
13801 fail:
13802 {
13803 if (temp2)
13804 delete arg2;
13805 }
13806 return NULL;
13807 }
13808
13809
13810 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13811 PyObject *resultobj;
13812 wxDC *arg1 = (wxDC *) 0 ;
13813 wxString *arg2 = 0 ;
13814 wxPoint *arg3 = 0 ;
13815 bool temp2 = false ;
13816 wxPoint temp3 ;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 char *kwnames[] = {
13821 (char *) "self",(char *) "text",(char *) "pt", NULL
13822 };
13823
13824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13826 if (SWIG_arg_fail(1)) SWIG_fail;
13827 {
13828 arg2 = wxString_in_helper(obj1);
13829 if (arg2 == NULL) SWIG_fail;
13830 temp2 = true;
13831 }
13832 {
13833 arg3 = &temp3;
13834 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 Py_INCREF(Py_None); resultobj = Py_None;
13844 {
13845 if (temp2)
13846 delete arg2;
13847 }
13848 return resultobj;
13849 fail:
13850 {
13851 if (temp2)
13852 delete arg2;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxDC *arg1 = (wxDC *) 0 ;
13861 wxString *arg2 = 0 ;
13862 int arg3 ;
13863 int arg4 ;
13864 double arg5 ;
13865 bool temp2 = false ;
13866 PyObject * obj0 = 0 ;
13867 PyObject * obj1 = 0 ;
13868 PyObject * obj2 = 0 ;
13869 PyObject * obj3 = 0 ;
13870 PyObject * obj4 = 0 ;
13871 char *kwnames[] = {
13872 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13873 };
13874
13875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13877 if (SWIG_arg_fail(1)) SWIG_fail;
13878 {
13879 arg2 = wxString_in_helper(obj1);
13880 if (arg2 == NULL) SWIG_fail;
13881 temp2 = true;
13882 }
13883 {
13884 arg3 = (int)(SWIG_As_int(obj2));
13885 if (SWIG_arg_fail(3)) SWIG_fail;
13886 }
13887 {
13888 arg4 = (int)(SWIG_As_int(obj3));
13889 if (SWIG_arg_fail(4)) SWIG_fail;
13890 }
13891 {
13892 arg5 = (double)(SWIG_As_double(obj4));
13893 if (SWIG_arg_fail(5)) SWIG_fail;
13894 }
13895 {
13896 PyThreadState* __tstate = wxPyBeginAllowThreads();
13897 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13898
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 Py_INCREF(Py_None); resultobj = Py_None;
13903 {
13904 if (temp2)
13905 delete arg2;
13906 }
13907 return resultobj;
13908 fail:
13909 {
13910 if (temp2)
13911 delete arg2;
13912 }
13913 return NULL;
13914 }
13915
13916
13917 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj;
13919 wxDC *arg1 = (wxDC *) 0 ;
13920 wxString *arg2 = 0 ;
13921 wxPoint *arg3 = 0 ;
13922 double arg4 ;
13923 bool temp2 = false ;
13924 wxPoint temp3 ;
13925 PyObject * obj0 = 0 ;
13926 PyObject * obj1 = 0 ;
13927 PyObject * obj2 = 0 ;
13928 PyObject * obj3 = 0 ;
13929 char *kwnames[] = {
13930 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13931 };
13932
13933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13935 if (SWIG_arg_fail(1)) SWIG_fail;
13936 {
13937 arg2 = wxString_in_helper(obj1);
13938 if (arg2 == NULL) SWIG_fail;
13939 temp2 = true;
13940 }
13941 {
13942 arg3 = &temp3;
13943 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13944 }
13945 {
13946 arg4 = (double)(SWIG_As_double(obj3));
13947 if (SWIG_arg_fail(4)) SWIG_fail;
13948 }
13949 {
13950 PyThreadState* __tstate = wxPyBeginAllowThreads();
13951 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13952
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 Py_INCREF(Py_None); resultobj = Py_None;
13957 {
13958 if (temp2)
13959 delete arg2;
13960 }
13961 return resultobj;
13962 fail:
13963 {
13964 if (temp2)
13965 delete arg2;
13966 }
13967 return NULL;
13968 }
13969
13970
13971 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13972 PyObject *resultobj;
13973 wxDC *arg1 = (wxDC *) 0 ;
13974 int arg2 ;
13975 int arg3 ;
13976 int arg4 ;
13977 int arg5 ;
13978 wxDC *arg6 = (wxDC *) 0 ;
13979 int arg7 ;
13980 int arg8 ;
13981 int arg9 = (int) wxCOPY ;
13982 bool arg10 = (bool) false ;
13983 int arg11 = (int) -1 ;
13984 int arg12 = (int) -1 ;
13985 bool result;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 PyObject * obj2 = 0 ;
13989 PyObject * obj3 = 0 ;
13990 PyObject * obj4 = 0 ;
13991 PyObject * obj5 = 0 ;
13992 PyObject * obj6 = 0 ;
13993 PyObject * obj7 = 0 ;
13994 PyObject * obj8 = 0 ;
13995 PyObject * obj9 = 0 ;
13996 PyObject * obj10 = 0 ;
13997 PyObject * obj11 = 0 ;
13998 char *kwnames[] = {
13999 (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
14000 };
14001
14002 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;
14003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14004 if (SWIG_arg_fail(1)) SWIG_fail;
14005 {
14006 arg2 = (int)(SWIG_As_int(obj1));
14007 if (SWIG_arg_fail(2)) SWIG_fail;
14008 }
14009 {
14010 arg3 = (int)(SWIG_As_int(obj2));
14011 if (SWIG_arg_fail(3)) SWIG_fail;
14012 }
14013 {
14014 arg4 = (int)(SWIG_As_int(obj3));
14015 if (SWIG_arg_fail(4)) SWIG_fail;
14016 }
14017 {
14018 arg5 = (int)(SWIG_As_int(obj4));
14019 if (SWIG_arg_fail(5)) SWIG_fail;
14020 }
14021 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14022 if (SWIG_arg_fail(6)) SWIG_fail;
14023 {
14024 arg7 = (int)(SWIG_As_int(obj6));
14025 if (SWIG_arg_fail(7)) SWIG_fail;
14026 }
14027 {
14028 arg8 = (int)(SWIG_As_int(obj7));
14029 if (SWIG_arg_fail(8)) SWIG_fail;
14030 }
14031 if (obj8) {
14032 {
14033 arg9 = (int)(SWIG_As_int(obj8));
14034 if (SWIG_arg_fail(9)) SWIG_fail;
14035 }
14036 }
14037 if (obj9) {
14038 {
14039 arg10 = (bool)(SWIG_As_bool(obj9));
14040 if (SWIG_arg_fail(10)) SWIG_fail;
14041 }
14042 }
14043 if (obj10) {
14044 {
14045 arg11 = (int)(SWIG_As_int(obj10));
14046 if (SWIG_arg_fail(11)) SWIG_fail;
14047 }
14048 }
14049 if (obj11) {
14050 {
14051 arg12 = (int)(SWIG_As_int(obj11));
14052 if (SWIG_arg_fail(12)) SWIG_fail;
14053 }
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14058
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 {
14063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxDC *arg1 = (wxDC *) 0 ;
14074 wxPoint *arg2 = 0 ;
14075 wxSize *arg3 = 0 ;
14076 wxDC *arg4 = (wxDC *) 0 ;
14077 wxPoint *arg5 = 0 ;
14078 int arg6 = (int) wxCOPY ;
14079 bool arg7 = (bool) false ;
14080 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14081 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14082 bool result;
14083 wxPoint temp2 ;
14084 wxSize temp3 ;
14085 wxPoint temp5 ;
14086 wxPoint temp8 ;
14087 PyObject * obj0 = 0 ;
14088 PyObject * obj1 = 0 ;
14089 PyObject * obj2 = 0 ;
14090 PyObject * obj3 = 0 ;
14091 PyObject * obj4 = 0 ;
14092 PyObject * obj5 = 0 ;
14093 PyObject * obj6 = 0 ;
14094 PyObject * obj7 = 0 ;
14095 char *kwnames[] = {
14096 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14097 };
14098
14099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14101 if (SWIG_arg_fail(1)) SWIG_fail;
14102 {
14103 arg2 = &temp2;
14104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14105 }
14106 {
14107 arg3 = &temp3;
14108 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14109 }
14110 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14111 if (SWIG_arg_fail(4)) SWIG_fail;
14112 {
14113 arg5 = &temp5;
14114 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14115 }
14116 if (obj5) {
14117 {
14118 arg6 = (int)(SWIG_As_int(obj5));
14119 if (SWIG_arg_fail(6)) SWIG_fail;
14120 }
14121 }
14122 if (obj6) {
14123 {
14124 arg7 = (bool)(SWIG_As_bool(obj6));
14125 if (SWIG_arg_fail(7)) SWIG_fail;
14126 }
14127 }
14128 if (obj7) {
14129 {
14130 arg8 = &temp8;
14131 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14132 }
14133 }
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxDC *arg1 = (wxDC *) 0 ;
14153 int arg2 ;
14154 int arg3 ;
14155 int arg4 ;
14156 int arg5 ;
14157 PyObject * obj0 = 0 ;
14158 PyObject * obj1 = 0 ;
14159 PyObject * obj2 = 0 ;
14160 PyObject * obj3 = 0 ;
14161 PyObject * obj4 = 0 ;
14162 char *kwnames[] = {
14163 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14164 };
14165
14166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14168 if (SWIG_arg_fail(1)) SWIG_fail;
14169 {
14170 arg2 = (int)(SWIG_As_int(obj1));
14171 if (SWIG_arg_fail(2)) SWIG_fail;
14172 }
14173 {
14174 arg3 = (int)(SWIG_As_int(obj2));
14175 if (SWIG_arg_fail(3)) SWIG_fail;
14176 }
14177 {
14178 arg4 = (int)(SWIG_As_int(obj3));
14179 if (SWIG_arg_fail(4)) SWIG_fail;
14180 }
14181 {
14182 arg5 = (int)(SWIG_As_int(obj4));
14183 if (SWIG_arg_fail(5)) SWIG_fail;
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14188
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 Py_INCREF(Py_None); resultobj = Py_None;
14193 return resultobj;
14194 fail:
14195 return NULL;
14196 }
14197
14198
14199 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14200 PyObject *resultobj;
14201 wxDC *arg1 = (wxDC *) 0 ;
14202 wxPoint *arg2 = 0 ;
14203 wxSize *arg3 = 0 ;
14204 wxPoint temp2 ;
14205 wxSize temp3 ;
14206 PyObject * obj0 = 0 ;
14207 PyObject * obj1 = 0 ;
14208 PyObject * obj2 = 0 ;
14209 char *kwnames[] = {
14210 (char *) "self",(char *) "pt",(char *) "sz", NULL
14211 };
14212
14213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14215 if (SWIG_arg_fail(1)) SWIG_fail;
14216 {
14217 arg2 = &temp2;
14218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14219 }
14220 {
14221 arg3 = &temp3;
14222 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14223 }
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14227
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 Py_INCREF(Py_None); resultobj = Py_None;
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj;
14240 wxDC *arg1 = (wxDC *) 0 ;
14241 wxRegion *arg2 = 0 ;
14242 PyObject * obj0 = 0 ;
14243 PyObject * obj1 = 0 ;
14244 char *kwnames[] = {
14245 (char *) "self",(char *) "region", NULL
14246 };
14247
14248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14250 if (SWIG_arg_fail(1)) SWIG_fail;
14251 {
14252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(2)) SWIG_fail;
14254 if (arg2 == NULL) {
14255 SWIG_null_ref("wxRegion");
14256 }
14257 if (SWIG_arg_fail(2)) SWIG_fail;
14258 }
14259 {
14260 PyThreadState* __tstate = wxPyBeginAllowThreads();
14261 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
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_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj;
14275 wxDC *arg1 = (wxDC *) 0 ;
14276 wxRect *arg2 = 0 ;
14277 wxRect temp2 ;
14278 PyObject * obj0 = 0 ;
14279 PyObject * obj1 = 0 ;
14280 char *kwnames[] = {
14281 (char *) "self",(char *) "rect", NULL
14282 };
14283
14284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14286 if (SWIG_arg_fail(1)) SWIG_fail;
14287 {
14288 arg2 = &temp2;
14289 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14290 }
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 Py_INCREF(Py_None); resultobj = Py_None;
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxDC *arg1 = (wxDC *) 0 ;
14308 int arg2 ;
14309 wxPoint *arg3 = (wxPoint *) 0 ;
14310 int arg4 = (int) 0 ;
14311 int arg5 = (int) 0 ;
14312 PyObject * obj0 = 0 ;
14313 PyObject * obj1 = 0 ;
14314 PyObject * obj2 = 0 ;
14315 PyObject * obj3 = 0 ;
14316 char *kwnames[] = {
14317 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14318 };
14319
14320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14322 if (SWIG_arg_fail(1)) SWIG_fail;
14323 {
14324 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14325 if (arg3 == NULL) SWIG_fail;
14326 }
14327 if (obj2) {
14328 {
14329 arg4 = (int)(SWIG_As_int(obj2));
14330 if (SWIG_arg_fail(4)) SWIG_fail;
14331 }
14332 }
14333 if (obj3) {
14334 {
14335 arg5 = (int)(SWIG_As_int(obj3));
14336 if (SWIG_arg_fail(5)) SWIG_fail;
14337 }
14338 }
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14342
14343 wxPyEndAllowThreads(__tstate);
14344 if (PyErr_Occurred()) SWIG_fail;
14345 }
14346 Py_INCREF(Py_None); resultobj = Py_None;
14347 {
14348 if (arg3) delete [] arg3;
14349 }
14350 return resultobj;
14351 fail:
14352 {
14353 if (arg3) delete [] arg3;
14354 }
14355 return NULL;
14356 }
14357
14358
14359 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14360 PyObject *resultobj;
14361 wxDC *arg1 = (wxDC *) 0 ;
14362 int arg2 ;
14363 wxPoint *arg3 = (wxPoint *) 0 ;
14364 int arg4 = (int) 0 ;
14365 int arg5 = (int) 0 ;
14366 int arg6 = (int) wxODDEVEN_RULE ;
14367 PyObject * obj0 = 0 ;
14368 PyObject * obj1 = 0 ;
14369 PyObject * obj2 = 0 ;
14370 PyObject * obj3 = 0 ;
14371 PyObject * obj4 = 0 ;
14372 char *kwnames[] = {
14373 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14374 };
14375
14376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14378 if (SWIG_arg_fail(1)) SWIG_fail;
14379 {
14380 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14381 if (arg3 == NULL) SWIG_fail;
14382 }
14383 if (obj2) {
14384 {
14385 arg4 = (int)(SWIG_As_int(obj2));
14386 if (SWIG_arg_fail(4)) SWIG_fail;
14387 }
14388 }
14389 if (obj3) {
14390 {
14391 arg5 = (int)(SWIG_As_int(obj3));
14392 if (SWIG_arg_fail(5)) SWIG_fail;
14393 }
14394 }
14395 if (obj4) {
14396 {
14397 arg6 = (int)(SWIG_As_int(obj4));
14398 if (SWIG_arg_fail(6)) SWIG_fail;
14399 }
14400 }
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14404
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 Py_INCREF(Py_None); resultobj = Py_None;
14409 {
14410 if (arg3) delete [] arg3;
14411 }
14412 return resultobj;
14413 fail:
14414 {
14415 if (arg3) delete [] arg3;
14416 }
14417 return NULL;
14418 }
14419
14420
14421 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj;
14423 wxDC *arg1 = (wxDC *) 0 ;
14424 wxString *arg2 = 0 ;
14425 wxRect *arg3 = 0 ;
14426 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14427 int arg5 = (int) -1 ;
14428 bool temp2 = false ;
14429 wxRect temp3 ;
14430 PyObject * obj0 = 0 ;
14431 PyObject * obj1 = 0 ;
14432 PyObject * obj2 = 0 ;
14433 PyObject * obj3 = 0 ;
14434 PyObject * obj4 = 0 ;
14435 char *kwnames[] = {
14436 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14441 if (SWIG_arg_fail(1)) SWIG_fail;
14442 {
14443 arg2 = wxString_in_helper(obj1);
14444 if (arg2 == NULL) SWIG_fail;
14445 temp2 = true;
14446 }
14447 {
14448 arg3 = &temp3;
14449 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14450 }
14451 if (obj3) {
14452 {
14453 arg4 = (int)(SWIG_As_int(obj3));
14454 if (SWIG_arg_fail(4)) SWIG_fail;
14455 }
14456 }
14457 if (obj4) {
14458 {
14459 arg5 = (int)(SWIG_As_int(obj4));
14460 if (SWIG_arg_fail(5)) SWIG_fail;
14461 }
14462 }
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14466
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 Py_INCREF(Py_None); resultobj = Py_None;
14471 {
14472 if (temp2)
14473 delete arg2;
14474 }
14475 return resultobj;
14476 fail:
14477 {
14478 if (temp2)
14479 delete arg2;
14480 }
14481 return NULL;
14482 }
14483
14484
14485 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14486 PyObject *resultobj;
14487 wxDC *arg1 = (wxDC *) 0 ;
14488 wxString *arg2 = 0 ;
14489 wxBitmap *arg3 = 0 ;
14490 wxRect *arg4 = 0 ;
14491 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14492 int arg6 = (int) -1 ;
14493 wxRect result;
14494 bool temp2 = false ;
14495 wxRect temp4 ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 PyObject * obj2 = 0 ;
14499 PyObject * obj3 = 0 ;
14500 PyObject * obj4 = 0 ;
14501 PyObject * obj5 = 0 ;
14502 char *kwnames[] = {
14503 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14504 };
14505
14506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14508 if (SWIG_arg_fail(1)) SWIG_fail;
14509 {
14510 arg2 = wxString_in_helper(obj1);
14511 if (arg2 == NULL) SWIG_fail;
14512 temp2 = true;
14513 }
14514 {
14515 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14516 if (SWIG_arg_fail(3)) SWIG_fail;
14517 if (arg3 == NULL) {
14518 SWIG_null_ref("wxBitmap");
14519 }
14520 if (SWIG_arg_fail(3)) SWIG_fail;
14521 }
14522 {
14523 arg4 = &temp4;
14524 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14525 }
14526 if (obj4) {
14527 {
14528 arg5 = (int)(SWIG_As_int(obj4));
14529 if (SWIG_arg_fail(5)) SWIG_fail;
14530 }
14531 }
14532 if (obj5) {
14533 {
14534 arg6 = (int)(SWIG_As_int(obj5));
14535 if (SWIG_arg_fail(6)) SWIG_fail;
14536 }
14537 }
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 {
14546 wxRect * resultptr;
14547 resultptr = new wxRect((wxRect &)(result));
14548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14549 }
14550 {
14551 if (temp2)
14552 delete arg2;
14553 }
14554 return resultobj;
14555 fail:
14556 {
14557 if (temp2)
14558 delete arg2;
14559 }
14560 return NULL;
14561 }
14562
14563
14564 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14565 PyObject *resultobj;
14566 wxDC *arg1 = (wxDC *) 0 ;
14567 int arg2 ;
14568 wxPoint *arg3 = (wxPoint *) 0 ;
14569 PyObject * obj0 = 0 ;
14570 PyObject * obj1 = 0 ;
14571 char *kwnames[] = {
14572 (char *) "self",(char *) "points", NULL
14573 };
14574
14575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14577 if (SWIG_arg_fail(1)) SWIG_fail;
14578 {
14579 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14580 if (arg3 == NULL) SWIG_fail;
14581 }
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 (arg1)->DrawSpline(arg2,arg3);
14585
14586 wxPyEndAllowThreads(__tstate);
14587 if (PyErr_Occurred()) SWIG_fail;
14588 }
14589 Py_INCREF(Py_None); resultobj = Py_None;
14590 {
14591 if (arg3) delete [] arg3;
14592 }
14593 return resultobj;
14594 fail:
14595 {
14596 if (arg3) delete [] arg3;
14597 }
14598 return NULL;
14599 }
14600
14601
14602 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj;
14604 wxDC *arg1 = (wxDC *) 0 ;
14605 PyObject * obj0 = 0 ;
14606 char *kwnames[] = {
14607 (char *) "self", NULL
14608 };
14609
14610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14612 if (SWIG_arg_fail(1)) SWIG_fail;
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 (arg1)->Clear();
14616
14617 wxPyEndAllowThreads(__tstate);
14618 if (PyErr_Occurred()) SWIG_fail;
14619 }
14620 Py_INCREF(Py_None); resultobj = Py_None;
14621 return resultobj;
14622 fail:
14623 return NULL;
14624 }
14625
14626
14627 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14628 PyObject *resultobj;
14629 wxDC *arg1 = (wxDC *) 0 ;
14630 wxString *arg2 = 0 ;
14631 bool result;
14632 bool temp2 = false ;
14633 PyObject * obj0 = 0 ;
14634 PyObject * obj1 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "self",(char *) "message", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(1)) SWIG_fail;
14642 {
14643 arg2 = wxString_in_helper(obj1);
14644 if (arg2 == NULL) SWIG_fail;
14645 temp2 = true;
14646 }
14647 {
14648 PyThreadState* __tstate = wxPyBeginAllowThreads();
14649 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14650
14651 wxPyEndAllowThreads(__tstate);
14652 if (PyErr_Occurred()) SWIG_fail;
14653 }
14654 {
14655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14656 }
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp2)
14665 delete arg2;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj;
14673 wxDC *arg1 = (wxDC *) 0 ;
14674 PyObject * obj0 = 0 ;
14675 char *kwnames[] = {
14676 (char *) "self", NULL
14677 };
14678
14679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(1)) SWIG_fail;
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 (arg1)->EndDoc();
14685
14686 wxPyEndAllowThreads(__tstate);
14687 if (PyErr_Occurred()) SWIG_fail;
14688 }
14689 Py_INCREF(Py_None); resultobj = Py_None;
14690 return resultobj;
14691 fail:
14692 return NULL;
14693 }
14694
14695
14696 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14697 PyObject *resultobj;
14698 wxDC *arg1 = (wxDC *) 0 ;
14699 PyObject * obj0 = 0 ;
14700 char *kwnames[] = {
14701 (char *) "self", NULL
14702 };
14703
14704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14706 if (SWIG_arg_fail(1)) SWIG_fail;
14707 {
14708 PyThreadState* __tstate = wxPyBeginAllowThreads();
14709 (arg1)->StartPage();
14710
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 Py_INCREF(Py_None); resultobj = Py_None;
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14722 PyObject *resultobj;
14723 wxDC *arg1 = (wxDC *) 0 ;
14724 PyObject * obj0 = 0 ;
14725 char *kwnames[] = {
14726 (char *) "self", NULL
14727 };
14728
14729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14731 if (SWIG_arg_fail(1)) SWIG_fail;
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 (arg1)->EndPage();
14735
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 Py_INCREF(Py_None); resultobj = Py_None;
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj;
14748 wxDC *arg1 = (wxDC *) 0 ;
14749 wxFont *arg2 = 0 ;
14750 PyObject * obj0 = 0 ;
14751 PyObject * obj1 = 0 ;
14752 char *kwnames[] = {
14753 (char *) "self",(char *) "font", NULL
14754 };
14755
14756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14758 if (SWIG_arg_fail(1)) SWIG_fail;
14759 {
14760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14761 if (SWIG_arg_fail(2)) SWIG_fail;
14762 if (arg2 == NULL) {
14763 SWIG_null_ref("wxFont");
14764 }
14765 if (SWIG_arg_fail(2)) SWIG_fail;
14766 }
14767 {
14768 PyThreadState* __tstate = wxPyBeginAllowThreads();
14769 (arg1)->SetFont((wxFont const &)*arg2);
14770
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 Py_INCREF(Py_None); resultobj = Py_None;
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14782 PyObject *resultobj;
14783 wxDC *arg1 = (wxDC *) 0 ;
14784 wxPen *arg2 = 0 ;
14785 PyObject * obj0 = 0 ;
14786 PyObject * obj1 = 0 ;
14787 char *kwnames[] = {
14788 (char *) "self",(char *) "pen", NULL
14789 };
14790
14791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14793 if (SWIG_arg_fail(1)) SWIG_fail;
14794 {
14795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14796 if (SWIG_arg_fail(2)) SWIG_fail;
14797 if (arg2 == NULL) {
14798 SWIG_null_ref("wxPen");
14799 }
14800 if (SWIG_arg_fail(2)) SWIG_fail;
14801 }
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 (arg1)->SetPen((wxPen const &)*arg2);
14805
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 Py_INCREF(Py_None); resultobj = Py_None;
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj;
14818 wxDC *arg1 = (wxDC *) 0 ;
14819 wxBrush *arg2 = 0 ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 char *kwnames[] = {
14823 (char *) "self",(char *) "brush", NULL
14824 };
14825
14826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14828 if (SWIG_arg_fail(1)) SWIG_fail;
14829 {
14830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(2)) SWIG_fail;
14832 if (arg2 == NULL) {
14833 SWIG_null_ref("wxBrush");
14834 }
14835 if (SWIG_arg_fail(2)) SWIG_fail;
14836 }
14837 {
14838 PyThreadState* __tstate = wxPyBeginAllowThreads();
14839 (arg1)->SetBrush((wxBrush const &)*arg2);
14840
14841 wxPyEndAllowThreads(__tstate);
14842 if (PyErr_Occurred()) SWIG_fail;
14843 }
14844 Py_INCREF(Py_None); resultobj = Py_None;
14845 return resultobj;
14846 fail:
14847 return NULL;
14848 }
14849
14850
14851 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14852 PyObject *resultobj;
14853 wxDC *arg1 = (wxDC *) 0 ;
14854 wxBrush *arg2 = 0 ;
14855 PyObject * obj0 = 0 ;
14856 PyObject * obj1 = 0 ;
14857 char *kwnames[] = {
14858 (char *) "self",(char *) "brush", NULL
14859 };
14860
14861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14863 if (SWIG_arg_fail(1)) SWIG_fail;
14864 {
14865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14866 if (SWIG_arg_fail(2)) SWIG_fail;
14867 if (arg2 == NULL) {
14868 SWIG_null_ref("wxBrush");
14869 }
14870 if (SWIG_arg_fail(2)) SWIG_fail;
14871 }
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 (arg1)->SetBackground((wxBrush const &)*arg2);
14875
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 Py_INCREF(Py_None); resultobj = Py_None;
14880 return resultobj;
14881 fail:
14882 return NULL;
14883 }
14884
14885
14886 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj;
14888 wxDC *arg1 = (wxDC *) 0 ;
14889 int arg2 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 char *kwnames[] = {
14893 (char *) "self",(char *) "mode", NULL
14894 };
14895
14896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14898 if (SWIG_arg_fail(1)) SWIG_fail;
14899 {
14900 arg2 = (int)(SWIG_As_int(obj1));
14901 if (SWIG_arg_fail(2)) SWIG_fail;
14902 }
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 (arg1)->SetBackgroundMode(arg2);
14906
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 Py_INCREF(Py_None); resultobj = Py_None;
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj;
14919 wxDC *arg1 = (wxDC *) 0 ;
14920 wxPalette *arg2 = 0 ;
14921 PyObject * obj0 = 0 ;
14922 PyObject * obj1 = 0 ;
14923 char *kwnames[] = {
14924 (char *) "self",(char *) "palette", NULL
14925 };
14926
14927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14929 if (SWIG_arg_fail(1)) SWIG_fail;
14930 {
14931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14932 if (SWIG_arg_fail(2)) SWIG_fail;
14933 if (arg2 == NULL) {
14934 SWIG_null_ref("wxPalette");
14935 }
14936 if (SWIG_arg_fail(2)) SWIG_fail;
14937 }
14938 {
14939 PyThreadState* __tstate = wxPyBeginAllowThreads();
14940 (arg1)->SetPalette((wxPalette const &)*arg2);
14941
14942 wxPyEndAllowThreads(__tstate);
14943 if (PyErr_Occurred()) SWIG_fail;
14944 }
14945 Py_INCREF(Py_None); resultobj = Py_None;
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxDC *arg1 = (wxDC *) 0 ;
14955 PyObject * obj0 = 0 ;
14956 char *kwnames[] = {
14957 (char *) "self", NULL
14958 };
14959
14960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14962 if (SWIG_arg_fail(1)) SWIG_fail;
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 (arg1)->DestroyClippingRegion();
14966
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 Py_INCREF(Py_None); resultobj = Py_None;
14971 return resultobj;
14972 fail:
14973 return NULL;
14974 }
14975
14976
14977 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14978 PyObject *resultobj;
14979 wxDC *arg1 = (wxDC *) 0 ;
14980 int *arg2 = (int *) 0 ;
14981 int *arg3 = (int *) 0 ;
14982 int *arg4 = (int *) 0 ;
14983 int *arg5 = (int *) 0 ;
14984 int temp2 ;
14985 int res2 = 0 ;
14986 int temp3 ;
14987 int res3 = 0 ;
14988 int temp4 ;
14989 int res4 = 0 ;
14990 int temp5 ;
14991 int res5 = 0 ;
14992 PyObject * obj0 = 0 ;
14993 char *kwnames[] = {
14994 (char *) "self", NULL
14995 };
14996
14997 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14998 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14999 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15000 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15003 if (SWIG_arg_fail(1)) SWIG_fail;
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15007
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 Py_INCREF(Py_None); resultobj = Py_None;
15012 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15013 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15014 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15015 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15016 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15017 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15018 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15019 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15027 PyObject *resultobj;
15028 wxDC *arg1 = (wxDC *) 0 ;
15029 wxRect result;
15030 PyObject * obj0 = 0 ;
15031 char *kwnames[] = {
15032 (char *) "self", NULL
15033 };
15034
15035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15037 if (SWIG_arg_fail(1)) SWIG_fail;
15038 {
15039 PyThreadState* __tstate = wxPyBeginAllowThreads();
15040 result = wxDC_GetClippingRect(arg1);
15041
15042 wxPyEndAllowThreads(__tstate);
15043 if (PyErr_Occurred()) SWIG_fail;
15044 }
15045 {
15046 wxRect * resultptr;
15047 resultptr = new wxRect((wxRect &)(result));
15048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15049 }
15050 return resultobj;
15051 fail:
15052 return NULL;
15053 }
15054
15055
15056 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15057 PyObject *resultobj;
15058 wxDC *arg1 = (wxDC *) 0 ;
15059 int result;
15060 PyObject * obj0 = 0 ;
15061 char *kwnames[] = {
15062 (char *) "self", NULL
15063 };
15064
15065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15067 if (SWIG_arg_fail(1)) SWIG_fail;
15068 {
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = (int)((wxDC const *)arg1)->GetCharHeight();
15071
15072 wxPyEndAllowThreads(__tstate);
15073 if (PyErr_Occurred()) SWIG_fail;
15074 }
15075 {
15076 resultobj = SWIG_From_int((int)(result));
15077 }
15078 return resultobj;
15079 fail:
15080 return NULL;
15081 }
15082
15083
15084 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15085 PyObject *resultobj;
15086 wxDC *arg1 = (wxDC *) 0 ;
15087 int result;
15088 PyObject * obj0 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "self", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(1)) SWIG_fail;
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 result = (int)((wxDC const *)arg1)->GetCharWidth();
15099
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 {
15104 resultobj = SWIG_From_int((int)(result));
15105 }
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj;
15114 wxDC *arg1 = (wxDC *) 0 ;
15115 wxString *arg2 = 0 ;
15116 int *arg3 = (int *) 0 ;
15117 int *arg4 = (int *) 0 ;
15118 bool temp2 = false ;
15119 int temp3 ;
15120 int res3 = 0 ;
15121 int temp4 ;
15122 int res4 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self",(char *) "string", NULL
15127 };
15128
15129 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15130 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15133 if (SWIG_arg_fail(1)) SWIG_fail;
15134 {
15135 arg2 = wxString_in_helper(obj1);
15136 if (arg2 == NULL) SWIG_fail;
15137 temp2 = true;
15138 }
15139 {
15140 PyThreadState* __tstate = wxPyBeginAllowThreads();
15141 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15142
15143 wxPyEndAllowThreads(__tstate);
15144 if (PyErr_Occurred()) SWIG_fail;
15145 }
15146 Py_INCREF(Py_None); resultobj = Py_None;
15147 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15148 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15149 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15150 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15151 {
15152 if (temp2)
15153 delete arg2;
15154 }
15155 return resultobj;
15156 fail:
15157 {
15158 if (temp2)
15159 delete arg2;
15160 }
15161 return NULL;
15162 }
15163
15164
15165 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15166 PyObject *resultobj;
15167 wxDC *arg1 = (wxDC *) 0 ;
15168 wxString *arg2 = 0 ;
15169 int *arg3 = (int *) 0 ;
15170 int *arg4 = (int *) 0 ;
15171 int *arg5 = (int *) 0 ;
15172 int *arg6 = (int *) 0 ;
15173 wxFont *arg7 = (wxFont *) NULL ;
15174 bool temp2 = false ;
15175 int temp3 ;
15176 int res3 = 0 ;
15177 int temp4 ;
15178 int res4 = 0 ;
15179 int temp5 ;
15180 int res5 = 0 ;
15181 int temp6 ;
15182 int res6 = 0 ;
15183 PyObject * obj0 = 0 ;
15184 PyObject * obj1 = 0 ;
15185 PyObject * obj2 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self",(char *) "string",(char *) "font", NULL
15188 };
15189
15190 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15191 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15192 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15193 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15196 if (SWIG_arg_fail(1)) SWIG_fail;
15197 {
15198 arg2 = wxString_in_helper(obj1);
15199 if (arg2 == NULL) SWIG_fail;
15200 temp2 = true;
15201 }
15202 if (obj2) {
15203 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15204 if (SWIG_arg_fail(7)) SWIG_fail;
15205 }
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15209
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 Py_INCREF(Py_None); resultobj = Py_None;
15214 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15215 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15216 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15217 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15218 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15219 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15220 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15221 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15222 {
15223 if (temp2)
15224 delete arg2;
15225 }
15226 return resultobj;
15227 fail:
15228 {
15229 if (temp2)
15230 delete arg2;
15231 }
15232 return NULL;
15233 }
15234
15235
15236 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj;
15238 wxDC *arg1 = (wxDC *) 0 ;
15239 wxString *arg2 = 0 ;
15240 int *arg3 = (int *) 0 ;
15241 int *arg4 = (int *) 0 ;
15242 int *arg5 = (int *) 0 ;
15243 wxFont *arg6 = (wxFont *) NULL ;
15244 bool temp2 = false ;
15245 int temp3 ;
15246 int res3 = 0 ;
15247 int temp4 ;
15248 int res4 = 0 ;
15249 int temp5 ;
15250 int res5 = 0 ;
15251 PyObject * obj0 = 0 ;
15252 PyObject * obj1 = 0 ;
15253 PyObject * obj2 = 0 ;
15254 char *kwnames[] = {
15255 (char *) "self",(char *) "text",(char *) "font", NULL
15256 };
15257
15258 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15259 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15260 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15263 if (SWIG_arg_fail(1)) SWIG_fail;
15264 {
15265 arg2 = wxString_in_helper(obj1);
15266 if (arg2 == NULL) SWIG_fail;
15267 temp2 = true;
15268 }
15269 if (obj2) {
15270 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15271 if (SWIG_arg_fail(6)) SWIG_fail;
15272 }
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15276
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 Py_INCREF(Py_None); resultobj = Py_None;
15281 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15282 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15283 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15284 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15285 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15286 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15287 {
15288 if (temp2)
15289 delete arg2;
15290 }
15291 return resultobj;
15292 fail:
15293 {
15294 if (temp2)
15295 delete arg2;
15296 }
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxDC *arg1 = (wxDC *) 0 ;
15304 wxString *arg2 = 0 ;
15305 wxArrayInt result;
15306 bool temp2 = false ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "text", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 {
15317 arg2 = wxString_in_helper(obj1);
15318 if (arg2 == NULL) SWIG_fail;
15319 temp2 = true;
15320 }
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15324
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 {
15329 resultobj = PyList_New(0);
15330 size_t idx;
15331 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15332 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15333 PyList_Append(resultobj, val);
15334 Py_DECREF(val);
15335 }
15336 }
15337 {
15338 if (temp2)
15339 delete arg2;
15340 }
15341 return resultobj;
15342 fail:
15343 {
15344 if (temp2)
15345 delete arg2;
15346 }
15347 return NULL;
15348 }
15349
15350
15351 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15352 PyObject *resultobj;
15353 wxDC *arg1 = (wxDC *) 0 ;
15354 wxSize result;
15355 PyObject * obj0 = 0 ;
15356 char *kwnames[] = {
15357 (char *) "self", NULL
15358 };
15359
15360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15362 if (SWIG_arg_fail(1)) SWIG_fail;
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 result = (arg1)->GetSize();
15366
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 {
15371 wxSize * resultptr;
15372 resultptr = new wxSize((wxSize &)(result));
15373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15374 }
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15382 PyObject *resultobj;
15383 wxDC *arg1 = (wxDC *) 0 ;
15384 int *arg2 = (int *) 0 ;
15385 int *arg3 = (int *) 0 ;
15386 int temp2 ;
15387 int res2 = 0 ;
15388 int temp3 ;
15389 int res3 = 0 ;
15390 PyObject * obj0 = 0 ;
15391 char *kwnames[] = {
15392 (char *) "self", NULL
15393 };
15394
15395 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15396 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(1)) SWIG_fail;
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 (arg1)->GetSize(arg2,arg3);
15403
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 Py_INCREF(Py_None); resultobj = Py_None;
15408 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15409 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15410 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15411 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxDC *arg1 = (wxDC *) 0 ;
15421 wxSize result;
15422 PyObject * obj0 = 0 ;
15423 char *kwnames[] = {
15424 (char *) "self", NULL
15425 };
15426
15427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
15432 result = ((wxDC const *)arg1)->GetSizeMM();
15433
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 {
15438 wxSize * resultptr;
15439 resultptr = new wxSize((wxSize &)(result));
15440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15441 }
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj;
15450 wxDC *arg1 = (wxDC *) 0 ;
15451 int *arg2 = (int *) 0 ;
15452 int *arg3 = (int *) 0 ;
15453 int temp2 ;
15454 int res2 = 0 ;
15455 int temp3 ;
15456 int res3 = 0 ;
15457 PyObject * obj0 = 0 ;
15458 char *kwnames[] = {
15459 (char *) "self", NULL
15460 };
15461
15462 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15463 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15466 if (SWIG_arg_fail(1)) SWIG_fail;
15467 {
15468 PyThreadState* __tstate = wxPyBeginAllowThreads();
15469 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15470
15471 wxPyEndAllowThreads(__tstate);
15472 if (PyErr_Occurred()) SWIG_fail;
15473 }
15474 Py_INCREF(Py_None); resultobj = Py_None;
15475 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15476 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15477 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15478 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj;
15487 wxDC *arg1 = (wxDC *) 0 ;
15488 int arg2 ;
15489 int result;
15490 PyObject * obj0 = 0 ;
15491 PyObject * obj1 = 0 ;
15492 char *kwnames[] = {
15493 (char *) "self",(char *) "x", NULL
15494 };
15495
15496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15498 if (SWIG_arg_fail(1)) SWIG_fail;
15499 {
15500 arg2 = (int)(SWIG_As_int(obj1));
15501 if (SWIG_arg_fail(2)) SWIG_fail;
15502 }
15503 {
15504 PyThreadState* __tstate = wxPyBeginAllowThreads();
15505 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15506
15507 wxPyEndAllowThreads(__tstate);
15508 if (PyErr_Occurred()) SWIG_fail;
15509 }
15510 {
15511 resultobj = SWIG_From_int((int)(result));
15512 }
15513 return resultobj;
15514 fail:
15515 return NULL;
15516 }
15517
15518
15519 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15520 PyObject *resultobj;
15521 wxDC *arg1 = (wxDC *) 0 ;
15522 int arg2 ;
15523 int result;
15524 PyObject * obj0 = 0 ;
15525 PyObject * obj1 = 0 ;
15526 char *kwnames[] = {
15527 (char *) "self",(char *) "y", NULL
15528 };
15529
15530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15532 if (SWIG_arg_fail(1)) SWIG_fail;
15533 {
15534 arg2 = (int)(SWIG_As_int(obj1));
15535 if (SWIG_arg_fail(2)) SWIG_fail;
15536 }
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15540
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 {
15545 resultobj = SWIG_From_int((int)(result));
15546 }
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj;
15555 wxDC *arg1 = (wxDC *) 0 ;
15556 int arg2 ;
15557 int result;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 char *kwnames[] = {
15561 (char *) "self",(char *) "x", NULL
15562 };
15563
15564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15566 if (SWIG_arg_fail(1)) SWIG_fail;
15567 {
15568 arg2 = (int)(SWIG_As_int(obj1));
15569 if (SWIG_arg_fail(2)) SWIG_fail;
15570 }
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15574
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 {
15579 resultobj = SWIG_From_int((int)(result));
15580 }
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15588 PyObject *resultobj;
15589 wxDC *arg1 = (wxDC *) 0 ;
15590 int arg2 ;
15591 int result;
15592 PyObject * obj0 = 0 ;
15593 PyObject * obj1 = 0 ;
15594 char *kwnames[] = {
15595 (char *) "self",(char *) "y", NULL
15596 };
15597
15598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15600 if (SWIG_arg_fail(1)) SWIG_fail;
15601 {
15602 arg2 = (int)(SWIG_As_int(obj1));
15603 if (SWIG_arg_fail(2)) SWIG_fail;
15604 }
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15608
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 {
15613 resultobj = SWIG_From_int((int)(result));
15614 }
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj;
15623 wxDC *arg1 = (wxDC *) 0 ;
15624 int arg2 ;
15625 int result;
15626 PyObject * obj0 = 0 ;
15627 PyObject * obj1 = 0 ;
15628 char *kwnames[] = {
15629 (char *) "self",(char *) "x", NULL
15630 };
15631
15632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15634 if (SWIG_arg_fail(1)) SWIG_fail;
15635 {
15636 arg2 = (int)(SWIG_As_int(obj1));
15637 if (SWIG_arg_fail(2)) SWIG_fail;
15638 }
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15642
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 {
15647 resultobj = SWIG_From_int((int)(result));
15648 }
15649 return resultobj;
15650 fail:
15651 return NULL;
15652 }
15653
15654
15655 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15656 PyObject *resultobj;
15657 wxDC *arg1 = (wxDC *) 0 ;
15658 int arg2 ;
15659 int result;
15660 PyObject * obj0 = 0 ;
15661 PyObject * obj1 = 0 ;
15662 char *kwnames[] = {
15663 (char *) "self",(char *) "y", NULL
15664 };
15665
15666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15668 if (SWIG_arg_fail(1)) SWIG_fail;
15669 {
15670 arg2 = (int)(SWIG_As_int(obj1));
15671 if (SWIG_arg_fail(2)) SWIG_fail;
15672 }
15673 {
15674 PyThreadState* __tstate = wxPyBeginAllowThreads();
15675 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15676
15677 wxPyEndAllowThreads(__tstate);
15678 if (PyErr_Occurred()) SWIG_fail;
15679 }
15680 {
15681 resultobj = SWIG_From_int((int)(result));
15682 }
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15690 PyObject *resultobj;
15691 wxDC *arg1 = (wxDC *) 0 ;
15692 int arg2 ;
15693 int result;
15694 PyObject * obj0 = 0 ;
15695 PyObject * obj1 = 0 ;
15696 char *kwnames[] = {
15697 (char *) "self",(char *) "x", NULL
15698 };
15699
15700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15702 if (SWIG_arg_fail(1)) SWIG_fail;
15703 {
15704 arg2 = (int)(SWIG_As_int(obj1));
15705 if (SWIG_arg_fail(2)) SWIG_fail;
15706 }
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15710
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 {
15715 resultobj = SWIG_From_int((int)(result));
15716 }
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15724 PyObject *resultobj;
15725 wxDC *arg1 = (wxDC *) 0 ;
15726 int arg2 ;
15727 int result;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 char *kwnames[] = {
15731 (char *) "self",(char *) "y", NULL
15732 };
15733
15734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15736 if (SWIG_arg_fail(1)) SWIG_fail;
15737 {
15738 arg2 = (int)(SWIG_As_int(obj1));
15739 if (SWIG_arg_fail(2)) SWIG_fail;
15740 }
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15744
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 {
15749 resultobj = SWIG_From_int((int)(result));
15750 }
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15758 PyObject *resultobj;
15759 wxDC *arg1 = (wxDC *) 0 ;
15760 bool result;
15761 PyObject * obj0 = 0 ;
15762 char *kwnames[] = {
15763 (char *) "self", NULL
15764 };
15765
15766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15768 if (SWIG_arg_fail(1)) SWIG_fail;
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15772
15773 wxPyEndAllowThreads(__tstate);
15774 if (PyErr_Occurred()) SWIG_fail;
15775 }
15776 {
15777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15778 }
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15786 PyObject *resultobj;
15787 wxDC *arg1 = (wxDC *) 0 ;
15788 bool result;
15789 PyObject * obj0 = 0 ;
15790 char *kwnames[] = {
15791 (char *) "self", NULL
15792 };
15793
15794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15796 if (SWIG_arg_fail(1)) SWIG_fail;
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15800
15801 wxPyEndAllowThreads(__tstate);
15802 if (PyErr_Occurred()) SWIG_fail;
15803 }
15804 {
15805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15806 }
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15814 PyObject *resultobj;
15815 wxDC *arg1 = (wxDC *) 0 ;
15816 int result;
15817 PyObject * obj0 = 0 ;
15818 char *kwnames[] = {
15819 (char *) "self", NULL
15820 };
15821
15822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15824 if (SWIG_arg_fail(1)) SWIG_fail;
15825 {
15826 PyThreadState* __tstate = wxPyBeginAllowThreads();
15827 result = (int)((wxDC const *)arg1)->GetDepth();
15828
15829 wxPyEndAllowThreads(__tstate);
15830 if (PyErr_Occurred()) SWIG_fail;
15831 }
15832 {
15833 resultobj = SWIG_From_int((int)(result));
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxDC *arg1 = (wxDC *) 0 ;
15844 wxSize result;
15845 PyObject * obj0 = 0 ;
15846 char *kwnames[] = {
15847 (char *) "self", NULL
15848 };
15849
15850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15852 if (SWIG_arg_fail(1)) SWIG_fail;
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 result = ((wxDC const *)arg1)->GetPPI();
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 wxSize * resultptr;
15862 resultptr = new wxSize((wxSize &)(result));
15863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15864 }
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15872 PyObject *resultobj;
15873 wxDC *arg1 = (wxDC *) 0 ;
15874 bool result;
15875 PyObject * obj0 = 0 ;
15876 char *kwnames[] = {
15877 (char *) "self", NULL
15878 };
15879
15880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15882 if (SWIG_arg_fail(1)) SWIG_fail;
15883 {
15884 PyThreadState* __tstate = wxPyBeginAllowThreads();
15885 result = (bool)((wxDC const *)arg1)->Ok();
15886
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 {
15891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15892 }
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15900 PyObject *resultobj;
15901 wxDC *arg1 = (wxDC *) 0 ;
15902 int result;
15903 PyObject * obj0 = 0 ;
15904 char *kwnames[] = {
15905 (char *) "self", NULL
15906 };
15907
15908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15910 if (SWIG_arg_fail(1)) SWIG_fail;
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15914
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 {
15919 resultobj = SWIG_From_int((int)(result));
15920 }
15921 return resultobj;
15922 fail:
15923 return NULL;
15924 }
15925
15926
15927 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15928 PyObject *resultobj;
15929 wxDC *arg1 = (wxDC *) 0 ;
15930 wxBrush *result;
15931 PyObject * obj0 = 0 ;
15932 char *kwnames[] = {
15933 (char *) "self", NULL
15934 };
15935
15936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15938 if (SWIG_arg_fail(1)) SWIG_fail;
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 {
15942 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15943 result = (wxBrush *) &_result_ref;
15944 }
15945
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 {
15950 wxBrush* resultptr = new wxBrush(*result);
15951 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15952 }
15953 return resultobj;
15954 fail:
15955 return NULL;
15956 }
15957
15958
15959 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15960 PyObject *resultobj;
15961 wxDC *arg1 = (wxDC *) 0 ;
15962 wxBrush *result;
15963 PyObject * obj0 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 {
15974 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15975 result = (wxBrush *) &_result_ref;
15976 }
15977
15978 wxPyEndAllowThreads(__tstate);
15979 if (PyErr_Occurred()) SWIG_fail;
15980 }
15981 {
15982 wxBrush* resultptr = new wxBrush(*result);
15983 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj;
15993 wxDC *arg1 = (wxDC *) 0 ;
15994 wxFont *result;
15995 PyObject * obj0 = 0 ;
15996 char *kwnames[] = {
15997 (char *) "self", NULL
15998 };
15999
16000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16002 if (SWIG_arg_fail(1)) SWIG_fail;
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 {
16006 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16007 result = (wxFont *) &_result_ref;
16008 }
16009
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 {
16014 wxFont* resultptr = new wxFont(*result);
16015 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16016 }
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj;
16025 wxDC *arg1 = (wxDC *) 0 ;
16026 wxPen *result;
16027 PyObject * obj0 = 0 ;
16028 char *kwnames[] = {
16029 (char *) "self", NULL
16030 };
16031
16032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16034 if (SWIG_arg_fail(1)) SWIG_fail;
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 {
16038 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16039 result = (wxPen *) &_result_ref;
16040 }
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 {
16046 wxPen* resultptr = new wxPen(*result);
16047 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16048 }
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj;
16057 wxDC *arg1 = (wxDC *) 0 ;
16058 wxColour *result;
16059 PyObject * obj0 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 {
16070 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16071 result = (wxColour *) &_result_ref;
16072 }
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj;
16086 wxDC *arg1 = (wxDC *) 0 ;
16087 wxColour *result;
16088 PyObject * obj0 = 0 ;
16089 char *kwnames[] = {
16090 (char *) "self", NULL
16091 };
16092
16093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16095 if (SWIG_arg_fail(1)) SWIG_fail;
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 {
16099 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16100 result = (wxColour *) &_result_ref;
16101 }
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxDC *arg1 = (wxDC *) 0 ;
16116 wxColour *arg2 = 0 ;
16117 wxColour temp2 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self",(char *) "colour", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 {
16128 arg2 = &temp2;
16129 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16130 }
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 (arg1)->SetTextForeground((wxColour const &)*arg2);
16134
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 Py_INCREF(Py_None); resultobj = Py_None;
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxDC *arg1 = (wxDC *) 0 ;
16148 wxColour *arg2 = 0 ;
16149 wxColour temp2 ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 char *kwnames[] = {
16153 (char *) "self",(char *) "colour", NULL
16154 };
16155
16156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16158 if (SWIG_arg_fail(1)) SWIG_fail;
16159 {
16160 arg2 = &temp2;
16161 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 (arg1)->SetTextBackground((wxColour const &)*arg2);
16166
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 Py_INCREF(Py_None); resultobj = Py_None;
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj;
16179 wxDC *arg1 = (wxDC *) 0 ;
16180 int result;
16181 PyObject * obj0 = 0 ;
16182 char *kwnames[] = {
16183 (char *) "self", NULL
16184 };
16185
16186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16188 if (SWIG_arg_fail(1)) SWIG_fail;
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 result = (int)((wxDC const *)arg1)->GetMapMode();
16192
16193 wxPyEndAllowThreads(__tstate);
16194 if (PyErr_Occurred()) SWIG_fail;
16195 }
16196 {
16197 resultobj = SWIG_From_int((int)(result));
16198 }
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj;
16207 wxDC *arg1 = (wxDC *) 0 ;
16208 int arg2 ;
16209 PyObject * obj0 = 0 ;
16210 PyObject * obj1 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self",(char *) "mode", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 arg2 = (int)(SWIG_As_int(obj1));
16220 if (SWIG_arg_fail(2)) SWIG_fail;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 (arg1)->SetMapMode(arg2);
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 Py_INCREF(Py_None); resultobj = Py_None;
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16237 PyObject *resultobj;
16238 wxDC *arg1 = (wxDC *) 0 ;
16239 double *arg2 = (double *) 0 ;
16240 double *arg3 = (double *) 0 ;
16241 double temp2 ;
16242 int res2 = 0 ;
16243 double temp3 ;
16244 int res3 = 0 ;
16245 PyObject * obj0 = 0 ;
16246 char *kwnames[] = {
16247 (char *) "self", NULL
16248 };
16249
16250 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16251 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16254 if (SWIG_arg_fail(1)) SWIG_fail;
16255 {
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16258
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 Py_INCREF(Py_None); resultobj = Py_None;
16263 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16264 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16265 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16266 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj;
16275 wxDC *arg1 = (wxDC *) 0 ;
16276 double arg2 ;
16277 double arg3 ;
16278 PyObject * obj0 = 0 ;
16279 PyObject * obj1 = 0 ;
16280 PyObject * obj2 = 0 ;
16281 char *kwnames[] = {
16282 (char *) "self",(char *) "x",(char *) "y", NULL
16283 };
16284
16285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16287 if (SWIG_arg_fail(1)) SWIG_fail;
16288 {
16289 arg2 = (double)(SWIG_As_double(obj1));
16290 if (SWIG_arg_fail(2)) SWIG_fail;
16291 }
16292 {
16293 arg3 = (double)(SWIG_As_double(obj2));
16294 if (SWIG_arg_fail(3)) SWIG_fail;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 (arg1)->SetUserScale(arg2,arg3);
16299
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 Py_INCREF(Py_None); resultobj = Py_None;
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj;
16312 wxDC *arg1 = (wxDC *) 0 ;
16313 double *arg2 = (double *) 0 ;
16314 double *arg3 = (double *) 0 ;
16315 double temp2 ;
16316 int res2 = 0 ;
16317 double temp3 ;
16318 int res3 = 0 ;
16319 PyObject * obj0 = 0 ;
16320 char *kwnames[] = {
16321 (char *) "self", NULL
16322 };
16323
16324 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16325 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 (arg1)->GetLogicalScale(arg2,arg3);
16332
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 Py_INCREF(Py_None); resultobj = Py_None;
16337 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16338 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16339 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16340 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16341 return resultobj;
16342 fail:
16343 return NULL;
16344 }
16345
16346
16347 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16348 PyObject *resultobj;
16349 wxDC *arg1 = (wxDC *) 0 ;
16350 double arg2 ;
16351 double arg3 ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 PyObject * obj2 = 0 ;
16355 char *kwnames[] = {
16356 (char *) "self",(char *) "x",(char *) "y", NULL
16357 };
16358
16359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16361 if (SWIG_arg_fail(1)) SWIG_fail;
16362 {
16363 arg2 = (double)(SWIG_As_double(obj1));
16364 if (SWIG_arg_fail(2)) SWIG_fail;
16365 }
16366 {
16367 arg3 = (double)(SWIG_As_double(obj2));
16368 if (SWIG_arg_fail(3)) SWIG_fail;
16369 }
16370 {
16371 PyThreadState* __tstate = wxPyBeginAllowThreads();
16372 (arg1)->SetLogicalScale(arg2,arg3);
16373
16374 wxPyEndAllowThreads(__tstate);
16375 if (PyErr_Occurred()) SWIG_fail;
16376 }
16377 Py_INCREF(Py_None); resultobj = Py_None;
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj;
16386 wxDC *arg1 = (wxDC *) 0 ;
16387 wxPoint result;
16388 PyObject * obj0 = 0 ;
16389 char *kwnames[] = {
16390 (char *) "self", NULL
16391 };
16392
16393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16395 if (SWIG_arg_fail(1)) SWIG_fail;
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16399
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 wxPoint * resultptr;
16405 resultptr = new wxPoint((wxPoint &)(result));
16406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16407 }
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj;
16416 wxDC *arg1 = (wxDC *) 0 ;
16417 int *arg2 = (int *) 0 ;
16418 int *arg3 = (int *) 0 ;
16419 int temp2 ;
16420 int res2 = 0 ;
16421 int temp3 ;
16422 int res3 = 0 ;
16423 PyObject * obj0 = 0 ;
16424 char *kwnames[] = {
16425 (char *) "self", NULL
16426 };
16427
16428 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16429 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 Py_INCREF(Py_None); resultobj = Py_None;
16441 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16442 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16443 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16444 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj;
16453 wxDC *arg1 = (wxDC *) 0 ;
16454 int arg2 ;
16455 int arg3 ;
16456 PyObject * obj0 = 0 ;
16457 PyObject * obj1 = 0 ;
16458 PyObject * obj2 = 0 ;
16459 char *kwnames[] = {
16460 (char *) "self",(char *) "x",(char *) "y", NULL
16461 };
16462
16463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16465 if (SWIG_arg_fail(1)) SWIG_fail;
16466 {
16467 arg2 = (int)(SWIG_As_int(obj1));
16468 if (SWIG_arg_fail(2)) SWIG_fail;
16469 }
16470 {
16471 arg3 = (int)(SWIG_As_int(obj2));
16472 if (SWIG_arg_fail(3)) SWIG_fail;
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 (arg1)->SetLogicalOrigin(arg2,arg3);
16477
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 Py_INCREF(Py_None); resultobj = Py_None;
16482 return resultobj;
16483 fail:
16484 return NULL;
16485 }
16486
16487
16488 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj;
16490 wxDC *arg1 = (wxDC *) 0 ;
16491 wxPoint *arg2 = 0 ;
16492 wxPoint temp2 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 char *kwnames[] = {
16496 (char *) "self",(char *) "point", NULL
16497 };
16498
16499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16501 if (SWIG_arg_fail(1)) SWIG_fail;
16502 {
16503 arg2 = &temp2;
16504 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16505 }
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16509
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 Py_INCREF(Py_None); resultobj = Py_None;
16514 return resultobj;
16515 fail:
16516 return NULL;
16517 }
16518
16519
16520 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxDC *arg1 = (wxDC *) 0 ;
16523 wxPoint result;
16524 PyObject * obj0 = 0 ;
16525 char *kwnames[] = {
16526 (char *) "self", NULL
16527 };
16528
16529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16531 if (SWIG_arg_fail(1)) SWIG_fail;
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16535
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 {
16540 wxPoint * resultptr;
16541 resultptr = new wxPoint((wxPoint &)(result));
16542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16551 PyObject *resultobj;
16552 wxDC *arg1 = (wxDC *) 0 ;
16553 int *arg2 = (int *) 0 ;
16554 int *arg3 = (int *) 0 ;
16555 int temp2 ;
16556 int res2 = 0 ;
16557 int temp3 ;
16558 int res3 = 0 ;
16559 PyObject * obj0 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self", NULL
16562 };
16563
16564 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16565 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",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 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16572
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 Py_INCREF(Py_None); resultobj = Py_None;
16577 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16578 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16579 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16580 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16588 PyObject *resultobj;
16589 wxDC *arg1 = (wxDC *) 0 ;
16590 int arg2 ;
16591 int arg3 ;
16592 PyObject * obj0 = 0 ;
16593 PyObject * obj1 = 0 ;
16594 PyObject * obj2 = 0 ;
16595 char *kwnames[] = {
16596 (char *) "self",(char *) "x",(char *) "y", NULL
16597 };
16598
16599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16601 if (SWIG_arg_fail(1)) SWIG_fail;
16602 {
16603 arg2 = (int)(SWIG_As_int(obj1));
16604 if (SWIG_arg_fail(2)) SWIG_fail;
16605 }
16606 {
16607 arg3 = (int)(SWIG_As_int(obj2));
16608 if (SWIG_arg_fail(3)) SWIG_fail;
16609 }
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 (arg1)->SetDeviceOrigin(arg2,arg3);
16613
16614 wxPyEndAllowThreads(__tstate);
16615 if (PyErr_Occurred()) SWIG_fail;
16616 }
16617 Py_INCREF(Py_None); resultobj = Py_None;
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj;
16626 wxDC *arg1 = (wxDC *) 0 ;
16627 wxPoint *arg2 = 0 ;
16628 wxPoint temp2 ;
16629 PyObject * obj0 = 0 ;
16630 PyObject * obj1 = 0 ;
16631 char *kwnames[] = {
16632 (char *) "self",(char *) "point", NULL
16633 };
16634
16635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16637 if (SWIG_arg_fail(1)) SWIG_fail;
16638 {
16639 arg2 = &temp2;
16640 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16641 }
16642 {
16643 PyThreadState* __tstate = wxPyBeginAllowThreads();
16644 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16645
16646 wxPyEndAllowThreads(__tstate);
16647 if (PyErr_Occurred()) SWIG_fail;
16648 }
16649 Py_INCREF(Py_None); resultobj = Py_None;
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16657 PyObject *resultobj;
16658 wxDC *arg1 = (wxDC *) 0 ;
16659 bool arg2 ;
16660 bool arg3 ;
16661 PyObject * obj0 = 0 ;
16662 PyObject * obj1 = 0 ;
16663 PyObject * obj2 = 0 ;
16664 char *kwnames[] = {
16665 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16670 if (SWIG_arg_fail(1)) SWIG_fail;
16671 {
16672 arg2 = (bool)(SWIG_As_bool(obj1));
16673 if (SWIG_arg_fail(2)) SWIG_fail;
16674 }
16675 {
16676 arg3 = (bool)(SWIG_As_bool(obj2));
16677 if (SWIG_arg_fail(3)) SWIG_fail;
16678 }
16679 {
16680 PyThreadState* __tstate = wxPyBeginAllowThreads();
16681 (arg1)->SetAxisOrientation(arg2,arg3);
16682
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 Py_INCREF(Py_None); resultobj = Py_None;
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj;
16695 wxDC *arg1 = (wxDC *) 0 ;
16696 int result;
16697 PyObject * obj0 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16708
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 {
16713 resultobj = SWIG_From_int((int)(result));
16714 }
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj;
16723 wxDC *arg1 = (wxDC *) 0 ;
16724 int arg2 ;
16725 PyObject * obj0 = 0 ;
16726 PyObject * obj1 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self",(char *) "function", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 arg2 = (int)(SWIG_As_int(obj1));
16736 if (SWIG_arg_fail(2)) SWIG_fail;
16737 }
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 (arg1)->SetLogicalFunction(arg2);
16741
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 Py_INCREF(Py_None); resultobj = Py_None;
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj;
16754 wxDC *arg1 = (wxDC *) 0 ;
16755 PyObject * obj0 = 0 ;
16756 char *kwnames[] = {
16757 (char *) "self", NULL
16758 };
16759
16760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16762 if (SWIG_arg_fail(1)) SWIG_fail;
16763 {
16764 PyThreadState* __tstate = wxPyBeginAllowThreads();
16765 (arg1)->ComputeScaleAndOrigin();
16766
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 Py_INCREF(Py_None); resultobj = Py_None;
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj;
16779 wxDC *arg1 = (wxDC *) 0 ;
16780 int arg2 ;
16781 int arg3 ;
16782 PyObject * obj0 = 0 ;
16783 PyObject * obj1 = 0 ;
16784 PyObject * obj2 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self",(char *) "x",(char *) "y", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 arg2 = (int)(SWIG_As_int(obj1));
16794 if (SWIG_arg_fail(2)) SWIG_fail;
16795 }
16796 {
16797 arg3 = (int)(SWIG_As_int(obj2));
16798 if (SWIG_arg_fail(3)) SWIG_fail;
16799 }
16800 {
16801 PyThreadState* __tstate = wxPyBeginAllowThreads();
16802 (arg1)->CalcBoundingBox(arg2,arg3);
16803
16804 wxPyEndAllowThreads(__tstate);
16805 if (PyErr_Occurred()) SWIG_fail;
16806 }
16807 Py_INCREF(Py_None); resultobj = Py_None;
16808 return resultobj;
16809 fail:
16810 return NULL;
16811 }
16812
16813
16814 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16815 PyObject *resultobj;
16816 wxDC *arg1 = (wxDC *) 0 ;
16817 wxPoint *arg2 = 0 ;
16818 wxPoint temp2 ;
16819 PyObject * obj0 = 0 ;
16820 PyObject * obj1 = 0 ;
16821 char *kwnames[] = {
16822 (char *) "self",(char *) "point", NULL
16823 };
16824
16825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16827 if (SWIG_arg_fail(1)) SWIG_fail;
16828 {
16829 arg2 = &temp2;
16830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16831 }
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 Py_INCREF(Py_None); resultobj = Py_None;
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxDC *arg1 = (wxDC *) 0 ;
16849 PyObject * obj0 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self", NULL
16852 };
16853
16854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(1)) SWIG_fail;
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 (arg1)->ResetBoundingBox();
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 Py_INCREF(Py_None); resultobj = Py_None;
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj;
16873 wxDC *arg1 = (wxDC *) 0 ;
16874 int result;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16882 if (SWIG_arg_fail(1)) SWIG_fail;
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 result = (int)((wxDC const *)arg1)->MinX();
16886
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 {
16891 resultobj = SWIG_From_int((int)(result));
16892 }
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16900 PyObject *resultobj;
16901 wxDC *arg1 = (wxDC *) 0 ;
16902 int result;
16903 PyObject * obj0 = 0 ;
16904 char *kwnames[] = {
16905 (char *) "self", NULL
16906 };
16907
16908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16910 if (SWIG_arg_fail(1)) SWIG_fail;
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = (int)((wxDC const *)arg1)->MaxX();
16914
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 {
16919 resultobj = SWIG_From_int((int)(result));
16920 }
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16928 PyObject *resultobj;
16929 wxDC *arg1 = (wxDC *) 0 ;
16930 int result;
16931 PyObject * obj0 = 0 ;
16932 char *kwnames[] = {
16933 (char *) "self", NULL
16934 };
16935
16936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16938 if (SWIG_arg_fail(1)) SWIG_fail;
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 result = (int)((wxDC const *)arg1)->MinY();
16942
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 {
16947 resultobj = SWIG_From_int((int)(result));
16948 }
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj;
16957 wxDC *arg1 = (wxDC *) 0 ;
16958 int result;
16959 PyObject * obj0 = 0 ;
16960 char *kwnames[] = {
16961 (char *) "self", NULL
16962 };
16963
16964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16966 if (SWIG_arg_fail(1)) SWIG_fail;
16967 {
16968 PyThreadState* __tstate = wxPyBeginAllowThreads();
16969 result = (int)((wxDC const *)arg1)->MaxY();
16970
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 {
16975 resultobj = SWIG_From_int((int)(result));
16976 }
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj;
16985 wxDC *arg1 = (wxDC *) 0 ;
16986 int *arg2 = (int *) 0 ;
16987 int *arg3 = (int *) 0 ;
16988 int *arg4 = (int *) 0 ;
16989 int *arg5 = (int *) 0 ;
16990 int temp2 ;
16991 int res2 = 0 ;
16992 int temp3 ;
16993 int res3 = 0 ;
16994 int temp4 ;
16995 int res4 = 0 ;
16996 int temp5 ;
16997 int res5 = 0 ;
16998 PyObject * obj0 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "self", NULL
17001 };
17002
17003 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17004 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17005 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17006 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17009 if (SWIG_arg_fail(1)) SWIG_fail;
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17013
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 Py_INCREF(Py_None); resultobj = Py_None;
17018 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17019 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17020 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17021 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17022 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17023 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17024 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17025 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxDC *arg1 = (wxDC *) 0 ;
17035 PyObject *arg2 = (PyObject *) 0 ;
17036 PyObject *arg3 = (PyObject *) 0 ;
17037 PyObject *arg4 = (PyObject *) 0 ;
17038 PyObject *result;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 PyObject * obj2 = 0 ;
17042 PyObject * obj3 = 0 ;
17043 char *kwnames[] = {
17044 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17045 };
17046
17047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17049 if (SWIG_arg_fail(1)) SWIG_fail;
17050 arg2 = obj1;
17051 arg3 = obj2;
17052 arg4 = obj3;
17053 {
17054 PyThreadState* __tstate = wxPyBeginAllowThreads();
17055 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17056
17057 wxPyEndAllowThreads(__tstate);
17058 if (PyErr_Occurred()) SWIG_fail;
17059 }
17060 resultobj = result;
17061 return resultobj;
17062 fail:
17063 return NULL;
17064 }
17065
17066
17067 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17068 PyObject *resultobj;
17069 wxDC *arg1 = (wxDC *) 0 ;
17070 PyObject *arg2 = (PyObject *) 0 ;
17071 PyObject *arg3 = (PyObject *) 0 ;
17072 PyObject *arg4 = (PyObject *) 0 ;
17073 PyObject *result;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 PyObject * obj2 = 0 ;
17077 PyObject * obj3 = 0 ;
17078 char *kwnames[] = {
17079 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17080 };
17081
17082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17084 if (SWIG_arg_fail(1)) SWIG_fail;
17085 arg2 = obj1;
17086 arg3 = obj2;
17087 arg4 = obj3;
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17091
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 resultobj = result;
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 wxDC *arg1 = (wxDC *) 0 ;
17105 PyObject *arg2 = (PyObject *) 0 ;
17106 PyObject *arg3 = (PyObject *) 0 ;
17107 PyObject *arg4 = (PyObject *) 0 ;
17108 PyObject *result;
17109 PyObject * obj0 = 0 ;
17110 PyObject * obj1 = 0 ;
17111 PyObject * obj2 = 0 ;
17112 PyObject * obj3 = 0 ;
17113 char *kwnames[] = {
17114 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17115 };
17116
17117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17119 if (SWIG_arg_fail(1)) SWIG_fail;
17120 arg2 = obj1;
17121 arg3 = obj2;
17122 arg4 = obj3;
17123 {
17124 PyThreadState* __tstate = wxPyBeginAllowThreads();
17125 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17126
17127 wxPyEndAllowThreads(__tstate);
17128 if (PyErr_Occurred()) SWIG_fail;
17129 }
17130 resultobj = result;
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxDC *arg1 = (wxDC *) 0 ;
17140 PyObject *arg2 = (PyObject *) 0 ;
17141 PyObject *arg3 = (PyObject *) 0 ;
17142 PyObject *arg4 = (PyObject *) 0 ;
17143 PyObject *result;
17144 PyObject * obj0 = 0 ;
17145 PyObject * obj1 = 0 ;
17146 PyObject * obj2 = 0 ;
17147 PyObject * obj3 = 0 ;
17148 char *kwnames[] = {
17149 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17150 };
17151
17152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17154 if (SWIG_arg_fail(1)) SWIG_fail;
17155 arg2 = obj1;
17156 arg3 = obj2;
17157 arg4 = obj3;
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17161
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 resultobj = result;
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxDC *arg1 = (wxDC *) 0 ;
17175 PyObject *arg2 = (PyObject *) 0 ;
17176 PyObject *arg3 = (PyObject *) 0 ;
17177 PyObject *arg4 = (PyObject *) 0 ;
17178 PyObject *result;
17179 PyObject * obj0 = 0 ;
17180 PyObject * obj1 = 0 ;
17181 PyObject * obj2 = 0 ;
17182 PyObject * obj3 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 arg2 = obj1;
17191 arg3 = obj2;
17192 arg4 = obj3;
17193 {
17194 PyThreadState* __tstate = wxPyBeginAllowThreads();
17195 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17196
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 resultobj = result;
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17208 PyObject *resultobj;
17209 wxDC *arg1 = (wxDC *) 0 ;
17210 PyObject *arg2 = (PyObject *) 0 ;
17211 PyObject *arg3 = (PyObject *) 0 ;
17212 PyObject *arg4 = (PyObject *) 0 ;
17213 PyObject *arg5 = (PyObject *) 0 ;
17214 PyObject *result;
17215 PyObject * obj0 = 0 ;
17216 PyObject * obj1 = 0 ;
17217 PyObject * obj2 = 0 ;
17218 PyObject * obj3 = 0 ;
17219 PyObject * obj4 = 0 ;
17220 char *kwnames[] = {
17221 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17222 };
17223
17224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17226 if (SWIG_arg_fail(1)) SWIG_fail;
17227 arg2 = obj1;
17228 arg3 = obj2;
17229 arg4 = obj3;
17230 arg5 = obj4;
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 resultobj = result;
17239 return resultobj;
17240 fail:
17241 return NULL;
17242 }
17243
17244
17245 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17246 PyObject *obj;
17247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17248 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17249 Py_INCREF(obj);
17250 return Py_BuildValue((char *)"");
17251 }
17252 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17253 PyObject *resultobj;
17254 wxMemoryDC *result;
17255 char *kwnames[] = {
17256 NULL
17257 };
17258
17259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17260 {
17261 if (!wxPyCheckForApp()) SWIG_fail;
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (wxMemoryDC *)new wxMemoryDC();
17264
17265 wxPyEndAllowThreads(__tstate);
17266 if (PyErr_Occurred()) SWIG_fail;
17267 }
17268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17269 return resultobj;
17270 fail:
17271 return NULL;
17272 }
17273
17274
17275 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17276 PyObject *resultobj;
17277 wxDC *arg1 = (wxDC *) 0 ;
17278 wxMemoryDC *result;
17279 PyObject * obj0 = 0 ;
17280 char *kwnames[] = {
17281 (char *) "oldDC", NULL
17282 };
17283
17284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17286 if (SWIG_arg_fail(1)) SWIG_fail;
17287 {
17288 if (!wxPyCheckForApp()) SWIG_fail;
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17291
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17296 return resultobj;
17297 fail:
17298 return NULL;
17299 }
17300
17301
17302 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj;
17304 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17305 wxBitmap *arg2 = 0 ;
17306 PyObject * obj0 = 0 ;
17307 PyObject * obj1 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self",(char *) "bitmap", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17317 if (SWIG_arg_fail(2)) SWIG_fail;
17318 if (arg2 == NULL) {
17319 SWIG_null_ref("wxBitmap");
17320 }
17321 if (SWIG_arg_fail(2)) SWIG_fail;
17322 }
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 (arg1)->SelectObject((wxBitmap const &)*arg2);
17326
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 Py_INCREF(Py_None); resultobj = Py_None;
17331 return resultobj;
17332 fail:
17333 return NULL;
17334 }
17335
17336
17337 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17338 PyObject *obj;
17339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17340 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17341 Py_INCREF(obj);
17342 return Py_BuildValue((char *)"");
17343 }
17344 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17345 PyObject *resultobj;
17346 wxDC *arg1 = (wxDC *) 0 ;
17347 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17348 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17349 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17350 wxBufferedDC *result;
17351 PyObject * obj0 = 0 ;
17352 PyObject * obj1 = 0 ;
17353 PyObject * obj2 = 0 ;
17354
17355 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&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 if (obj1) {
17359 {
17360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17361 if (SWIG_arg_fail(2)) SWIG_fail;
17362 if (arg2 == NULL) {
17363 SWIG_null_ref("wxBitmap");
17364 }
17365 if (SWIG_arg_fail(2)) SWIG_fail;
17366 }
17367 }
17368 if (obj2) {
17369 {
17370 arg3 = (int)(SWIG_As_int(obj2));
17371 if (SWIG_arg_fail(3)) SWIG_fail;
17372 }
17373 }
17374 {
17375 if (!wxPyCheckForApp()) SWIG_fail;
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17378
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17390 PyObject *resultobj;
17391 wxDC *arg1 = (wxDC *) 0 ;
17392 wxSize *arg2 = 0 ;
17393 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17394 wxBufferedDC *result;
17395 wxSize temp2 ;
17396 PyObject * obj0 = 0 ;
17397 PyObject * obj1 = 0 ;
17398 PyObject * obj2 = 0 ;
17399
17400 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 arg2 = &temp2;
17405 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17406 }
17407 if (obj2) {
17408 {
17409 arg3 = (int)(SWIG_As_int(obj2));
17410 if (SWIG_arg_fail(3)) SWIG_fail;
17411 }
17412 }
17413 {
17414 if (!wxPyCheckForApp()) SWIG_fail;
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17417
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17429 int argc;
17430 PyObject *argv[4];
17431 int ii;
17432
17433 argc = PyObject_Length(args);
17434 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17435 argv[ii] = PyTuple_GetItem(args,ii);
17436 }
17437 if ((argc >= 1) && (argc <= 3)) {
17438 int _v;
17439 {
17440 void *ptr;
17441 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17442 _v = 0;
17443 PyErr_Clear();
17444 } else {
17445 _v = 1;
17446 }
17447 }
17448 if (_v) {
17449 if (argc <= 1) {
17450 return _wrap_new_BufferedDC__SWIG_0(self,args);
17451 }
17452 {
17453 void *ptr = 0;
17454 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17455 _v = 0;
17456 PyErr_Clear();
17457 } else {
17458 _v = (ptr != 0);
17459 }
17460 }
17461 if (_v) {
17462 if (argc <= 2) {
17463 return _wrap_new_BufferedDC__SWIG_0(self,args);
17464 }
17465 _v = SWIG_Check_int(argv[2]);
17466 if (_v) {
17467 return _wrap_new_BufferedDC__SWIG_0(self,args);
17468 }
17469 }
17470 }
17471 }
17472 if ((argc >= 2) && (argc <= 3)) {
17473 int _v;
17474 {
17475 void *ptr;
17476 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17477 _v = 0;
17478 PyErr_Clear();
17479 } else {
17480 _v = 1;
17481 }
17482 }
17483 if (_v) {
17484 {
17485 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17486 }
17487 if (_v) {
17488 if (argc <= 2) {
17489 return _wrap_new_BufferedDC__SWIG_1(self,args);
17490 }
17491 _v = SWIG_Check_int(argv[2]);
17492 if (_v) {
17493 return _wrap_new_BufferedDC__SWIG_1(self,args);
17494 }
17495 }
17496 }
17497 }
17498
17499 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17507 PyObject * obj0 = 0 ;
17508 char *kwnames[] = {
17509 (char *) "self", NULL
17510 };
17511
17512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17514 if (SWIG_arg_fail(1)) SWIG_fail;
17515 {
17516 PyThreadState* __tstate = wxPyBeginAllowThreads();
17517 delete arg1;
17518
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 Py_INCREF(Py_None); resultobj = Py_None;
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj;
17531 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17532 PyObject * obj0 = 0 ;
17533 char *kwnames[] = {
17534 (char *) "self", NULL
17535 };
17536
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 (arg1)->UnMask();
17543
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 Py_INCREF(Py_None); resultobj = Py_None;
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17555 PyObject *obj;
17556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17557 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17558 Py_INCREF(obj);
17559 return Py_BuildValue((char *)"");
17560 }
17561 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj;
17563 wxWindow *arg1 = (wxWindow *) 0 ;
17564 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17565 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17566 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17567 wxBufferedPaintDC *result;
17568 PyObject * obj0 = 0 ;
17569 PyObject * obj1 = 0 ;
17570 PyObject * obj2 = 0 ;
17571 char *kwnames[] = {
17572 (char *) "window",(char *) "buffer",(char *) "style", NULL
17573 };
17574
17575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17577 if (SWIG_arg_fail(1)) SWIG_fail;
17578 if (obj1) {
17579 {
17580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17581 if (SWIG_arg_fail(2)) SWIG_fail;
17582 if (arg2 == NULL) {
17583 SWIG_null_ref("wxBitmap");
17584 }
17585 if (SWIG_arg_fail(2)) SWIG_fail;
17586 }
17587 }
17588 if (obj2) {
17589 {
17590 arg3 = (int)(SWIG_As_int(obj2));
17591 if (SWIG_arg_fail(3)) SWIG_fail;
17592 }
17593 }
17594 {
17595 if (!wxPyCheckForApp()) SWIG_fail;
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17598
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17610 PyObject *obj;
17611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17612 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17613 Py_INCREF(obj);
17614 return Py_BuildValue((char *)"");
17615 }
17616 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxScreenDC *result;
17619 char *kwnames[] = {
17620 NULL
17621 };
17622
17623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17624 {
17625 if (!wxPyCheckForApp()) SWIG_fail;
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (wxScreenDC *)new wxScreenDC();
17628
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17642 wxWindow *arg2 = (wxWindow *) 0 ;
17643 bool result;
17644 PyObject * obj0 = 0 ;
17645 PyObject * obj1 = 0 ;
17646 char *kwnames[] = {
17647 (char *) "self",(char *) "window", NULL
17648 };
17649
17650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17652 if (SWIG_arg_fail(1)) SWIG_fail;
17653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(2)) SWIG_fail;
17655 {
17656 PyThreadState* __tstate = wxPyBeginAllowThreads();
17657 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17658
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17674 wxRect *arg2 = (wxRect *) NULL ;
17675 bool result;
17676 PyObject * obj0 = 0 ;
17677 PyObject * obj1 = 0 ;
17678 char *kwnames[] = {
17679 (char *) "self",(char *) "rect", NULL
17680 };
17681
17682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 if (obj1) {
17686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17687 if (SWIG_arg_fail(2)) SWIG_fail;
17688 }
17689 {
17690 PyThreadState* __tstate = wxPyBeginAllowThreads();
17691 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17692
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 {
17697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj;
17707 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17708 bool result;
17709 PyObject * obj0 = 0 ;
17710 char *kwnames[] = {
17711 (char *) "self", NULL
17712 };
17713
17714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17716 if (SWIG_arg_fail(1)) SWIG_fail;
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)(arg1)->EndDrawingOnTop();
17720
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 {
17725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17734 PyObject *obj;
17735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17736 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17737 Py_INCREF(obj);
17738 return Py_BuildValue((char *)"");
17739 }
17740 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17741 PyObject *resultobj;
17742 wxWindow *arg1 = (wxWindow *) 0 ;
17743 wxClientDC *result;
17744 PyObject * obj0 = 0 ;
17745 char *kwnames[] = {
17746 (char *) "win", NULL
17747 };
17748
17749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17751 if (SWIG_arg_fail(1)) SWIG_fail;
17752 {
17753 if (!wxPyCheckForApp()) SWIG_fail;
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (wxClientDC *)new wxClientDC(arg1);
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17768 PyObject *obj;
17769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17770 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17771 Py_INCREF(obj);
17772 return Py_BuildValue((char *)"");
17773 }
17774 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxWindow *arg1 = (wxWindow *) 0 ;
17777 wxPaintDC *result;
17778 PyObject * obj0 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "win", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 if (!wxPyCheckForApp()) SWIG_fail;
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 result = (wxPaintDC *)new wxPaintDC(arg1);
17790
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17802 PyObject *obj;
17803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17804 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17805 Py_INCREF(obj);
17806 return Py_BuildValue((char *)"");
17807 }
17808 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj;
17810 wxWindow *arg1 = (wxWindow *) 0 ;
17811 wxWindowDC *result;
17812 PyObject * obj0 = 0 ;
17813 char *kwnames[] = {
17814 (char *) "win", NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17819 if (SWIG_arg_fail(1)) SWIG_fail;
17820 {
17821 if (!wxPyCheckForApp()) SWIG_fail;
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 result = (wxWindowDC *)new wxWindowDC(arg1);
17824
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17836 PyObject *obj;
17837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17838 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17839 Py_INCREF(obj);
17840 return Py_BuildValue((char *)"");
17841 }
17842 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj;
17844 wxDC *arg1 = 0 ;
17845 bool arg2 ;
17846 wxMirrorDC *result;
17847 PyObject * obj0 = 0 ;
17848 PyObject * obj1 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "dc",(char *) "mirror", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17854 {
17855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17856 if (SWIG_arg_fail(1)) SWIG_fail;
17857 if (arg1 == NULL) {
17858 SWIG_null_ref("wxDC");
17859 }
17860 if (SWIG_arg_fail(1)) SWIG_fail;
17861 }
17862 {
17863 arg2 = (bool)(SWIG_As_bool(obj1));
17864 if (SWIG_arg_fail(2)) SWIG_fail;
17865 }
17866 {
17867 if (!wxPyCheckForApp()) SWIG_fail;
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17870
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17882 PyObject *obj;
17883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17884 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17885 Py_INCREF(obj);
17886 return Py_BuildValue((char *)"");
17887 }
17888 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj;
17890 wxPrintData *arg1 = 0 ;
17891 wxPostScriptDC *result;
17892 PyObject * obj0 = 0 ;
17893 char *kwnames[] = {
17894 (char *) "printData", NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17898 {
17899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17900 if (SWIG_arg_fail(1)) SWIG_fail;
17901 if (arg1 == NULL) {
17902 SWIG_null_ref("wxPrintData");
17903 }
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 }
17906 {
17907 if (!wxPyCheckForApp()) SWIG_fail;
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17910
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17915 return resultobj;
17916 fail:
17917 return NULL;
17918 }
17919
17920
17921 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17924 wxPrintData *result;
17925 PyObject * obj0 = 0 ;
17926 char *kwnames[] = {
17927 (char *) "self", NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17932 if (SWIG_arg_fail(1)) SWIG_fail;
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 {
17936 wxPrintData &_result_ref = (arg1)->GetPrintData();
17937 result = (wxPrintData *) &_result_ref;
17938 }
17939
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17944 return resultobj;
17945 fail:
17946 return NULL;
17947 }
17948
17949
17950 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17951 PyObject *resultobj;
17952 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17953 wxPrintData *arg2 = 0 ;
17954 PyObject * obj0 = 0 ;
17955 PyObject * obj1 = 0 ;
17956 char *kwnames[] = {
17957 (char *) "self",(char *) "data", NULL
17958 };
17959
17960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17962 if (SWIG_arg_fail(1)) SWIG_fail;
17963 {
17964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17965 if (SWIG_arg_fail(2)) SWIG_fail;
17966 if (arg2 == NULL) {
17967 SWIG_null_ref("wxPrintData");
17968 }
17969 if (SWIG_arg_fail(2)) SWIG_fail;
17970 }
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 Py_INCREF(Py_None); resultobj = Py_None;
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj;
17987 int arg1 ;
17988 PyObject * obj0 = 0 ;
17989 char *kwnames[] = {
17990 (char *) "ppi", NULL
17991 };
17992
17993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17994 {
17995 arg1 = (int)(SWIG_As_int(obj0));
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 }
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 wxPostScriptDC::SetResolution(arg1);
18001
18002 wxPyEndAllowThreads(__tstate);
18003 if (PyErr_Occurred()) SWIG_fail;
18004 }
18005 Py_INCREF(Py_None); resultobj = Py_None;
18006 return resultobj;
18007 fail:
18008 return NULL;
18009 }
18010
18011
18012 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18013 PyObject *resultobj;
18014 int result;
18015 char *kwnames[] = {
18016 NULL
18017 };
18018
18019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (int)wxPostScriptDC::GetResolution();
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = SWIG_From_int((int)(result));
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18037 PyObject *obj;
18038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18039 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18040 Py_INCREF(obj);
18041 return Py_BuildValue((char *)"");
18042 }
18043 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18044 PyObject *resultobj;
18045 wxString const &arg1_defvalue = wxPyEmptyString ;
18046 wxString *arg1 = (wxString *) &arg1_defvalue ;
18047 wxMetaFile *result;
18048 bool temp1 = false ;
18049 PyObject * obj0 = 0 ;
18050 char *kwnames[] = {
18051 (char *) "filename", NULL
18052 };
18053
18054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18055 if (obj0) {
18056 {
18057 arg1 = wxString_in_helper(obj0);
18058 if (arg1 == NULL) SWIG_fail;
18059 temp1 = true;
18060 }
18061 }
18062 {
18063 if (!wxPyCheckForApp()) SWIG_fail;
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18066
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18071 {
18072 if (temp1)
18073 delete arg1;
18074 }
18075 return resultobj;
18076 fail:
18077 {
18078 if (temp1)
18079 delete arg1;
18080 }
18081 return NULL;
18082 }
18083
18084
18085 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18086 PyObject *obj;
18087 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18088 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18089 Py_INCREF(obj);
18090 return Py_BuildValue((char *)"");
18091 }
18092 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj;
18094 wxString const &arg1_defvalue = wxPyEmptyString ;
18095 wxString *arg1 = (wxString *) &arg1_defvalue ;
18096 int arg2 = (int) 0 ;
18097 int arg3 = (int) 0 ;
18098 wxString const &arg4_defvalue = wxPyEmptyString ;
18099 wxString *arg4 = (wxString *) &arg4_defvalue ;
18100 wxMetaFileDC *result;
18101 bool temp1 = false ;
18102 bool temp4 = false ;
18103 PyObject * obj0 = 0 ;
18104 PyObject * obj1 = 0 ;
18105 PyObject * obj2 = 0 ;
18106 PyObject * obj3 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18109 };
18110
18111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18112 if (obj0) {
18113 {
18114 arg1 = wxString_in_helper(obj0);
18115 if (arg1 == NULL) SWIG_fail;
18116 temp1 = true;
18117 }
18118 }
18119 if (obj1) {
18120 {
18121 arg2 = (int)(SWIG_As_int(obj1));
18122 if (SWIG_arg_fail(2)) SWIG_fail;
18123 }
18124 }
18125 if (obj2) {
18126 {
18127 arg3 = (int)(SWIG_As_int(obj2));
18128 if (SWIG_arg_fail(3)) SWIG_fail;
18129 }
18130 }
18131 if (obj3) {
18132 {
18133 arg4 = wxString_in_helper(obj3);
18134 if (arg4 == NULL) SWIG_fail;
18135 temp4 = true;
18136 }
18137 }
18138 {
18139 if (!wxPyCheckForApp()) SWIG_fail;
18140 PyThreadState* __tstate = wxPyBeginAllowThreads();
18141 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18142
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18147 {
18148 if (temp1)
18149 delete arg1;
18150 }
18151 {
18152 if (temp4)
18153 delete arg4;
18154 }
18155 return resultobj;
18156 fail:
18157 {
18158 if (temp1)
18159 delete arg1;
18160 }
18161 {
18162 if (temp4)
18163 delete arg4;
18164 }
18165 return NULL;
18166 }
18167
18168
18169 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18170 PyObject *obj;
18171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18172 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18173 Py_INCREF(obj);
18174 return Py_BuildValue((char *)"");
18175 }
18176 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18177 PyObject *resultobj;
18178 wxPrintData *arg1 = 0 ;
18179 wxPrinterDC *result;
18180 PyObject * obj0 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "printData", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18186 {
18187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18188 if (SWIG_arg_fail(1)) SWIG_fail;
18189 if (arg1 == NULL) {
18190 SWIG_null_ref("wxPrintData");
18191 }
18192 if (SWIG_arg_fail(1)) SWIG_fail;
18193 }
18194 {
18195 if (!wxPyCheckForApp()) SWIG_fail;
18196 PyThreadState* __tstate = wxPyBeginAllowThreads();
18197 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18198
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18210 PyObject *obj;
18211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18212 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18213 Py_INCREF(obj);
18214 return Py_BuildValue((char *)"");
18215 }
18216 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18217 PyObject *resultobj;
18218 int arg1 ;
18219 int arg2 ;
18220 int arg3 = (int) true ;
18221 int arg4 = (int) 1 ;
18222 wxImageList *result;
18223 PyObject * obj0 = 0 ;
18224 PyObject * obj1 = 0 ;
18225 PyObject * obj2 = 0 ;
18226 PyObject * obj3 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18232 {
18233 arg1 = (int)(SWIG_As_int(obj0));
18234 if (SWIG_arg_fail(1)) SWIG_fail;
18235 }
18236 {
18237 arg2 = (int)(SWIG_As_int(obj1));
18238 if (SWIG_arg_fail(2)) SWIG_fail;
18239 }
18240 if (obj2) {
18241 {
18242 arg3 = (int)(SWIG_As_int(obj2));
18243 if (SWIG_arg_fail(3)) SWIG_fail;
18244 }
18245 }
18246 if (obj3) {
18247 {
18248 arg4 = (int)(SWIG_As_int(obj3));
18249 if (SWIG_arg_fail(4)) SWIG_fail;
18250 }
18251 }
18252 {
18253 if (!wxPyCheckForApp()) SWIG_fail;
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18256
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 {
18261 resultobj = wxPyMake_wxObject(result, 1);
18262 }
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj;
18271 wxImageList *arg1 = (wxImageList *) 0 ;
18272 PyObject * obj0 = 0 ;
18273 char *kwnames[] = {
18274 (char *) "self", NULL
18275 };
18276
18277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 delete arg1;
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 Py_INCREF(Py_None); resultobj = Py_None;
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj;
18296 wxImageList *arg1 = (wxImageList *) 0 ;
18297 wxBitmap *arg2 = 0 ;
18298 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18299 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18300 int result;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 PyObject * obj2 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18313 if (SWIG_arg_fail(2)) SWIG_fail;
18314 if (arg2 == NULL) {
18315 SWIG_null_ref("wxBitmap");
18316 }
18317 if (SWIG_arg_fail(2)) SWIG_fail;
18318 }
18319 if (obj2) {
18320 {
18321 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(3)) SWIG_fail;
18323 if (arg3 == NULL) {
18324 SWIG_null_ref("wxBitmap");
18325 }
18326 if (SWIG_arg_fail(3)) SWIG_fail;
18327 }
18328 }
18329 {
18330 PyThreadState* __tstate = wxPyBeginAllowThreads();
18331 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18332
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 {
18337 resultobj = SWIG_From_int((int)(result));
18338 }
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj;
18347 wxImageList *arg1 = (wxImageList *) 0 ;
18348 wxBitmap *arg2 = 0 ;
18349 wxColour *arg3 = 0 ;
18350 int result;
18351 wxColour temp3 ;
18352 PyObject * obj0 = 0 ;
18353 PyObject * obj1 = 0 ;
18354 PyObject * obj2 = 0 ;
18355 char *kwnames[] = {
18356 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18357 };
18358
18359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18361 if (SWIG_arg_fail(1)) SWIG_fail;
18362 {
18363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(2)) SWIG_fail;
18365 if (arg2 == NULL) {
18366 SWIG_null_ref("wxBitmap");
18367 }
18368 if (SWIG_arg_fail(2)) SWIG_fail;
18369 }
18370 {
18371 arg3 = &temp3;
18372 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18373 }
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = SWIG_From_int((int)(result));
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxImageList *arg1 = (wxImageList *) 0 ;
18393 wxIcon *arg2 = 0 ;
18394 int result;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char *kwnames[] = {
18398 (char *) "self",(char *) "icon", NULL
18399 };
18400
18401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18403 if (SWIG_arg_fail(1)) SWIG_fail;
18404 {
18405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18406 if (SWIG_arg_fail(2)) SWIG_fail;
18407 if (arg2 == NULL) {
18408 SWIG_null_ref("wxIcon");
18409 }
18410 if (SWIG_arg_fail(2)) SWIG_fail;
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18415
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 {
18420 resultobj = SWIG_From_int((int)(result));
18421 }
18422 return resultobj;
18423 fail:
18424 return NULL;
18425 }
18426
18427
18428 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18429 PyObject *resultobj;
18430 wxImageList *arg1 = (wxImageList *) 0 ;
18431 int arg2 ;
18432 SwigValueWrapper<wxBitmap > result;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 char *kwnames[] = {
18436 (char *) "self",(char *) "index", NULL
18437 };
18438
18439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18441 if (SWIG_arg_fail(1)) SWIG_fail;
18442 {
18443 arg2 = (int)(SWIG_As_int(obj1));
18444 if (SWIG_arg_fail(2)) SWIG_fail;
18445 }
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18449
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 {
18454 wxBitmap * resultptr;
18455 resultptr = new wxBitmap((wxBitmap &)(result));
18456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18457 }
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj;
18466 wxImageList *arg1 = (wxImageList *) 0 ;
18467 int arg2 ;
18468 wxIcon result;
18469 PyObject * obj0 = 0 ;
18470 PyObject * obj1 = 0 ;
18471 char *kwnames[] = {
18472 (char *) "self",(char *) "index", NULL
18473 };
18474
18475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18477 if (SWIG_arg_fail(1)) SWIG_fail;
18478 {
18479 arg2 = (int)(SWIG_As_int(obj1));
18480 if (SWIG_arg_fail(2)) SWIG_fail;
18481 }
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18485
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 {
18490 wxIcon * resultptr;
18491 resultptr = new wxIcon((wxIcon &)(result));
18492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18493 }
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18501 PyObject *resultobj;
18502 wxImageList *arg1 = (wxImageList *) 0 ;
18503 int arg2 ;
18504 wxBitmap *arg3 = 0 ;
18505 bool result;
18506 PyObject * obj0 = 0 ;
18507 PyObject * obj1 = 0 ;
18508 PyObject * obj2 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 {
18517 arg2 = (int)(SWIG_As_int(obj1));
18518 if (SWIG_arg_fail(2)) SWIG_fail;
18519 }
18520 {
18521 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18522 if (SWIG_arg_fail(3)) SWIG_fail;
18523 if (arg3 == NULL) {
18524 SWIG_null_ref("wxBitmap");
18525 }
18526 if (SWIG_arg_fail(3)) SWIG_fail;
18527 }
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18531
18532 wxPyEndAllowThreads(__tstate);
18533 if (PyErr_Occurred()) SWIG_fail;
18534 }
18535 {
18536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18537 }
18538 return resultobj;
18539 fail:
18540 return NULL;
18541 }
18542
18543
18544 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18545 PyObject *resultobj;
18546 wxImageList *arg1 = (wxImageList *) 0 ;
18547 int arg2 ;
18548 wxDC *arg3 = 0 ;
18549 int arg4 ;
18550 int arg5 ;
18551 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18552 bool arg7 = (bool) (bool)false ;
18553 bool result;
18554 PyObject * obj0 = 0 ;
18555 PyObject * obj1 = 0 ;
18556 PyObject * obj2 = 0 ;
18557 PyObject * obj3 = 0 ;
18558 PyObject * obj4 = 0 ;
18559 PyObject * obj5 = 0 ;
18560 PyObject * obj6 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18567 if (SWIG_arg_fail(1)) SWIG_fail;
18568 {
18569 arg2 = (int)(SWIG_As_int(obj1));
18570 if (SWIG_arg_fail(2)) SWIG_fail;
18571 }
18572 {
18573 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18574 if (SWIG_arg_fail(3)) SWIG_fail;
18575 if (arg3 == NULL) {
18576 SWIG_null_ref("wxDC");
18577 }
18578 if (SWIG_arg_fail(3)) SWIG_fail;
18579 }
18580 {
18581 arg4 = (int)(SWIG_As_int(obj3));
18582 if (SWIG_arg_fail(4)) SWIG_fail;
18583 }
18584 {
18585 arg5 = (int)(SWIG_As_int(obj4));
18586 if (SWIG_arg_fail(5)) SWIG_fail;
18587 }
18588 if (obj5) {
18589 {
18590 arg6 = (int)(SWIG_As_int(obj5));
18591 if (SWIG_arg_fail(6)) SWIG_fail;
18592 }
18593 }
18594 if (obj6) {
18595 {
18596 arg7 = (bool const)(SWIG_As_bool(obj6));
18597 if (SWIG_arg_fail(7)) SWIG_fail;
18598 }
18599 }
18600 {
18601 PyThreadState* __tstate = wxPyBeginAllowThreads();
18602 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18603
18604 wxPyEndAllowThreads(__tstate);
18605 if (PyErr_Occurred()) SWIG_fail;
18606 }
18607 {
18608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18609 }
18610 return resultobj;
18611 fail:
18612 return NULL;
18613 }
18614
18615
18616 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18617 PyObject *resultobj;
18618 wxImageList *arg1 = (wxImageList *) 0 ;
18619 int result;
18620 PyObject * obj0 = 0 ;
18621 char *kwnames[] = {
18622 (char *) "self", NULL
18623 };
18624
18625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18627 if (SWIG_arg_fail(1)) SWIG_fail;
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (int)(arg1)->GetImageCount();
18631
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 {
18636 resultobj = SWIG_From_int((int)(result));
18637 }
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18645 PyObject *resultobj;
18646 wxImageList *arg1 = (wxImageList *) 0 ;
18647 int arg2 ;
18648 bool result;
18649 PyObject * obj0 = 0 ;
18650 PyObject * obj1 = 0 ;
18651 char *kwnames[] = {
18652 (char *) "self",(char *) "index", NULL
18653 };
18654
18655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18657 if (SWIG_arg_fail(1)) SWIG_fail;
18658 {
18659 arg2 = (int)(SWIG_As_int(obj1));
18660 if (SWIG_arg_fail(2)) SWIG_fail;
18661 }
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 result = (bool)(arg1)->Remove(arg2);
18665
18666 wxPyEndAllowThreads(__tstate);
18667 if (PyErr_Occurred()) SWIG_fail;
18668 }
18669 {
18670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18671 }
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj;
18680 wxImageList *arg1 = (wxImageList *) 0 ;
18681 bool result;
18682 PyObject * obj0 = 0 ;
18683 char *kwnames[] = {
18684 (char *) "self", NULL
18685 };
18686
18687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18689 if (SWIG_arg_fail(1)) SWIG_fail;
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 result = (bool)(arg1)->RemoveAll();
18693
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 {
18698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18699 }
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj;
18708 wxImageList *arg1 = (wxImageList *) 0 ;
18709 int arg2 ;
18710 int *arg3 = 0 ;
18711 int *arg4 = 0 ;
18712 int temp3 ;
18713 int res3 = 0 ;
18714 int temp4 ;
18715 int res4 = 0 ;
18716 PyObject * obj0 = 0 ;
18717 PyObject * obj1 = 0 ;
18718 char *kwnames[] = {
18719 (char *) "self",(char *) "index", NULL
18720 };
18721
18722 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18723 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18726 if (SWIG_arg_fail(1)) SWIG_fail;
18727 {
18728 arg2 = (int)(SWIG_As_int(obj1));
18729 if (SWIG_arg_fail(2)) SWIG_fail;
18730 }
18731 {
18732 PyThreadState* __tstate = wxPyBeginAllowThreads();
18733 (arg1)->GetSize(arg2,*arg3,*arg4);
18734
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 Py_INCREF(Py_None); resultobj = Py_None;
18739 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18740 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18741 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18742 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18750 PyObject *obj;
18751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18752 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18753 Py_INCREF(obj);
18754 return Py_BuildValue((char *)"");
18755 }
18756 static int _wrap_NORMAL_FONT_set(PyObject *) {
18757 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18758 return 1;
18759 }
18760
18761
18762 static PyObject *_wrap_NORMAL_FONT_get(void) {
18763 PyObject *pyobj;
18764
18765 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18766 return pyobj;
18767 }
18768
18769
18770 static int _wrap_SMALL_FONT_set(PyObject *) {
18771 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18772 return 1;
18773 }
18774
18775
18776 static PyObject *_wrap_SMALL_FONT_get(void) {
18777 PyObject *pyobj;
18778
18779 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18780 return pyobj;
18781 }
18782
18783
18784 static int _wrap_ITALIC_FONT_set(PyObject *) {
18785 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18786 return 1;
18787 }
18788
18789
18790 static PyObject *_wrap_ITALIC_FONT_get(void) {
18791 PyObject *pyobj;
18792
18793 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18794 return pyobj;
18795 }
18796
18797
18798 static int _wrap_SWISS_FONT_set(PyObject *) {
18799 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18800 return 1;
18801 }
18802
18803
18804 static PyObject *_wrap_SWISS_FONT_get(void) {
18805 PyObject *pyobj;
18806
18807 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18808 return pyobj;
18809 }
18810
18811
18812 static int _wrap_RED_PEN_set(PyObject *) {
18813 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18814 return 1;
18815 }
18816
18817
18818 static PyObject *_wrap_RED_PEN_get(void) {
18819 PyObject *pyobj;
18820
18821 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18822 return pyobj;
18823 }
18824
18825
18826 static int _wrap_CYAN_PEN_set(PyObject *) {
18827 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18828 return 1;
18829 }
18830
18831
18832 static PyObject *_wrap_CYAN_PEN_get(void) {
18833 PyObject *pyobj;
18834
18835 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18836 return pyobj;
18837 }
18838
18839
18840 static int _wrap_GREEN_PEN_set(PyObject *) {
18841 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18842 return 1;
18843 }
18844
18845
18846 static PyObject *_wrap_GREEN_PEN_get(void) {
18847 PyObject *pyobj;
18848
18849 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18850 return pyobj;
18851 }
18852
18853
18854 static int _wrap_BLACK_PEN_set(PyObject *) {
18855 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18856 return 1;
18857 }
18858
18859
18860 static PyObject *_wrap_BLACK_PEN_get(void) {
18861 PyObject *pyobj;
18862
18863 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18864 return pyobj;
18865 }
18866
18867
18868 static int _wrap_WHITE_PEN_set(PyObject *) {
18869 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18870 return 1;
18871 }
18872
18873
18874 static PyObject *_wrap_WHITE_PEN_get(void) {
18875 PyObject *pyobj;
18876
18877 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18878 return pyobj;
18879 }
18880
18881
18882 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18883 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18884 return 1;
18885 }
18886
18887
18888 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18889 PyObject *pyobj;
18890
18891 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18892 return pyobj;
18893 }
18894
18895
18896 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18897 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18898 return 1;
18899 }
18900
18901
18902 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18903 PyObject *pyobj;
18904
18905 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18906 return pyobj;
18907 }
18908
18909
18910 static int _wrap_GREY_PEN_set(PyObject *) {
18911 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18912 return 1;
18913 }
18914
18915
18916 static PyObject *_wrap_GREY_PEN_get(void) {
18917 PyObject *pyobj;
18918
18919 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18920 return pyobj;
18921 }
18922
18923
18924 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18925 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18926 return 1;
18927 }
18928
18929
18930 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18931 PyObject *pyobj;
18932
18933 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18934 return pyobj;
18935 }
18936
18937
18938 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18939 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18940 return 1;
18941 }
18942
18943
18944 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18945 PyObject *pyobj;
18946
18947 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18948 return pyobj;
18949 }
18950
18951
18952 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18953 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18954 return 1;
18955 }
18956
18957
18958 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18959 PyObject *pyobj;
18960
18961 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18962 return pyobj;
18963 }
18964
18965
18966 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18967 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18968 return 1;
18969 }
18970
18971
18972 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18973 PyObject *pyobj;
18974
18975 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18976 return pyobj;
18977 }
18978
18979
18980 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18981 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18982 return 1;
18983 }
18984
18985
18986 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18987 PyObject *pyobj;
18988
18989 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18990 return pyobj;
18991 }
18992
18993
18994 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18995 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18996 return 1;
18997 }
18998
18999
19000 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19001 PyObject *pyobj;
19002
19003 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19004 return pyobj;
19005 }
19006
19007
19008 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19009 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19010 return 1;
19011 }
19012
19013
19014 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19015 PyObject *pyobj;
19016
19017 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19018 return pyobj;
19019 }
19020
19021
19022 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19023 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19024 return 1;
19025 }
19026
19027
19028 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19029 PyObject *pyobj;
19030
19031 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19032 return pyobj;
19033 }
19034
19035
19036 static int _wrap_RED_BRUSH_set(PyObject *) {
19037 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19038 return 1;
19039 }
19040
19041
19042 static PyObject *_wrap_RED_BRUSH_get(void) {
19043 PyObject *pyobj;
19044
19045 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19046 return pyobj;
19047 }
19048
19049
19050 static int _wrap_GREY_BRUSH_set(PyObject *) {
19051 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19052 return 1;
19053 }
19054
19055
19056 static PyObject *_wrap_GREY_BRUSH_get(void) {
19057 PyObject *pyobj;
19058
19059 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19060 return pyobj;
19061 }
19062
19063
19064 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19065 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19066 return 1;
19067 }
19068
19069
19070 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19071 PyObject *pyobj;
19072
19073 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19074 return pyobj;
19075 }
19076
19077
19078 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19079 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19080 return 1;
19081 }
19082
19083
19084 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19085 PyObject *pyobj;
19086
19087 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19088 return pyobj;
19089 }
19090
19091
19092 static int _wrap_BLACK_set(PyObject *) {
19093 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19094 return 1;
19095 }
19096
19097
19098 static PyObject *_wrap_BLACK_get(void) {
19099 PyObject *pyobj;
19100
19101 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19102 return pyobj;
19103 }
19104
19105
19106 static int _wrap_WHITE_set(PyObject *) {
19107 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19108 return 1;
19109 }
19110
19111
19112 static PyObject *_wrap_WHITE_get(void) {
19113 PyObject *pyobj;
19114
19115 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19116 return pyobj;
19117 }
19118
19119
19120 static int _wrap_RED_set(PyObject *) {
19121 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19122 return 1;
19123 }
19124
19125
19126 static PyObject *_wrap_RED_get(void) {
19127 PyObject *pyobj;
19128
19129 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19130 return pyobj;
19131 }
19132
19133
19134 static int _wrap_BLUE_set(PyObject *) {
19135 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19136 return 1;
19137 }
19138
19139
19140 static PyObject *_wrap_BLUE_get(void) {
19141 PyObject *pyobj;
19142
19143 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19144 return pyobj;
19145 }
19146
19147
19148 static int _wrap_GREEN_set(PyObject *) {
19149 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19150 return 1;
19151 }
19152
19153
19154 static PyObject *_wrap_GREEN_get(void) {
19155 PyObject *pyobj;
19156
19157 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19158 return pyobj;
19159 }
19160
19161
19162 static int _wrap_CYAN_set(PyObject *) {
19163 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19164 return 1;
19165 }
19166
19167
19168 static PyObject *_wrap_CYAN_get(void) {
19169 PyObject *pyobj;
19170
19171 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19172 return pyobj;
19173 }
19174
19175
19176 static int _wrap_LIGHT_GREY_set(PyObject *) {
19177 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19178 return 1;
19179 }
19180
19181
19182 static PyObject *_wrap_LIGHT_GREY_get(void) {
19183 PyObject *pyobj;
19184
19185 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19186 return pyobj;
19187 }
19188
19189
19190 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19191 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19192 return 1;
19193 }
19194
19195
19196 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19197 PyObject *pyobj;
19198
19199 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19200 return pyobj;
19201 }
19202
19203
19204 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19205 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19206 return 1;
19207 }
19208
19209
19210 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19211 PyObject *pyobj;
19212
19213 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19214 return pyobj;
19215 }
19216
19217
19218 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19219 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19220 return 1;
19221 }
19222
19223
19224 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19225 PyObject *pyobj;
19226
19227 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19228 return pyobj;
19229 }
19230
19231
19232 static int _wrap_NullBitmap_set(PyObject *) {
19233 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19234 return 1;
19235 }
19236
19237
19238 static PyObject *_wrap_NullBitmap_get(void) {
19239 PyObject *pyobj;
19240
19241 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19242 return pyobj;
19243 }
19244
19245
19246 static int _wrap_NullIcon_set(PyObject *) {
19247 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19248 return 1;
19249 }
19250
19251
19252 static PyObject *_wrap_NullIcon_get(void) {
19253 PyObject *pyobj;
19254
19255 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19256 return pyobj;
19257 }
19258
19259
19260 static int _wrap_NullCursor_set(PyObject *) {
19261 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19262 return 1;
19263 }
19264
19265
19266 static PyObject *_wrap_NullCursor_get(void) {
19267 PyObject *pyobj;
19268
19269 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19270 return pyobj;
19271 }
19272
19273
19274 static int _wrap_NullPen_set(PyObject *) {
19275 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19276 return 1;
19277 }
19278
19279
19280 static PyObject *_wrap_NullPen_get(void) {
19281 PyObject *pyobj;
19282
19283 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19284 return pyobj;
19285 }
19286
19287
19288 static int _wrap_NullBrush_set(PyObject *) {
19289 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19290 return 1;
19291 }
19292
19293
19294 static PyObject *_wrap_NullBrush_get(void) {
19295 PyObject *pyobj;
19296
19297 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19298 return pyobj;
19299 }
19300
19301
19302 static int _wrap_NullPalette_set(PyObject *) {
19303 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19304 return 1;
19305 }
19306
19307
19308 static PyObject *_wrap_NullPalette_get(void) {
19309 PyObject *pyobj;
19310
19311 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19312 return pyobj;
19313 }
19314
19315
19316 static int _wrap_NullFont_set(PyObject *) {
19317 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19318 return 1;
19319 }
19320
19321
19322 static PyObject *_wrap_NullFont_get(void) {
19323 PyObject *pyobj;
19324
19325 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19326 return pyobj;
19327 }
19328
19329
19330 static int _wrap_NullColour_set(PyObject *) {
19331 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19332 return 1;
19333 }
19334
19335
19336 static PyObject *_wrap_NullColour_get(void) {
19337 PyObject *pyobj;
19338
19339 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19340 return pyobj;
19341 }
19342
19343
19344 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19345 PyObject *resultobj;
19346 wxPenList *arg1 = (wxPenList *) 0 ;
19347 wxPen *arg2 = (wxPen *) 0 ;
19348 PyObject * obj0 = 0 ;
19349 PyObject * obj1 = 0 ;
19350 char *kwnames[] = {
19351 (char *) "self",(char *) "pen", NULL
19352 };
19353
19354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19356 if (SWIG_arg_fail(1)) SWIG_fail;
19357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19358 if (SWIG_arg_fail(2)) SWIG_fail;
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 (arg1)->AddPen(arg2);
19362
19363 wxPyEndAllowThreads(__tstate);
19364 if (PyErr_Occurred()) SWIG_fail;
19365 }
19366 Py_INCREF(Py_None); resultobj = Py_None;
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj;
19375 wxPenList *arg1 = (wxPenList *) 0 ;
19376 wxColour *arg2 = 0 ;
19377 int arg3 ;
19378 int arg4 ;
19379 wxPen *result;
19380 wxColour temp2 ;
19381 PyObject * obj0 = 0 ;
19382 PyObject * obj1 = 0 ;
19383 PyObject * obj2 = 0 ;
19384 PyObject * obj3 = 0 ;
19385 char *kwnames[] = {
19386 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19387 };
19388
19389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19391 if (SWIG_arg_fail(1)) SWIG_fail;
19392 {
19393 arg2 = &temp2;
19394 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19395 }
19396 {
19397 arg3 = (int)(SWIG_As_int(obj2));
19398 if (SWIG_arg_fail(3)) SWIG_fail;
19399 }
19400 {
19401 arg4 = (int)(SWIG_As_int(obj3));
19402 if (SWIG_arg_fail(4)) SWIG_fail;
19403 }
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19407
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj;
19420 wxPenList *arg1 = (wxPenList *) 0 ;
19421 wxPen *arg2 = (wxPen *) 0 ;
19422 PyObject * obj0 = 0 ;
19423 PyObject * obj1 = 0 ;
19424 char *kwnames[] = {
19425 (char *) "self",(char *) "pen", NULL
19426 };
19427
19428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 (arg1)->RemovePen(arg2);
19436
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 Py_INCREF(Py_None); resultobj = Py_None;
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj;
19449 wxPenList *arg1 = (wxPenList *) 0 ;
19450 int result;
19451 PyObject * obj0 = 0 ;
19452 char *kwnames[] = {
19453 (char *) "self", NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19458 if (SWIG_arg_fail(1)) SWIG_fail;
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (int)(arg1)->GetCount();
19462
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 {
19467 resultobj = SWIG_From_int((int)(result));
19468 }
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19476 PyObject *obj;
19477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19478 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19479 Py_INCREF(obj);
19480 return Py_BuildValue((char *)"");
19481 }
19482 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19483 PyObject *resultobj;
19484 wxBrushList *arg1 = (wxBrushList *) 0 ;
19485 wxBrush *arg2 = (wxBrush *) 0 ;
19486 PyObject * obj0 = 0 ;
19487 PyObject * obj1 = 0 ;
19488 char *kwnames[] = {
19489 (char *) "self",(char *) "brush", NULL
19490 };
19491
19492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19494 if (SWIG_arg_fail(1)) SWIG_fail;
19495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19496 if (SWIG_arg_fail(2)) SWIG_fail;
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 (arg1)->AddBrush(arg2);
19500
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 Py_INCREF(Py_None); resultobj = Py_None;
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj;
19513 wxBrushList *arg1 = (wxBrushList *) 0 ;
19514 wxColour *arg2 = 0 ;
19515 int arg3 = (int) wxSOLID ;
19516 wxBrush *result;
19517 wxColour temp2 ;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 PyObject * obj2 = 0 ;
19521 char *kwnames[] = {
19522 (char *) "self",(char *) "colour",(char *) "style", NULL
19523 };
19524
19525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19527 if (SWIG_arg_fail(1)) SWIG_fail;
19528 {
19529 arg2 = &temp2;
19530 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19531 }
19532 if (obj2) {
19533 {
19534 arg3 = (int)(SWIG_As_int(obj2));
19535 if (SWIG_arg_fail(3)) SWIG_fail;
19536 }
19537 }
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19541
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19553 PyObject *resultobj;
19554 wxBrushList *arg1 = (wxBrushList *) 0 ;
19555 wxBrush *arg2 = (wxBrush *) 0 ;
19556 PyObject * obj0 = 0 ;
19557 PyObject * obj1 = 0 ;
19558 char *kwnames[] = {
19559 (char *) "self",(char *) "brush", NULL
19560 };
19561
19562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19566 if (SWIG_arg_fail(2)) SWIG_fail;
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 (arg1)->RemoveBrush(arg2);
19570
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 Py_INCREF(Py_None); resultobj = Py_None;
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj;
19583 wxBrushList *arg1 = (wxBrushList *) 0 ;
19584 int result;
19585 PyObject * obj0 = 0 ;
19586 char *kwnames[] = {
19587 (char *) "self", NULL
19588 };
19589
19590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19592 if (SWIG_arg_fail(1)) SWIG_fail;
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = (int)(arg1)->GetCount();
19596
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 {
19601 resultobj = SWIG_From_int((int)(result));
19602 }
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19610 PyObject *obj;
19611 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19612 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19613 Py_INCREF(obj);
19614 return Py_BuildValue((char *)"");
19615 }
19616 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj;
19618 wxColourDatabase *result;
19619 char *kwnames[] = {
19620 NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19624 {
19625 if (!wxPyCheckForApp()) SWIG_fail;
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 result = (wxColourDatabase *)new wxColourDatabase();
19628
19629 wxPyEndAllowThreads(__tstate);
19630 if (PyErr_Occurred()) SWIG_fail;
19631 }
19632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19633 return resultobj;
19634 fail:
19635 return NULL;
19636 }
19637
19638
19639 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19640 PyObject *resultobj;
19641 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19642 PyObject * obj0 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "self", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19649 if (SWIG_arg_fail(1)) SWIG_fail;
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 delete arg1;
19653
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 Py_INCREF(Py_None); resultobj = Py_None;
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj;
19666 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19667 wxString *arg2 = 0 ;
19668 wxColour result;
19669 bool temp2 = false ;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self",(char *) "name", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 arg2 = wxString_in_helper(obj1);
19681 if (arg2 == NULL) SWIG_fail;
19682 temp2 = true;
19683 }
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 wxColour * resultptr;
19693 resultptr = new wxColour((wxColour &)(result));
19694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19695 }
19696 {
19697 if (temp2)
19698 delete arg2;
19699 }
19700 return resultobj;
19701 fail:
19702 {
19703 if (temp2)
19704 delete arg2;
19705 }
19706 return NULL;
19707 }
19708
19709
19710 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19711 PyObject *resultobj;
19712 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19713 wxColour *arg2 = 0 ;
19714 wxString result;
19715 wxColour temp2 ;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 char *kwnames[] = {
19719 (char *) "self",(char *) "colour", NULL
19720 };
19721
19722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19724 if (SWIG_arg_fail(1)) SWIG_fail;
19725 {
19726 arg2 = &temp2;
19727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19732
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 {
19737 #if wxUSE_UNICODE
19738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19739 #else
19740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19741 #endif
19742 }
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19752 wxString *arg2 = 0 ;
19753 wxColour *arg3 = 0 ;
19754 bool temp2 = false ;
19755 wxColour temp3 ;
19756 PyObject * obj0 = 0 ;
19757 PyObject * obj1 = 0 ;
19758 PyObject * obj2 = 0 ;
19759 char *kwnames[] = {
19760 (char *) "self",(char *) "name",(char *) "colour", NULL
19761 };
19762
19763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19765 if (SWIG_arg_fail(1)) SWIG_fail;
19766 {
19767 arg2 = wxString_in_helper(obj1);
19768 if (arg2 == NULL) SWIG_fail;
19769 temp2 = true;
19770 }
19771 {
19772 arg3 = &temp3;
19773 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19774 }
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19778
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 Py_INCREF(Py_None); resultobj = Py_None;
19783 {
19784 if (temp2)
19785 delete arg2;
19786 }
19787 return resultobj;
19788 fail:
19789 {
19790 if (temp2)
19791 delete arg2;
19792 }
19793 return NULL;
19794 }
19795
19796
19797 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19798 PyObject *resultobj;
19799 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19800 wxString *arg2 = 0 ;
19801 int arg3 ;
19802 int arg4 ;
19803 int arg5 ;
19804 bool temp2 = false ;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 PyObject * obj2 = 0 ;
19808 PyObject * obj3 = 0 ;
19809 PyObject * obj4 = 0 ;
19810 char *kwnames[] = {
19811 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19812 };
19813
19814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19816 if (SWIG_arg_fail(1)) SWIG_fail;
19817 {
19818 arg2 = wxString_in_helper(obj1);
19819 if (arg2 == NULL) SWIG_fail;
19820 temp2 = true;
19821 }
19822 {
19823 arg3 = (int)(SWIG_As_int(obj2));
19824 if (SWIG_arg_fail(3)) SWIG_fail;
19825 }
19826 {
19827 arg4 = (int)(SWIG_As_int(obj3));
19828 if (SWIG_arg_fail(4)) SWIG_fail;
19829 }
19830 {
19831 arg5 = (int)(SWIG_As_int(obj4));
19832 if (SWIG_arg_fail(5)) SWIG_fail;
19833 }
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19837
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 Py_INCREF(Py_None); resultobj = Py_None;
19842 {
19843 if (temp2)
19844 delete arg2;
19845 }
19846 return resultobj;
19847 fail:
19848 {
19849 if (temp2)
19850 delete arg2;
19851 }
19852 return NULL;
19853 }
19854
19855
19856 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19857 PyObject *obj;
19858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19859 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19860 Py_INCREF(obj);
19861 return Py_BuildValue((char *)"");
19862 }
19863 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj;
19865 wxFontList *arg1 = (wxFontList *) 0 ;
19866 wxFont *arg2 = (wxFont *) 0 ;
19867 PyObject * obj0 = 0 ;
19868 PyObject * obj1 = 0 ;
19869 char *kwnames[] = {
19870 (char *) "self",(char *) "font", NULL
19871 };
19872
19873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19875 if (SWIG_arg_fail(1)) SWIG_fail;
19876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19877 if (SWIG_arg_fail(2)) SWIG_fail;
19878 {
19879 PyThreadState* __tstate = wxPyBeginAllowThreads();
19880 (arg1)->AddFont(arg2);
19881
19882 wxPyEndAllowThreads(__tstate);
19883 if (PyErr_Occurred()) SWIG_fail;
19884 }
19885 Py_INCREF(Py_None); resultobj = Py_None;
19886 return resultobj;
19887 fail:
19888 return NULL;
19889 }
19890
19891
19892 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19893 PyObject *resultobj;
19894 wxFontList *arg1 = (wxFontList *) 0 ;
19895 int arg2 ;
19896 int arg3 ;
19897 int arg4 ;
19898 int arg5 ;
19899 bool arg6 = (bool) false ;
19900 wxString const &arg7_defvalue = wxPyEmptyString ;
19901 wxString *arg7 = (wxString *) &arg7_defvalue ;
19902 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19903 wxFont *result;
19904 bool temp7 = false ;
19905 PyObject * obj0 = 0 ;
19906 PyObject * obj1 = 0 ;
19907 PyObject * obj2 = 0 ;
19908 PyObject * obj3 = 0 ;
19909 PyObject * obj4 = 0 ;
19910 PyObject * obj5 = 0 ;
19911 PyObject * obj6 = 0 ;
19912 PyObject * obj7 = 0 ;
19913 char *kwnames[] = {
19914 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19915 };
19916
19917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19919 if (SWIG_arg_fail(1)) SWIG_fail;
19920 {
19921 arg2 = (int)(SWIG_As_int(obj1));
19922 if (SWIG_arg_fail(2)) SWIG_fail;
19923 }
19924 {
19925 arg3 = (int)(SWIG_As_int(obj2));
19926 if (SWIG_arg_fail(3)) SWIG_fail;
19927 }
19928 {
19929 arg4 = (int)(SWIG_As_int(obj3));
19930 if (SWIG_arg_fail(4)) SWIG_fail;
19931 }
19932 {
19933 arg5 = (int)(SWIG_As_int(obj4));
19934 if (SWIG_arg_fail(5)) SWIG_fail;
19935 }
19936 if (obj5) {
19937 {
19938 arg6 = (bool)(SWIG_As_bool(obj5));
19939 if (SWIG_arg_fail(6)) SWIG_fail;
19940 }
19941 }
19942 if (obj6) {
19943 {
19944 arg7 = wxString_in_helper(obj6);
19945 if (arg7 == NULL) SWIG_fail;
19946 temp7 = true;
19947 }
19948 }
19949 if (obj7) {
19950 {
19951 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19952 if (SWIG_arg_fail(8)) SWIG_fail;
19953 }
19954 }
19955 {
19956 PyThreadState* __tstate = wxPyBeginAllowThreads();
19957 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19958
19959 wxPyEndAllowThreads(__tstate);
19960 if (PyErr_Occurred()) SWIG_fail;
19961 }
19962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19963 {
19964 if (temp7)
19965 delete arg7;
19966 }
19967 return resultobj;
19968 fail:
19969 {
19970 if (temp7)
19971 delete arg7;
19972 }
19973 return NULL;
19974 }
19975
19976
19977 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj;
19979 wxFontList *arg1 = (wxFontList *) 0 ;
19980 wxFont *arg2 = (wxFont *) 0 ;
19981 PyObject * obj0 = 0 ;
19982 PyObject * obj1 = 0 ;
19983 char *kwnames[] = {
19984 (char *) "self",(char *) "font", NULL
19985 };
19986
19987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19989 if (SWIG_arg_fail(1)) SWIG_fail;
19990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19991 if (SWIG_arg_fail(2)) SWIG_fail;
19992 {
19993 PyThreadState* __tstate = wxPyBeginAllowThreads();
19994 (arg1)->RemoveFont(arg2);
19995
19996 wxPyEndAllowThreads(__tstate);
19997 if (PyErr_Occurred()) SWIG_fail;
19998 }
19999 Py_INCREF(Py_None); resultobj = Py_None;
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20007 PyObject *resultobj;
20008 wxFontList *arg1 = (wxFontList *) 0 ;
20009 int result;
20010 PyObject * obj0 = 0 ;
20011 char *kwnames[] = {
20012 (char *) "self", NULL
20013 };
20014
20015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20017 if (SWIG_arg_fail(1)) SWIG_fail;
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 result = (int)(arg1)->GetCount();
20021
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 {
20026 resultobj = SWIG_From_int((int)(result));
20027 }
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20035 PyObject *obj;
20036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20037 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20038 Py_INCREF(obj);
20039 return Py_BuildValue((char *)"");
20040 }
20041 static int _wrap_TheFontList_set(PyObject *) {
20042 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20043 return 1;
20044 }
20045
20046
20047 static PyObject *_wrap_TheFontList_get(void) {
20048 PyObject *pyobj;
20049
20050 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20051 return pyobj;
20052 }
20053
20054
20055 static int _wrap_ThePenList_set(PyObject *) {
20056 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20057 return 1;
20058 }
20059
20060
20061 static PyObject *_wrap_ThePenList_get(void) {
20062 PyObject *pyobj;
20063
20064 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20065 return pyobj;
20066 }
20067
20068
20069 static int _wrap_TheBrushList_set(PyObject *) {
20070 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20071 return 1;
20072 }
20073
20074
20075 static PyObject *_wrap_TheBrushList_get(void) {
20076 PyObject *pyobj;
20077
20078 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20079 return pyobj;
20080 }
20081
20082
20083 static int _wrap_TheColourDatabase_set(PyObject *) {
20084 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20085 return 1;
20086 }
20087
20088
20089 static PyObject *_wrap_TheColourDatabase_get(void) {
20090 PyObject *pyobj;
20091
20092 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20093 return pyobj;
20094 }
20095
20096
20097 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20098 PyObject *resultobj;
20099 wxEffects *result;
20100 char *kwnames[] = {
20101 NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (wxEffects *)new wxEffects();
20108
20109 wxPyEndAllowThreads(__tstate);
20110 if (PyErr_Occurred()) SWIG_fail;
20111 }
20112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj;
20121 wxEffects *arg1 = (wxEffects *) 0 ;
20122 wxColour result;
20123 PyObject * obj0 = 0 ;
20124 char *kwnames[] = {
20125 (char *) "self", NULL
20126 };
20127
20128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20130 if (SWIG_arg_fail(1)) SWIG_fail;
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = ((wxEffects const *)arg1)->GetHighlightColour();
20134
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 wxColour * resultptr;
20140 resultptr = new wxColour((wxColour &)(result));
20141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20150 PyObject *resultobj;
20151 wxEffects *arg1 = (wxEffects *) 0 ;
20152 wxColour result;
20153 PyObject * obj0 = 0 ;
20154 char *kwnames[] = {
20155 (char *) "self", NULL
20156 };
20157
20158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(1)) SWIG_fail;
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = ((wxEffects const *)arg1)->GetLightShadow();
20164
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 {
20169 wxColour * resultptr;
20170 resultptr = new wxColour((wxColour &)(result));
20171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20172 }
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20180 PyObject *resultobj;
20181 wxEffects *arg1 = (wxEffects *) 0 ;
20182 wxColour result;
20183 PyObject * obj0 = 0 ;
20184 char *kwnames[] = {
20185 (char *) "self", NULL
20186 };
20187
20188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20190 if (SWIG_arg_fail(1)) SWIG_fail;
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = ((wxEffects const *)arg1)->GetFaceColour();
20194
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 {
20199 wxColour * resultptr;
20200 resultptr = new wxColour((wxColour &)(result));
20201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20202 }
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20210 PyObject *resultobj;
20211 wxEffects *arg1 = (wxEffects *) 0 ;
20212 wxColour result;
20213 PyObject * obj0 = 0 ;
20214 char *kwnames[] = {
20215 (char *) "self", NULL
20216 };
20217
20218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20220 if (SWIG_arg_fail(1)) SWIG_fail;
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = ((wxEffects const *)arg1)->GetMediumShadow();
20224
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 wxColour * resultptr;
20230 resultptr = new wxColour((wxColour &)(result));
20231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxEffects *arg1 = (wxEffects *) 0 ;
20242 wxColour result;
20243 PyObject * obj0 = 0 ;
20244 char *kwnames[] = {
20245 (char *) "self", NULL
20246 };
20247
20248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20250 if (SWIG_arg_fail(1)) SWIG_fail;
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 result = ((wxEffects const *)arg1)->GetDarkShadow();
20254
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 {
20259 wxColour * resultptr;
20260 resultptr = new wxColour((wxColour &)(result));
20261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxEffects *arg1 = (wxEffects *) 0 ;
20272 wxColour *arg2 = 0 ;
20273 wxColour temp2 ;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 char *kwnames[] = {
20277 (char *) "self",(char *) "c", NULL
20278 };
20279
20280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20282 if (SWIG_arg_fail(1)) SWIG_fail;
20283 {
20284 arg2 = &temp2;
20285 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20286 }
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20290
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 Py_INCREF(Py_None); resultobj = Py_None;
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj;
20303 wxEffects *arg1 = (wxEffects *) 0 ;
20304 wxColour *arg2 = 0 ;
20305 wxColour temp2 ;
20306 PyObject * obj0 = 0 ;
20307 PyObject * obj1 = 0 ;
20308 char *kwnames[] = {
20309 (char *) "self",(char *) "c", NULL
20310 };
20311
20312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20314 if (SWIG_arg_fail(1)) SWIG_fail;
20315 {
20316 arg2 = &temp2;
20317 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20318 }
20319 {
20320 PyThreadState* __tstate = wxPyBeginAllowThreads();
20321 (arg1)->SetLightShadow((wxColour const &)*arg2);
20322
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 Py_INCREF(Py_None); resultobj = Py_None;
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj;
20335 wxEffects *arg1 = (wxEffects *) 0 ;
20336 wxColour *arg2 = 0 ;
20337 wxColour temp2 ;
20338 PyObject * obj0 = 0 ;
20339 PyObject * obj1 = 0 ;
20340 char *kwnames[] = {
20341 (char *) "self",(char *) "c", NULL
20342 };
20343
20344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20346 if (SWIG_arg_fail(1)) SWIG_fail;
20347 {
20348 arg2 = &temp2;
20349 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20350 }
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 (arg1)->SetFaceColour((wxColour const &)*arg2);
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 Py_INCREF(Py_None); resultobj = Py_None;
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj;
20367 wxEffects *arg1 = (wxEffects *) 0 ;
20368 wxColour *arg2 = 0 ;
20369 wxColour temp2 ;
20370 PyObject * obj0 = 0 ;
20371 PyObject * obj1 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self",(char *) "c", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, 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 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 Py_INCREF(Py_None); resultobj = Py_None;
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj;
20399 wxEffects *arg1 = (wxEffects *) 0 ;
20400 wxColour *arg2 = 0 ;
20401 wxColour temp2 ;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self",(char *) "c", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 arg2 = &temp2;
20413 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 Py_INCREF(Py_None); resultobj = Py_None;
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20430 PyObject *resultobj;
20431 wxEffects *arg1 = (wxEffects *) 0 ;
20432 wxColour *arg2 = 0 ;
20433 wxColour *arg3 = 0 ;
20434 wxColour *arg4 = 0 ;
20435 wxColour *arg5 = 0 ;
20436 wxColour *arg6 = 0 ;
20437 wxColour temp2 ;
20438 wxColour temp3 ;
20439 wxColour temp4 ;
20440 wxColour temp5 ;
20441 wxColour temp6 ;
20442 PyObject * obj0 = 0 ;
20443 PyObject * obj1 = 0 ;
20444 PyObject * obj2 = 0 ;
20445 PyObject * obj3 = 0 ;
20446 PyObject * obj4 = 0 ;
20447 PyObject * obj5 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20454 if (SWIG_arg_fail(1)) SWIG_fail;
20455 {
20456 arg2 = &temp2;
20457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20458 }
20459 {
20460 arg3 = &temp3;
20461 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20462 }
20463 {
20464 arg4 = &temp4;
20465 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20466 }
20467 {
20468 arg5 = &temp5;
20469 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20470 }
20471 {
20472 arg6 = &temp6;
20473 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20474 }
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20478
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 Py_INCREF(Py_None); resultobj = Py_None;
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj;
20491 wxEffects *arg1 = (wxEffects *) 0 ;
20492 wxDC *arg2 = 0 ;
20493 wxRect *arg3 = 0 ;
20494 int arg4 = (int) 1 ;
20495 wxRect temp3 ;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 PyObject * obj2 = 0 ;
20499 PyObject * obj3 = 0 ;
20500 char *kwnames[] = {
20501 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20502 };
20503
20504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20506 if (SWIG_arg_fail(1)) SWIG_fail;
20507 {
20508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20509 if (SWIG_arg_fail(2)) SWIG_fail;
20510 if (arg2 == NULL) {
20511 SWIG_null_ref("wxDC");
20512 }
20513 if (SWIG_arg_fail(2)) SWIG_fail;
20514 }
20515 {
20516 arg3 = &temp3;
20517 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20518 }
20519 if (obj3) {
20520 {
20521 arg4 = (int)(SWIG_As_int(obj3));
20522 if (SWIG_arg_fail(4)) SWIG_fail;
20523 }
20524 }
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20528
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 Py_INCREF(Py_None); resultobj = Py_None;
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20540 PyObject *resultobj;
20541 wxEffects *arg1 = (wxEffects *) 0 ;
20542 wxRect *arg2 = 0 ;
20543 wxDC *arg3 = 0 ;
20544 wxBitmap *arg4 = 0 ;
20545 bool result;
20546 wxRect temp2 ;
20547 PyObject * obj0 = 0 ;
20548 PyObject * obj1 = 0 ;
20549 PyObject * obj2 = 0 ;
20550 PyObject * obj3 = 0 ;
20551 char *kwnames[] = {
20552 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20553 };
20554
20555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20557 if (SWIG_arg_fail(1)) SWIG_fail;
20558 {
20559 arg2 = &temp2;
20560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20561 }
20562 {
20563 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20564 if (SWIG_arg_fail(3)) SWIG_fail;
20565 if (arg3 == NULL) {
20566 SWIG_null_ref("wxDC");
20567 }
20568 if (SWIG_arg_fail(3)) SWIG_fail;
20569 }
20570 {
20571 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20572 if (SWIG_arg_fail(4)) SWIG_fail;
20573 if (arg4 == NULL) {
20574 SWIG_null_ref("wxBitmap");
20575 }
20576 if (SWIG_arg_fail(4)) SWIG_fail;
20577 }
20578 {
20579 PyThreadState* __tstate = wxPyBeginAllowThreads();
20580 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20581
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 {
20586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20587 }
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20595 PyObject *obj;
20596 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20597 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20598 Py_INCREF(obj);
20599 return Py_BuildValue((char *)"");
20600 }
20601 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20602 PyObject *resultobj;
20603 int arg1 ;
20604 int arg2 ;
20605 bool arg3 ;
20606 wxSplitterRenderParams *result;
20607 PyObject * obj0 = 0 ;
20608 PyObject * obj1 = 0 ;
20609 PyObject * obj2 = 0 ;
20610 char *kwnames[] = {
20611 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
20612 };
20613
20614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
20615 {
20616 arg1 = (int)(SWIG_As_int(obj0));
20617 if (SWIG_arg_fail(1)) SWIG_fail;
20618 }
20619 {
20620 arg2 = (int)(SWIG_As_int(obj1));
20621 if (SWIG_arg_fail(2)) SWIG_fail;
20622 }
20623 {
20624 arg3 = (bool)(SWIG_As_bool(obj2));
20625 if (SWIG_arg_fail(3)) SWIG_fail;
20626 }
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
20630
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20642 PyObject *resultobj;
20643 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20644 PyObject * obj0 = 0 ;
20645 char *kwnames[] = {
20646 (char *) "self", NULL
20647 };
20648
20649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
20650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20651 if (SWIG_arg_fail(1)) SWIG_fail;
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 delete arg1;
20655
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 Py_INCREF(Py_None); resultobj = Py_None;
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
20667 PyObject *resultobj;
20668 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20669 int result;
20670 PyObject * obj0 = 0 ;
20671 char *kwnames[] = {
20672 (char *) "self", NULL
20673 };
20674
20675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
20676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20677 if (SWIG_arg_fail(1)) SWIG_fail;
20678 result = (int)(int) ((arg1)->widthSash);
20679
20680 {
20681 resultobj = SWIG_From_int((int)(result));
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
20690 PyObject *resultobj;
20691 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20692 int result;
20693 PyObject * obj0 = 0 ;
20694 char *kwnames[] = {
20695 (char *) "self", NULL
20696 };
20697
20698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
20699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20700 if (SWIG_arg_fail(1)) SWIG_fail;
20701 result = (int)(int) ((arg1)->border);
20702
20703 {
20704 resultobj = SWIG_From_int((int)(result));
20705 }
20706 return resultobj;
20707 fail:
20708 return NULL;
20709 }
20710
20711
20712 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
20713 PyObject *resultobj;
20714 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20715 bool result;
20716 PyObject * obj0 = 0 ;
20717 char *kwnames[] = {
20718 (char *) "self", NULL
20719 };
20720
20721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
20722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20723 if (SWIG_arg_fail(1)) SWIG_fail;
20724 result = (bool)(bool) ((arg1)->isHotSensitive);
20725
20726 {
20727 resultobj = SWIG_From_bool((bool)(result));
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
20736 PyObject *obj;
20737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20738 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
20739 Py_INCREF(obj);
20740 return Py_BuildValue((char *)"");
20741 }
20742 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj;
20744 int arg1 ;
20745 int arg2 ;
20746 wxRendererVersion *result;
20747 PyObject * obj0 = 0 ;
20748 PyObject * obj1 = 0 ;
20749 char *kwnames[] = {
20750 (char *) "version_",(char *) "age_", NULL
20751 };
20752
20753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
20754 {
20755 arg1 = (int)(SWIG_As_int(obj0));
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 }
20758 {
20759 arg2 = (int)(SWIG_As_int(obj1));
20760 if (SWIG_arg_fail(2)) SWIG_fail;
20761 }
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20777 PyObject *resultobj;
20778 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20779 PyObject * obj0 = 0 ;
20780 char *kwnames[] = {
20781 (char *) "self", NULL
20782 };
20783
20784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
20785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20786 if (SWIG_arg_fail(1)) SWIG_fail;
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 delete arg1;
20790
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 Py_INCREF(Py_None); resultobj = Py_None;
20795 return resultobj;
20796 fail:
20797 return NULL;
20798 }
20799
20800
20801 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
20802 PyObject *resultobj;
20803 wxRendererVersion *arg1 = 0 ;
20804 bool result;
20805 PyObject * obj0 = 0 ;
20806 char *kwnames[] = {
20807 (char *) "ver", NULL
20808 };
20809
20810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
20811 {
20812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20813 if (SWIG_arg_fail(1)) SWIG_fail;
20814 if (arg1 == NULL) {
20815 SWIG_null_ref("wxRendererVersion");
20816 }
20817 if (SWIG_arg_fail(1)) SWIG_fail;
20818 }
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
20822
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20828 }
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20838 int result;
20839 PyObject * obj0 = 0 ;
20840 char *kwnames[] = {
20841 (char *) "self", NULL
20842 };
20843
20844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
20845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20846 if (SWIG_arg_fail(1)) SWIG_fail;
20847 result = (int)(int) ((arg1)->version);
20848
20849 {
20850 resultobj = SWIG_From_int((int)(result));
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20861 int result;
20862 PyObject * obj0 = 0 ;
20863 char *kwnames[] = {
20864 (char *) "self", NULL
20865 };
20866
20867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
20868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20869 if (SWIG_arg_fail(1)) SWIG_fail;
20870 result = (int)(int) ((arg1)->age);
20871
20872 {
20873 resultobj = SWIG_From_int((int)(result));
20874 }
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
20882 PyObject *obj;
20883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20884 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
20885 Py_INCREF(obj);
20886 return Py_BuildValue((char *)"");
20887 }
20888 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj;
20890 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20891 wxWindow *arg2 = (wxWindow *) 0 ;
20892 wxDC *arg3 = 0 ;
20893 wxRect *arg4 = 0 ;
20894 int arg5 = (int) 0 ;
20895 wxRect temp4 ;
20896 PyObject * obj0 = 0 ;
20897 PyObject * obj1 = 0 ;
20898 PyObject * obj2 = 0 ;
20899 PyObject * obj3 = 0 ;
20900 PyObject * obj4 = 0 ;
20901 char *kwnames[] = {
20902 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
20903 };
20904
20905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(1)) SWIG_fail;
20908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20909 if (SWIG_arg_fail(2)) SWIG_fail;
20910 {
20911 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20912 if (SWIG_arg_fail(3)) SWIG_fail;
20913 if (arg3 == NULL) {
20914 SWIG_null_ref("wxDC");
20915 }
20916 if (SWIG_arg_fail(3)) SWIG_fail;
20917 }
20918 {
20919 arg4 = &temp4;
20920 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20921 }
20922 if (obj4) {
20923 {
20924 arg5 = (int)(SWIG_As_int(obj4));
20925 if (SWIG_arg_fail(5)) SWIG_fail;
20926 }
20927 }
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
20931
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 Py_INCREF(Py_None); resultobj = Py_None;
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20945 wxWindow *arg2 = (wxWindow *) 0 ;
20946 wxDC *arg3 = 0 ;
20947 wxRect *arg4 = 0 ;
20948 int arg5 = (int) 0 ;
20949 wxRect temp4 ;
20950 PyObject * obj0 = 0 ;
20951 PyObject * obj1 = 0 ;
20952 PyObject * obj2 = 0 ;
20953 PyObject * obj3 = 0 ;
20954 PyObject * obj4 = 0 ;
20955 char *kwnames[] = {
20956 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
20957 };
20958
20959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
20961 if (SWIG_arg_fail(1)) SWIG_fail;
20962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(2)) SWIG_fail;
20964 {
20965 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(3)) SWIG_fail;
20967 if (arg3 == NULL) {
20968 SWIG_null_ref("wxDC");
20969 }
20970 if (SWIG_arg_fail(3)) SWIG_fail;
20971 }
20972 {
20973 arg4 = &temp4;
20974 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20975 }
20976 if (obj4) {
20977 {
20978 arg5 = (int)(SWIG_As_int(obj4));
20979 if (SWIG_arg_fail(5)) SWIG_fail;
20980 }
20981 }
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 Py_INCREF(Py_None); resultobj = Py_None;
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj;
20998 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20999 wxWindow *arg2 = (wxWindow *) 0 ;
21000 wxDC *arg3 = 0 ;
21001 wxRect *arg4 = 0 ;
21002 int arg5 = (int) 0 ;
21003 wxRect temp4 ;
21004 PyObject * obj0 = 0 ;
21005 PyObject * obj1 = 0 ;
21006 PyObject * obj2 = 0 ;
21007 PyObject * obj3 = 0 ;
21008 PyObject * obj4 = 0 ;
21009 char *kwnames[] = {
21010 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21011 };
21012
21013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21015 if (SWIG_arg_fail(1)) SWIG_fail;
21016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21017 if (SWIG_arg_fail(2)) SWIG_fail;
21018 {
21019 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(3)) SWIG_fail;
21021 if (arg3 == NULL) {
21022 SWIG_null_ref("wxDC");
21023 }
21024 if (SWIG_arg_fail(3)) SWIG_fail;
21025 }
21026 {
21027 arg4 = &temp4;
21028 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21029 }
21030 if (obj4) {
21031 {
21032 arg5 = (int)(SWIG_As_int(obj4));
21033 if (SWIG_arg_fail(5)) SWIG_fail;
21034 }
21035 }
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 Py_INCREF(Py_None); resultobj = Py_None;
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21053 wxWindow *arg2 = (wxWindow *) 0 ;
21054 wxDC *arg3 = 0 ;
21055 wxSize *arg4 = 0 ;
21056 int arg5 ;
21057 wxOrientation arg6 ;
21058 int arg7 = (int) 0 ;
21059 wxSize temp4 ;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 PyObject * obj2 = 0 ;
21063 PyObject * obj3 = 0 ;
21064 PyObject * obj4 = 0 ;
21065 PyObject * obj5 = 0 ;
21066 PyObject * obj6 = 0 ;
21067 char *kwnames[] = {
21068 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21069 };
21070
21071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21073 if (SWIG_arg_fail(1)) SWIG_fail;
21074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(2)) SWIG_fail;
21076 {
21077 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21078 if (SWIG_arg_fail(3)) SWIG_fail;
21079 if (arg3 == NULL) {
21080 SWIG_null_ref("wxDC");
21081 }
21082 if (SWIG_arg_fail(3)) SWIG_fail;
21083 }
21084 {
21085 arg4 = &temp4;
21086 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21087 }
21088 {
21089 arg5 = (int)(SWIG_As_int(obj4));
21090 if (SWIG_arg_fail(5)) SWIG_fail;
21091 }
21092 {
21093 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21094 if (SWIG_arg_fail(6)) SWIG_fail;
21095 }
21096 if (obj6) {
21097 {
21098 arg7 = (int)(SWIG_As_int(obj6));
21099 if (SWIG_arg_fail(7)) SWIG_fail;
21100 }
21101 }
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 Py_INCREF(Py_None); resultobj = Py_None;
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21117 PyObject *resultobj;
21118 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21119 wxWindow *arg2 = (wxWindow *) 0 ;
21120 wxDC *arg3 = 0 ;
21121 wxRect *arg4 = 0 ;
21122 int arg5 = (int) 0 ;
21123 wxRect temp4 ;
21124 PyObject * obj0 = 0 ;
21125 PyObject * obj1 = 0 ;
21126 PyObject * obj2 = 0 ;
21127 PyObject * obj3 = 0 ;
21128 PyObject * obj4 = 0 ;
21129 char *kwnames[] = {
21130 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21131 };
21132
21133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21135 if (SWIG_arg_fail(1)) SWIG_fail;
21136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21137 if (SWIG_arg_fail(2)) SWIG_fail;
21138 {
21139 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21140 if (SWIG_arg_fail(3)) SWIG_fail;
21141 if (arg3 == NULL) {
21142 SWIG_null_ref("wxDC");
21143 }
21144 if (SWIG_arg_fail(3)) SWIG_fail;
21145 }
21146 {
21147 arg4 = &temp4;
21148 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21149 }
21150 if (obj4) {
21151 {
21152 arg5 = (int)(SWIG_As_int(obj4));
21153 if (SWIG_arg_fail(5)) SWIG_fail;
21154 }
21155 }
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 Py_INCREF(Py_None); resultobj = Py_None;
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21173 wxWindow *arg2 = (wxWindow *) 0 ;
21174 wxDC *arg3 = 0 ;
21175 wxRect *arg4 = 0 ;
21176 int arg5 = (int) 0 ;
21177 wxRect temp4 ;
21178 PyObject * obj0 = 0 ;
21179 PyObject * obj1 = 0 ;
21180 PyObject * obj2 = 0 ;
21181 PyObject * obj3 = 0 ;
21182 PyObject * obj4 = 0 ;
21183 char *kwnames[] = {
21184 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21185 };
21186
21187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21189 if (SWIG_arg_fail(1)) SWIG_fail;
21190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21191 if (SWIG_arg_fail(2)) SWIG_fail;
21192 {
21193 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21194 if (SWIG_arg_fail(3)) SWIG_fail;
21195 if (arg3 == NULL) {
21196 SWIG_null_ref("wxDC");
21197 }
21198 if (SWIG_arg_fail(3)) SWIG_fail;
21199 }
21200 {
21201 arg4 = &temp4;
21202 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21203 }
21204 if (obj4) {
21205 {
21206 arg5 = (int)(SWIG_As_int(obj4));
21207 if (SWIG_arg_fail(5)) SWIG_fail;
21208 }
21209 }
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 Py_INCREF(Py_None); resultobj = Py_None;
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
21225 PyObject *resultobj;
21226 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21227 wxWindow *arg2 = (wxWindow *) 0 ;
21228 SwigValueWrapper<wxSplitterRenderParams > result;
21229 PyObject * obj0 = 0 ;
21230 PyObject * obj1 = 0 ;
21231 char *kwnames[] = {
21232 (char *) "self",(char *) "win", NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
21236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21237 if (SWIG_arg_fail(1)) SWIG_fail;
21238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21239 if (SWIG_arg_fail(2)) SWIG_fail;
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
21243
21244 wxPyEndAllowThreads(__tstate);
21245 if (PyErr_Occurred()) SWIG_fail;
21246 }
21247 {
21248 wxSplitterRenderParams * resultptr;
21249 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
21250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 wxRendererNative *result;
21261 char *kwnames[] = {
21262 NULL
21263 };
21264
21265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
21266 {
21267 PyThreadState* __tstate = wxPyBeginAllowThreads();
21268 {
21269 wxRendererNative &_result_ref = wxRendererNative::Get();
21270 result = (wxRendererNative *) &_result_ref;
21271 }
21272
21273 wxPyEndAllowThreads(__tstate);
21274 if (PyErr_Occurred()) SWIG_fail;
21275 }
21276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
21284 PyObject *resultobj;
21285 wxRendererNative *result;
21286 char *kwnames[] = {
21287 NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 {
21294 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
21295 result = (wxRendererNative *) &_result_ref;
21296 }
21297
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
21309 PyObject *resultobj;
21310 wxRendererNative *result;
21311 char *kwnames[] = {
21312 NULL
21313 };
21314
21315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
21316 {
21317 PyThreadState* __tstate = wxPyBeginAllowThreads();
21318 {
21319 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
21320 result = (wxRendererNative *) &_result_ref;
21321 }
21322
21323 wxPyEndAllowThreads(__tstate);
21324 if (PyErr_Occurred()) SWIG_fail;
21325 }
21326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj;
21335 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21336 wxRendererNative *result;
21337 PyObject * obj0 = 0 ;
21338 char *kwnames[] = {
21339 (char *) "renderer", NULL
21340 };
21341
21342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
21343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21344 if (SWIG_arg_fail(1)) SWIG_fail;
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 result = (wxRendererNative *)wxRendererNative::Set(arg1);
21348
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj;
21361 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21362 SwigValueWrapper<wxRendererVersion > result;
21363 PyObject * obj0 = 0 ;
21364 char *kwnames[] = {
21365 (char *) "self", NULL
21366 };
21367
21368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
21369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21370 if (SWIG_arg_fail(1)) SWIG_fail;
21371 {
21372 PyThreadState* __tstate = wxPyBeginAllowThreads();
21373 result = ((wxRendererNative const *)arg1)->GetVersion();
21374
21375 wxPyEndAllowThreads(__tstate);
21376 if (PyErr_Occurred()) SWIG_fail;
21377 }
21378 {
21379 wxRendererVersion * resultptr;
21380 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
21381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
21390 PyObject *obj;
21391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21392 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
21393 Py_INCREF(obj);
21394 return Py_BuildValue((char *)"");
21395 }
21396 static PyMethodDef SwigMethods[] = {
21397 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21398 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21399 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21400 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21401 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21402 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21403 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21404 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21405 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21406 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21407 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21408 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21409 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21410 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21411 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21412 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21413 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21414 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21415 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21416 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21417 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21418 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21419 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21420 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21421 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21422 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21423 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21424 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21425 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21426 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21427 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21428 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21429 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21430 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21431 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21432 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21433 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21434 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21435 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21436 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21437 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21438 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21439 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21440 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21441 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21442 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21443 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21444 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21445 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21446 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21447 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21448 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21449 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21450 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21451 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21452 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21453 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21454 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21455 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21456 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21457 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21458 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21459 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21460 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21461 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21462 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21463 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21464 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21465 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21466 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21467 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21468 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21469 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21470 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21471 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21472 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21473 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21474 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21475 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21476 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21477 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21478 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21479 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21480 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21481 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21482 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21483 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21484 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21485 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21486 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21487 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21488 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21489 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21490 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21491 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21492 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21493 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21494 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21495 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21496 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21497 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21498 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21499 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21500 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21501 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21502 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21503 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21504 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21505 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21506 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21507 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21508 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21509 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21510 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21511 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21512 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21513 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21514 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21515 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21516 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21517 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21518 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21519 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21520 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21521 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21522 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21523 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21524 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21525 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21526 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21527 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21528 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21530 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21533 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21538 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21540 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21546 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21548 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21550 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21554 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21556 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21557 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21564 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21569 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21570 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21573 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21579 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21591 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21592 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21594 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21603 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21623 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21665 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21673 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21680 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21702 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21704 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21712 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21775 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21817 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21832 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21840 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21842 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21844 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21845 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21848 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21850 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21855 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21857 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21859 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21861 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21863 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21864 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21868 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21869 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21871 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21873 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21875 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21880 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21884 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21888 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21889 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21890 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21892 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21894 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21895 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21899 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21900 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21901 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21903 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21905 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21906 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21907 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21911 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21913 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21920 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21921 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21922 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21923 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21924 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21925 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21926 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
21927 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
21928 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
21929 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
21930 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
21931 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
21932 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21933 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21934 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
21935 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
21936 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
21937 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
21938 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
21939 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
21940 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
21941 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
21942 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
21943 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
21944 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
21945 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21946 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
21947 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
21948 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21949 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21950 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
21951 { NULL, NULL, 0, NULL }
21952 };
21953
21954
21955 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21956
21957 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21958 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21959 }
21960 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21961 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21962 }
21963 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21964 return (void *)((wxGDIObject *) ((wxIcon *) x));
21965 }
21966 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21967 return (void *)((wxGDIObject *) ((wxPalette *) x));
21968 }
21969 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21970 return (void *)((wxGDIObject *) ((wxPen *) x));
21971 }
21972 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21973 return (void *)((wxGDIObject *) ((wxFont *) x));
21974 }
21975 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21976 return (void *)((wxGDIObject *) ((wxCursor *) x));
21977 }
21978 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21979 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21980 }
21981 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21982 return (void *)((wxGDIObject *) ((wxRegion *) x));
21983 }
21984 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21985 return (void *)((wxGDIObject *) ((wxBrush *) x));
21986 }
21987 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21988 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21989 }
21990 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21991 return (void *)((wxDC *) ((wxScreenDC *) x));
21992 }
21993 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21994 return (void *)((wxDC *) ((wxMirrorDC *) x));
21995 }
21996 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21997 return (void *)((wxDC *) ((wxMemoryDC *) x));
21998 }
21999 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22000 return (void *)((wxDC *) ((wxWindowDC *) x));
22001 }
22002 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22003 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22004 }
22005 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22006 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22007 }
22008 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22009 return (void *)((wxDC *) ((wxClientDC *) x));
22010 }
22011 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22012 return (void *)((wxDC *) ((wxPaintDC *) x));
22013 }
22014 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22015 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22016 }
22017 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22018 return (void *)((wxDC *) ((wxPrinterDC *) x));
22019 }
22020 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22021 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22022 }
22023 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22024 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22025 }
22026 static void *_p_wxPenTo_p_wxObject(void *x) {
22027 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22028 }
22029 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22030 return (void *)((wxObject *) ((wxRegionIterator *) x));
22031 }
22032 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22033 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22034 }
22035 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22036 return (void *)((wxObject *) ((wxSizerItem *) x));
22037 }
22038 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22039 return (void *)((wxObject *) ((wxColourDatabase *) x));
22040 }
22041 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22042 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22043 }
22044 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22045 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22046 }
22047 static void *_p_wxIconTo_p_wxObject(void *x) {
22048 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22049 }
22050 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22051 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22052 }
22053 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22054 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22055 }
22056 static void *_p_wxSizerTo_p_wxObject(void *x) {
22057 return (void *)((wxObject *) ((wxSizer *) x));
22058 }
22059 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22060 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22061 }
22062 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22063 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22064 }
22065 static void *_p_wxPenListTo_p_wxObject(void *x) {
22066 return (void *)((wxObject *) ((wxPenList *) x));
22067 }
22068 static void *_p_wxEventTo_p_wxObject(void *x) {
22069 return (void *)((wxObject *) ((wxEvent *) x));
22070 }
22071 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22072 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22073 }
22074 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22075 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22076 }
22077 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22078 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22079 }
22080 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22081 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22082 }
22083 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22084 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22085 }
22086 static void *_p_wxDCTo_p_wxObject(void *x) {
22087 return (void *)((wxObject *) ((wxDC *) x));
22088 }
22089 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22090 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22091 }
22092 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22093 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22094 }
22095 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22096 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22097 }
22098 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22099 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22100 }
22101 static void *_p_wxControlTo_p_wxObject(void *x) {
22102 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22103 }
22104 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22105 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22106 }
22107 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22108 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22109 }
22110 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22111 return (void *)((wxObject *) ((wxFSFile *) x));
22112 }
22113 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22114 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22115 }
22116 static void *_p_wxRegionTo_p_wxObject(void *x) {
22117 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22118 }
22119 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22120 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22121 }
22122 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22123 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22124 }
22125 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22126 return (void *)((wxObject *) ((wxGDIObject *) x));
22127 }
22128 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22129 return (void *)((wxObject *) ((wxEffects *) x));
22130 }
22131 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22132 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22133 }
22134 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22135 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22136 }
22137 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22138 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22139 }
22140 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22141 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22142 }
22143 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22144 return (void *)((wxObject *) ((wxMenuItem *) x));
22145 }
22146 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22147 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22148 }
22149 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22150 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22151 }
22152 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22153 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22154 }
22155 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22156 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22157 }
22158 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22159 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22160 }
22161 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22162 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22163 }
22164 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22165 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22166 }
22167 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22168 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22169 }
22170 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22171 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22172 }
22173 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22174 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22175 }
22176 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22177 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22178 }
22179 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22180 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22181 }
22182 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22183 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22184 }
22185 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22186 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22187 }
22188 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22189 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22190 }
22191 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22192 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22193 }
22194 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22195 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22196 }
22197 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22198 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22199 }
22200 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22201 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22202 }
22203 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22204 return (void *)((wxObject *) ((wxImageHandler *) x));
22205 }
22206 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22207 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22208 }
22209 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22210 return (void *)((wxObject *) ((wxEvtHandler *) x));
22211 }
22212 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22213 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22214 }
22215 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22216 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22217 }
22218 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22219 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22220 }
22221 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22222 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22223 }
22224 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22225 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22226 }
22227 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22228 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22229 }
22230 static void *_p_wxImageTo_p_wxObject(void *x) {
22231 return (void *)((wxObject *) ((wxImage *) x));
22232 }
22233 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22234 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22235 }
22236 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22237 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22238 }
22239 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22240 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22241 }
22242 static void *_p_wxImageListTo_p_wxObject(void *x) {
22243 return (void *)((wxObject *) ((wxImageList *) x));
22244 }
22245 static void *_p_wxCursorTo_p_wxObject(void *x) {
22246 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22247 }
22248 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22249 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22250 }
22251 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22252 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22253 }
22254 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22255 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22256 }
22257 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22258 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22259 }
22260 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22261 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22262 }
22263 static void *_p_wxWindowTo_p_wxObject(void *x) {
22264 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22265 }
22266 static void *_p_wxMenuTo_p_wxObject(void *x) {
22267 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22268 }
22269 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22270 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22271 }
22272 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22273 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22274 }
22275 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22276 return (void *)((wxObject *) ((wxBrushList *) x));
22277 }
22278 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22279 return (void *)((wxObject *) ((wxFileSystem *) x));
22280 }
22281 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22282 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22283 }
22284 static void *_p_wxMaskTo_p_wxObject(void *x) {
22285 return (void *)((wxObject *) ((wxMask *) x));
22286 }
22287 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22288 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22289 }
22290 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22291 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22292 }
22293 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22294 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22295 }
22296 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22297 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22298 }
22299 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22300 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22301 }
22302 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22303 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22304 }
22305 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22306 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22307 }
22308 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22309 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22310 }
22311 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22312 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22313 }
22314 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22315 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22316 }
22317 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22319 }
22320 static void *_p_wxFontTo_p_wxObject(void *x) {
22321 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22322 }
22323 static void *_p_wxBrushTo_p_wxObject(void *x) {
22324 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22325 }
22326 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22327 return (void *)((wxObject *) ((wxMetaFile *) x));
22328 }
22329 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22330 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22331 }
22332 static void *_p_wxColourTo_p_wxObject(void *x) {
22333 return (void *)((wxObject *) ((wxColour *) x));
22334 }
22335 static void *_p_wxFontListTo_p_wxObject(void *x) {
22336 return (void *)((wxObject *) ((wxFontList *) x));
22337 }
22338 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22339 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22340 }
22341 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22342 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22343 }
22344 static void *_p_wxControlTo_p_wxWindow(void *x) {
22345 return (void *)((wxWindow *) ((wxControl *) x));
22346 }
22347 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22348 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22349 }
22350 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22351 return (void *)((wxWindow *) ((wxMenuBar *) x));
22352 }
22353 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}};
22354 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}};
22355 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}};
22356 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}};
22357 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}};
22358 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}};
22359 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}};
22360 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}};
22361 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}};
22362 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}};
22363 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}};
22364 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}};
22365 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}};
22366 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}};
22367 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}};
22368 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}};
22369 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}};
22370 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}};
22371 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}};
22372 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}};
22373 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}};
22374 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}};
22375 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}};
22376 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}};
22377 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_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_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_wxImageHandler", _p_wxImageHandlerTo_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_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_wxXPMHandler", _p_wxXPMHandlerTo_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}};
22378 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}};
22379 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}};
22380 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}};
22381 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}};
22382 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}};
22383 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}};
22384 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}};
22385 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}};
22386 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}};
22387 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}};
22388 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}};
22389 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}};
22390 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}};
22391 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}};
22392 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}};
22393 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}};
22394 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}};
22395 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}};
22396 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}};
22397 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}};
22398 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}};
22399 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}};
22400 static swig_type_info _swigt__p_wxConfigBase[] = {{"_p_wxConfigBase", 0, "wxConfigBase *", 0, 0, 0, 0},{"_p_wxConfigBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22401 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}};
22402 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}};
22403 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}};
22404 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}};
22405 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}};
22406 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}};
22407 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}};
22408 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}};
22409 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}};
22410 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}};
22411 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}};
22412 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}};
22413 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}};
22414 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}};
22415 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}};
22416 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}};
22417 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}};
22418
22419 static swig_type_info *swig_types_initial[] = {
22420 _swigt__p_wxPostScriptDC,
22421 _swigt__p_wxBrush,
22422 _swigt__p_wxColour,
22423 _swigt__p_wxDC,
22424 _swigt__p_wxMirrorDC,
22425 _swigt__p_form_ops_t,
22426 _swigt__p_wxRendererVersion,
22427 _swigt__p_wxDuplexMode,
22428 _swigt__p_wxPyFontEnumerator,
22429 _swigt__p_char,
22430 _swigt__p_wxIconLocation,
22431 _swigt__p_wxImage,
22432 _swigt__p_wxMetaFileDC,
22433 _swigt__p_wxMask,
22434 _swigt__p_wxSize,
22435 _swigt__p_wxFont,
22436 _swigt__p_wxWindow,
22437 _swigt__p_double,
22438 _swigt__p_wxMemoryDC,
22439 _swigt__p_wxFontMapper,
22440 _swigt__p_wxEffects,
22441 _swigt__p_wxNativeEncodingInfo,
22442 _swigt__p_wxPalette,
22443 _swigt__p_wxBitmap,
22444 _swigt__p_wxObject,
22445 _swigt__p_wxRegionIterator,
22446 _swigt__p_wxRect,
22447 _swigt__p_wxPaperSize,
22448 _swigt__p_wxString,
22449 _swigt__unsigned_int,
22450 _swigt__p_unsigned_int,
22451 _swigt__p_wxPrinterDC,
22452 _swigt__p_wxIconBundle,
22453 _swigt__p_wxPoint,
22454 _swigt__p_wxDash,
22455 _swigt__p_wxScreenDC,
22456 _swigt__p_wxCursor,
22457 _swigt__p_wxClientDC,
22458 _swigt__p_wxBufferedDC,
22459 _swigt__p_wxImageList,
22460 _swigt__p_unsigned_char,
22461 _swigt__p_wxGDIObject,
22462 _swigt__p_wxIcon,
22463 _swigt__p_wxLocale,
22464 _swigt__ptrdiff_t,
22465 _swigt__std__ptrdiff_t,
22466 _swigt__p_wxRegion,
22467 _swigt__p_wxConfigBase,
22468 _swigt__p_wxLanguageInfo,
22469 _swigt__p_wxWindowDC,
22470 _swigt__p_wxPrintData,
22471 _swigt__p_wxBrushList,
22472 _swigt__p_wxFontList,
22473 _swigt__p_wxPen,
22474 _swigt__p_wxBufferedPaintDC,
22475 _swigt__p_wxPaintDC,
22476 _swigt__p_wxPenList,
22477 _swigt__p_int,
22478 _swigt__p_wxMetaFile,
22479 _swigt__p_wxRendererNative,
22480 _swigt__p_unsigned_long,
22481 _swigt__p_wxNativeFontInfo,
22482 _swigt__p_wxEncodingConverter,
22483 _swigt__p_wxSplitterRenderParams,
22484 _swigt__p_wxColourDatabase,
22485 0
22486 };
22487
22488
22489 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22490
22491 static swig_const_info swig_const_table[] = {
22492 {0, 0, 0, 0.0, 0, 0}};
22493
22494 #ifdef __cplusplus
22495 }
22496 #endif
22497
22498
22499 #ifdef __cplusplus
22500 extern "C" {
22501 #endif
22502
22503 /* Python-specific SWIG API */
22504 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22505 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22506 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22507
22508 /* -----------------------------------------------------------------------------
22509 * global variable support code.
22510 * ----------------------------------------------------------------------------- */
22511
22512 typedef struct swig_globalvar {
22513 char *name; /* Name of global variable */
22514 PyObject *(*get_attr)(); /* Return the current value */
22515 int (*set_attr)(PyObject *); /* Set the value */
22516 struct swig_globalvar *next;
22517 } swig_globalvar;
22518
22519 typedef struct swig_varlinkobject {
22520 PyObject_HEAD
22521 swig_globalvar *vars;
22522 } swig_varlinkobject;
22523
22524 static PyObject *
22525 swig_varlink_repr(swig_varlinkobject *v) {
22526 v = v;
22527 return PyString_FromString("<Swig global variables>");
22528 }
22529
22530 static int
22531 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22532 swig_globalvar *var;
22533 flags = flags;
22534 fprintf(fp,"Swig global variables { ");
22535 for (var = v->vars; var; var=var->next) {
22536 fprintf(fp,"%s", var->name);
22537 if (var->next) fprintf(fp,", ");
22538 }
22539 fprintf(fp," }\n");
22540 return 0;
22541 }
22542
22543 static PyObject *
22544 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22545 swig_globalvar *var = v->vars;
22546 while (var) {
22547 if (strcmp(var->name,n) == 0) {
22548 return (*var->get_attr)();
22549 }
22550 var = var->next;
22551 }
22552 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22553 return NULL;
22554 }
22555
22556 static int
22557 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22558 swig_globalvar *var = v->vars;
22559 while (var) {
22560 if (strcmp(var->name,n) == 0) {
22561 return (*var->set_attr)(p);
22562 }
22563 var = var->next;
22564 }
22565 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22566 return 1;
22567 }
22568
22569 static PyTypeObject varlinktype = {
22570 PyObject_HEAD_INIT(0)
22571 0, /* Number of items in variable part (ob_size) */
22572 (char *)"swigvarlink", /* Type name (tp_name) */
22573 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22574 0, /* Itemsize (tp_itemsize) */
22575 0, /* Deallocator (tp_dealloc) */
22576 (printfunc) swig_varlink_print, /* Print (tp_print) */
22577 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22578 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22579 0, /* tp_compare */
22580 (reprfunc) swig_varlink_repr, /* tp_repr */
22581 0, /* tp_as_number */
22582 0, /* tp_as_sequence */
22583 0, /* tp_as_mapping */
22584 0, /* tp_hash */
22585 0, /* tp_call */
22586 0, /* tp_str */
22587 0, /* tp_getattro */
22588 0, /* tp_setattro */
22589 0, /* tp_as_buffer */
22590 0, /* tp_flags */
22591 0, /* tp_doc */
22592 #if PY_VERSION_HEX >= 0x02000000
22593 0, /* tp_traverse */
22594 0, /* tp_clear */
22595 #endif
22596 #if PY_VERSION_HEX >= 0x02010000
22597 0, /* tp_richcompare */
22598 0, /* tp_weaklistoffset */
22599 #endif
22600 #if PY_VERSION_HEX >= 0x02020000
22601 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22602 #endif
22603 #if PY_VERSION_HEX >= 0x02030000
22604 0, /* tp_del */
22605 #endif
22606 #ifdef COUNT_ALLOCS
22607 0,0,0,0 /* tp_alloc -> tp_next */
22608 #endif
22609 };
22610
22611 /* Create a variable linking object for use later */
22612 static PyObject *
22613 SWIG_Python_newvarlink(void) {
22614 swig_varlinkobject *result = 0;
22615 result = PyMem_NEW(swig_varlinkobject,1);
22616 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22617 result->ob_type = &varlinktype;
22618 result->vars = 0;
22619 result->ob_refcnt = 0;
22620 Py_XINCREF((PyObject *) result);
22621 return ((PyObject*) result);
22622 }
22623
22624 static void
22625 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22626 swig_varlinkobject *v;
22627 swig_globalvar *gv;
22628 v= (swig_varlinkobject *) p;
22629 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22630 gv->name = (char *) malloc(strlen(name)+1);
22631 strcpy(gv->name,name);
22632 gv->get_attr = get_attr;
22633 gv->set_attr = set_attr;
22634 gv->next = v->vars;
22635 v->vars = gv;
22636 }
22637
22638 /* -----------------------------------------------------------------------------
22639 * constants/methods manipulation
22640 * ----------------------------------------------------------------------------- */
22641
22642 /* Install Constants */
22643 static void
22644 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22645 PyObject *obj = 0;
22646 size_t i;
22647 for (i = 0; constants[i].type; i++) {
22648 switch(constants[i].type) {
22649 case SWIG_PY_INT:
22650 obj = PyInt_FromLong(constants[i].lvalue);
22651 break;
22652 case SWIG_PY_FLOAT:
22653 obj = PyFloat_FromDouble(constants[i].dvalue);
22654 break;
22655 case SWIG_PY_STRING:
22656 if (constants[i].pvalue) {
22657 obj = PyString_FromString((char *) constants[i].pvalue);
22658 } else {
22659 Py_INCREF(Py_None);
22660 obj = Py_None;
22661 }
22662 break;
22663 case SWIG_PY_POINTER:
22664 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22665 break;
22666 case SWIG_PY_BINARY:
22667 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22668 break;
22669 default:
22670 obj = 0;
22671 break;
22672 }
22673 if (obj) {
22674 PyDict_SetItemString(d,constants[i].name,obj);
22675 Py_DECREF(obj);
22676 }
22677 }
22678 }
22679
22680 /* -----------------------------------------------------------------------------*/
22681 /* Fix SwigMethods to carry the callback ptrs when needed */
22682 /* -----------------------------------------------------------------------------*/
22683
22684 static void
22685 SWIG_Python_FixMethods(PyMethodDef *methods,
22686 swig_const_info *const_table,
22687 swig_type_info **types,
22688 swig_type_info **types_initial) {
22689 size_t i;
22690 for (i = 0; methods[i].ml_name; ++i) {
22691 char *c = methods[i].ml_doc;
22692 if (c && (c = strstr(c, "swig_ptr: "))) {
22693 int j;
22694 swig_const_info *ci = 0;
22695 char *name = c + 10;
22696 for (j = 0; const_table[j].type; j++) {
22697 if (strncmp(const_table[j].name, name,
22698 strlen(const_table[j].name)) == 0) {
22699 ci = &(const_table[j]);
22700 break;
22701 }
22702 }
22703 if (ci) {
22704 size_t shift = (ci->ptype) - types;
22705 swig_type_info *ty = types_initial[shift];
22706 size_t ldoc = (c - methods[i].ml_doc);
22707 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22708 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22709 char *buff = ndoc;
22710 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22711 strncpy(buff, methods[i].ml_doc, ldoc);
22712 buff += ldoc;
22713 strncpy(buff, "swig_ptr: ", 10);
22714 buff += 10;
22715 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22716 methods[i].ml_doc = ndoc;
22717 }
22718 }
22719 }
22720 }
22721
22722 /* -----------------------------------------------------------------------------*
22723 * Initialize type list
22724 * -----------------------------------------------------------------------------*/
22725
22726 #if PY_MAJOR_VERSION < 2
22727 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22728 is copied out of Python/modsupport.c in python version 2.3.4 */
22729 static int
22730 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22731 {
22732 PyObject *dict;
22733 if (!PyModule_Check(m)) {
22734 PyErr_SetString(PyExc_TypeError,
22735 "PyModule_AddObject() needs module as first arg");
22736 return -1;
22737 }
22738 if (!o) {
22739 PyErr_SetString(PyExc_TypeError,
22740 "PyModule_AddObject() needs non-NULL value");
22741 return -1;
22742 }
22743
22744 dict = PyModule_GetDict(m);
22745 if (dict == NULL) {
22746 /* Internal error -- modules must have a dict! */
22747 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22748 PyModule_GetName(m));
22749 return -1;
22750 }
22751 if (PyDict_SetItemString(dict, name, o))
22752 return -1;
22753 Py_DECREF(o);
22754 return 0;
22755 }
22756 #endif
22757
22758 static swig_type_info **
22759 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22760 static PyMethodDef swig_empty_runtime_method_table[] = {
22761 {
22762 NULL, NULL, 0, NULL
22763 }
22764 };/* Sentinel */
22765
22766 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22767 swig_empty_runtime_method_table);
22768 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22769 if (pointer && module) {
22770 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22771 }
22772 return type_list_handle;
22773 }
22774
22775 static swig_type_info **
22776 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22777 swig_type_info **type_pointer;
22778
22779 /* first check if module already created */
22780 type_pointer = SWIG_Python_GetTypeListHandle();
22781 if (type_pointer) {
22782 return type_pointer;
22783 } else {
22784 /* create a new module and variable */
22785 return SWIG_Python_SetTypeListHandle(type_list_handle);
22786 }
22787 }
22788
22789 #ifdef __cplusplus
22790 }
22791 #endif
22792
22793 /* -----------------------------------------------------------------------------*
22794 * Partial Init method
22795 * -----------------------------------------------------------------------------*/
22796
22797 #ifdef SWIG_LINK_RUNTIME
22798 #ifdef __cplusplus
22799 extern "C"
22800 #endif
22801 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22802 #endif
22803
22804 #ifdef __cplusplus
22805 extern "C"
22806 #endif
22807 SWIGEXPORT(void) SWIG_init(void) {
22808 static PyObject *SWIG_globals = 0;
22809 static int typeinit = 0;
22810 PyObject *m, *d;
22811 int i;
22812 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22813
22814 /* Fix SwigMethods to carry the callback ptrs when needed */
22815 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22816
22817 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22818 d = PyModule_GetDict(m);
22819
22820 if (!typeinit) {
22821 #ifdef SWIG_LINK_RUNTIME
22822 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22823 #else
22824 # ifndef SWIG_STATIC_RUNTIME
22825 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22826 # endif
22827 #endif
22828 for (i = 0; swig_types_initial[i]; i++) {
22829 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22830 }
22831 typeinit = 1;
22832 }
22833 SWIG_InstallConstants(d,swig_const_table);
22834
22835 {
22836 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22837 }
22838 {
22839 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22840 }
22841 {
22842 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22843 }
22844 {
22845 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22846 }
22847 {
22848 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22849 }
22850 {
22851 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22852 }
22853 {
22854 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22855 }
22856 {
22857 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22900 }
22901 {
22902 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22903 }
22904 {
22905 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22906 }
22907 {
22908 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22909 }
22910 {
22911 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22912 }
22913 {
22914 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22915 }
22916 {
22917 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22918 }
22919 {
22920 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22921 }
22922 {
22923 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22924 }
22925 {
22926 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22927 }
22928 {
22929 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22930 }
22931 {
22932 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22933 }
22934 {
22935 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22936 }
22937 {
22938 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22939 }
22940 {
22941 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22942 }
22943 {
22944 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22945 }
22946 {
22947 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22948 }
22949 {
22950 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22951 }
22952 {
22953 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22954 }
22955 {
22956 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22957 }
22958 {
22959 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22960 }
22961 {
22962 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22963 }
22964 {
22965 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22966 }
22967 {
22968 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22969 }
22970 {
22971 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22972 }
22973 {
22974 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22975 }
22976 {
22977 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22978 }
22979 {
22980 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22981 }
22982 {
22983 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22984 }
22985 {
22986 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22987 }
22988 {
22989 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22990 }
22991 {
22992 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22993 }
22994 {
22995 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22996 }
22997 {
22998 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22999 }
23000 {
23001 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23002 }
23003 {
23004 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23005 }
23006 {
23007 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23008 }
23009 {
23010 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23011 }
23012 {
23013 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23014 }
23015 {
23016 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23017 }
23018 {
23019 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23020 }
23021 {
23022 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23023 }
23024 {
23025 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23026 }
23027 {
23028 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23029 }
23030 {
23031 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23032 }
23033 {
23034 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23035 }
23036 {
23037 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23038 }
23039 {
23040 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23041 }
23042 {
23043 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23044 }
23045 {
23046 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23047 }
23048 {
23049 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23050 }
23051 {
23052 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23053 }
23054 {
23055 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23056 }
23057 {
23058 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23059 }
23060 {
23061 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23062 }
23063 {
23064 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23065 }
23066 {
23067 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23068 }
23069 {
23070 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23071 }
23072 {
23073 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23074 }
23075 {
23076 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23077 }
23078 {
23079 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23080 }
23081 {
23082 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23083 }
23084 {
23085 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23086 }
23087 {
23088 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23089 }
23090 {
23091 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23092 }
23093 {
23094 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23095 }
23096 {
23097 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23098 }
23099 {
23100 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23101 }
23102 {
23103 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23104 }
23105 {
23106 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23107 }
23108 {
23109 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23110 }
23111 {
23112 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23113 }
23114 {
23115 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23116 }
23117 {
23118 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23119 }
23120 {
23121 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23122 }
23123 {
23124 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23125 }
23126 {
23127 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23128 }
23129 {
23130 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23131 }
23132 {
23133 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23134 }
23135 {
23136 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23137 }
23138 {
23139 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23140 }
23141 {
23142 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23143 }
23144 {
23145 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23146 }
23147 {
23148 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23149 }
23150 {
23151 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23152 }
23153 {
23154 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23155 }
23156 {
23157 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23158 }
23159 {
23160 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23161 }
23162 {
23163 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23164 }
23165 {
23166 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23167 }
23168 {
23169 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23170 }
23171 {
23172 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23173 }
23174 {
23175 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23176 }
23177 {
23178 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23179 }
23180 {
23181 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23182 }
23183 {
23184 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23185 }
23186 {
23187 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23188 }
23189 {
23190 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23191 }
23192 {
23193 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23194 }
23195 {
23196 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23197 }
23198 {
23199 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23200 }
23201 {
23202 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23203 }
23204 {
23205 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23206 }
23207 {
23208 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23209 }
23210 {
23211 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23212 }
23213 {
23214 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23215 }
23216
23217 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23218
23219 {
23220 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23221 }
23222 {
23223 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23224 }
23225 {
23226 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23227 }
23228 {
23229 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23230 }
23231 {
23232 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23233 }
23234 {
23235 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23236 }
23237 {
23238 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23239 }
23240 {
23241 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23242 }
23243 {
23244 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23245 }
23246 {
23247 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23248 }
23249 {
23250 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23251 }
23252 {
23253 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23254 }
23255 {
23256 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23257 }
23258 {
23259 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23260 }
23261 {
23262 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23263 }
23264 {
23265 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23266 }
23267 {
23268 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23269 }
23270 {
23271 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23272 }
23273 {
23274 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23275 }
23276 {
23277 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23278 }
23279 {
23280 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23281 }
23282 {
23283 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23284 }
23285 {
23286 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23287 }
23288 {
23289 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23290 }
23291 {
23292 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23293 }
23294 {
23295 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23296 }
23297 {
23298 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23299 }
23300 {
23301 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23302 }
23303 {
23304 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23305 }
23306 {
23307 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23308 }
23309 {
23310 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23311 }
23312 {
23313 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23314 }
23315 {
23316 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23317 }
23318 {
23319 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23320 }
23321 {
23322 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23323 }
23324 {
23325 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23326 }
23327 {
23328 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23329 }
23330 {
23331 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23332 }
23333 {
23334 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23335 }
23336 {
23337 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23338 }
23339 {
23340 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23341 }
23342 {
23343 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23344 }
23345 {
23346 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23347 }
23348 {
23349 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23350 }
23351 {
23352 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23353 }
23354 {
23355 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23356 }
23357 {
23358 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23359 }
23360 {
23361 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23362 }
23363 {
23364 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23365 }
23366 {
23367 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23368 }
23369 {
23370 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23371 }
23372 {
23373 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23374 }
23375 {
23376 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23377 }
23378 {
23379 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23380 }
23381 {
23382 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23383 }
23384 {
23385 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23386 }
23387 {
23388 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23389 }
23390 {
23391 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23392 }
23393 {
23394 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23395 }
23396 {
23397 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23398 }
23399 {
23400 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23401 }
23402 {
23403 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23404 }
23405 {
23406 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23407 }
23408 {
23409 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23410 }
23411 {
23412 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23413 }
23414 {
23415 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23416 }
23417 {
23418 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23419 }
23420 {
23421 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23422 }
23423 {
23424 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23425 }
23426 {
23427 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23428 }
23429 {
23430 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23431 }
23432 {
23433 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23434 }
23435 {
23436 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23437 }
23438 {
23439 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23440 }
23441 {
23442 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23443 }
23444 {
23445 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23446 }
23447 {
23448 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23449 }
23450 {
23451 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23452 }
23453 {
23454 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23455 }
23456 {
23457 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23458 }
23459 {
23460 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23461 }
23462 {
23463 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23464 }
23465 {
23466 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23467 }
23468 {
23469 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23470 }
23471 {
23472 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23473 }
23474 {
23475 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23476 }
23477 {
23478 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23479 }
23480 {
23481 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23482 }
23483 {
23484 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23485 }
23486 {
23487 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23488 }
23489 {
23490 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23491 }
23492 {
23493 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23494 }
23495 {
23496 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23497 }
23498 {
23499 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23500 }
23501 {
23502 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23503 }
23504 {
23505 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23506 }
23507 {
23508 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23509 }
23510 {
23511 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23512 }
23513 {
23514 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23515 }
23516 {
23517 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23518 }
23519 {
23520 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23521 }
23522 {
23523 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23524 }
23525 {
23526 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23527 }
23528 {
23529 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23530 }
23531 {
23532 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23533 }
23534 {
23535 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23536 }
23537 {
23538 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23539 }
23540 {
23541 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23542 }
23543 {
23544 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23545 }
23546 {
23547 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23548 }
23549 {
23550 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23551 }
23552 {
23553 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23554 }
23555 {
23556 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23557 }
23558 {
23559 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23560 }
23561 {
23562 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23563 }
23564 {
23565 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23566 }
23567 {
23568 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23569 }
23570 {
23571 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23572 }
23573 {
23574 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23575 }
23576 {
23577 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23578 }
23579 {
23580 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23581 }
23582 {
23583 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23584 }
23585 {
23586 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23587 }
23588 {
23589 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23590 }
23591 {
23592 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23593 }
23594 {
23595 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23596 }
23597 {
23598 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23599 }
23600 {
23601 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23602 }
23603 {
23604 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23605 }
23606 {
23607 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23608 }
23609 {
23610 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23611 }
23612 {
23613 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23614 }
23615 {
23616 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23617 }
23618 {
23619 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23620 }
23621 {
23622 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23623 }
23624 {
23625 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23626 }
23627 {
23628 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23629 }
23630 {
23631 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23632 }
23633 {
23634 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23635 }
23636 {
23637 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23638 }
23639 {
23640 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23641 }
23642 {
23643 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23644 }
23645 {
23646 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23647 }
23648 {
23649 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23650 }
23651 {
23652 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23653 }
23654 {
23655 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23656 }
23657 {
23658 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23659 }
23660 {
23661 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23662 }
23663 {
23664 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23665 }
23666 {
23667 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23668 }
23669 {
23670 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23671 }
23672 {
23673 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23674 }
23675 {
23676 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23677 }
23678 {
23679 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23680 }
23681 {
23682 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23683 }
23684 {
23685 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23686 }
23687 {
23688 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23689 }
23690 {
23691 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23692 }
23693 {
23694 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23695 }
23696 {
23697 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23698 }
23699 {
23700 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23701 }
23702 {
23703 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23704 }
23705 {
23706 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23707 }
23708 {
23709 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23710 }
23711 {
23712 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23713 }
23714 {
23715 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23716 }
23717 {
23718 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23719 }
23720 {
23721 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23722 }
23723 {
23724 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23725 }
23726 {
23727 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23728 }
23729 {
23730 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23731 }
23732 {
23733 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23734 }
23735 {
23736 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23737 }
23738 {
23739 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23740 }
23741 {
23742 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23743 }
23744 {
23745 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23746 }
23747 {
23748 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23749 }
23750 {
23751 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23752 }
23753 {
23754 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23755 }
23756 {
23757 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23758 }
23759 {
23760 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23761 }
23762 {
23763 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23764 }
23765 {
23766 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23767 }
23768 {
23769 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23770 }
23771 {
23772 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23773 }
23774 {
23775 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23776 }
23777 {
23778 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23779 }
23780 {
23781 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23782 }
23783 {
23784 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23785 }
23786 {
23787 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23788 }
23789 {
23790 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23791 }
23792 {
23793 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23794 }
23795 {
23796 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23797 }
23798 {
23799 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23800 }
23801 {
23802 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23803 }
23804 {
23805 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23806 }
23807 {
23808 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23809 }
23810 {
23811 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23812 }
23813 {
23814 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23815 }
23816 {
23817 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23818 }
23819 {
23820 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23821 }
23822 {
23823 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23824 }
23825 {
23826 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23827 }
23828 {
23829 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23830 }
23831 {
23832 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23833 }
23834 {
23835 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23836 }
23837 {
23838 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23839 }
23840 {
23841 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23842 }
23843 {
23844 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23845 }
23846 {
23847 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23848 }
23849 {
23850 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23851 }
23852 {
23853 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23854 }
23855 {
23856 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23857 }
23858 {
23859 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23860 }
23861 {
23862 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23863 }
23864 {
23865 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23866 }
23867 {
23868 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23869 }
23870 {
23871 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23872 }
23873 {
23874 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23875 }
23876 {
23877 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23878 }
23879 {
23880 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23881 }
23882 {
23883 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23884 }
23885 {
23886 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23887 }
23888 {
23889 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23890 }
23891 {
23892 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23893 }
23894 {
23895 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23896 }
23897 {
23898 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23899 }
23900 {
23901 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23902 }
23903 {
23904 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23905 }
23906 {
23907 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23908 }
23909 {
23910 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23911 }
23912 {
23913 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23914 }
23915 {
23916 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23917 }
23918 {
23919 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23920 }
23921 {
23922 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23923 }
23924 {
23925 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23926 }
23927 {
23928 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23929 }
23930 {
23931 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23932 }
23933 {
23934 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23935 }
23936 {
23937 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23938 }
23939 {
23940 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23941 }
23942 {
23943 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23944 }
23945 {
23946 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23947 }
23948 {
23949 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23950 }
23951 {
23952 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23953 }
23954 {
23955 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23956 }
23957 {
23958 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23959 }
23960 {
23961 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23962 }
23963 {
23964 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23965 }
23966 {
23967 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23968 }
23969 {
23970 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23971 }
23972 {
23973 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23974 }
23975 {
23976 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23977 }
23978 {
23979 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23980 }
23981 {
23982 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23983 }
23984 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23985 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23986 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23987 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23988 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23989 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23990 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23991 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23992 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23993 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23994 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23995 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23996 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23997 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23998 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23999 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24000 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24001 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24002 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24003 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24004 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24005 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24006 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24007 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24008 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24009 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24010 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24011 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24012 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24013 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24014 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24015 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24016 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24017 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24018 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24019 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24020 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24021 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24022 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24023 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24024 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24025 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24026 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24027 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24028 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24029 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24030 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24031 {
24032 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24033 }
24034 {
24035 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24036 }
24037 {
24038 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24039 }
24040 {
24041 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24042 }
24043 {
24044 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24045 }
24046 {
24047 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24048 }
24049 {
24050 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24051 }
24052 {
24053 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24054 }
24055 {
24056 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24057 }
24058 {
24059 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24060 }
24061 {
24062 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24063 }
24064 {
24065 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24066 }
24067 {
24068 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24069 }
24070 {
24071 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24072 }
24073 {
24074 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24075 }
24076
24077 // Work around a chicken/egg problem in drawlist.cpp
24078 wxPyDrawList_SetAPIPtr();
24079
24080 }
24081
wxWidgets (Impactor)