]> 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
GTK_NO_CHECK_CASTS is a gtk1 only thing, so don't put it to CPPFLAGS with gtk2.
[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_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_wxRendererNative swig_types[58]
1401 #define SWIGTYPE_p_unsigned_long swig_types[59]
1402 #define SWIGTYPE_p_wxNativeFontInfo swig_types[60]
1403 #define SWIGTYPE_p_wxEncodingConverter swig_types[61]
1404 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[62]
1405 #define SWIGTYPE_p_wxColourDatabase swig_types[63]
1406 static swig_type_info *swig_types[65];
1407
1408 /* -------- TYPES TABLE (END) -------- */
1409
1410
1411 /*-----------------------------------------------
1412 @(target):= _gdi_.so
1413 ------------------------------------------------*/
1414 #define SWIG_init init_gdi_
1415
1416 #define SWIG_name "_gdi_"
1417
1418 #include "wx/wxPython/wxPython.h"
1419 #include "wx/wxPython/pyclasses.h"
1420
1421
1422 static const wxString wxPyEmptyString(wxEmptyString);
1423
1424 #include <limits.h>
1425
1426
1427 SWIGINTERN int
1428 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1429 const char *errmsg)
1430 {
1431 if (value < min_value) {
1432 if (errmsg) {
1433 PyErr_Format(PyExc_OverflowError,
1434 "value %ld is less than '%s' minimum %ld",
1435 value, errmsg, min_value);
1436 }
1437 return 0;
1438 } else if (value > max_value) {
1439 if (errmsg) {
1440 PyErr_Format(PyExc_OverflowError,
1441 "value %ld is greater than '%s' maximum %ld",
1442 value, errmsg, max_value);
1443 }
1444 return 0;
1445 }
1446 return 1;
1447 }
1448
1449
1450 SWIGINTERN int
1451 SWIG_AsVal_long(PyObject* obj, long* val)
1452 {
1453 if (PyNumber_Check(obj)) {
1454 if (val) *val = PyInt_AsLong(obj);
1455 return 1;
1456 }
1457 else {
1458 SWIG_type_error("number", obj);
1459 }
1460 return 0;
1461 }
1462
1463
1464 #if INT_MAX != LONG_MAX
1465 SWIGINTERN int
1466 SWIG_AsVal_int(PyObject *obj, int *val)
1467 {
1468 const char* errmsg = val ? "int" : (char*)0;
1469 long v;
1470 if (SWIG_AsVal_long(obj, &v)) {
1471 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1472 if (val) *val = (int)(v);
1473 return 1;
1474 } else {
1475 return 0;
1476 }
1477 } else {
1478 PyErr_Clear();
1479 }
1480 if (val) {
1481 SWIG_type_error(errmsg, obj);
1482 }
1483 return 0;
1484 }
1485 #else
1486 SWIGINTERNSHORT int
1487 SWIG_AsVal_int(PyObject *obj, int *val)
1488 {
1489 return SWIG_AsVal_long(obj,(long*)val);
1490 }
1491 #endif
1492
1493
1494 SWIGINTERN int
1495 SWIG_AsVal_bool(PyObject *obj, bool *val)
1496 {
1497 if (obj == Py_True) {
1498 if (val) *val = true;
1499 return 1;
1500 }
1501 if (obj == Py_False) {
1502 if (val) *val = false;
1503 return 1;
1504 }
1505 int res = 0;
1506 if (SWIG_AsVal_int(obj, &res)) {
1507 if (val) *val = res ? true : false;
1508 return 1;
1509 } else {
1510 PyErr_Clear();
1511 }
1512 if (val) {
1513 SWIG_type_error("bool", obj);
1514 }
1515 return 0;
1516 }
1517
1518
1519 SWIGINTERNSHORT bool
1520 SWIG_As_bool(PyObject* obj)
1521 {
1522 bool v;
1523 if (!SWIG_AsVal_bool(obj, &v)) {
1524 /*
1525 this is needed to make valgrind/purify happier.
1526 */
1527 memset((void*)&v, 0, sizeof(bool));
1528 }
1529 return v;
1530 }
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_Check_bool(PyObject* obj)
1535 {
1536 return SWIG_AsVal_bool(obj, (bool*)0);
1537 }
1538
1539
1540 SWIGINTERN int
1541 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1542 {
1543 long v = 0;
1544 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1545 SWIG_type_error("unsigned number", obj);
1546 }
1547 else if (val)
1548 *val = (unsigned long)v;
1549 return 1;
1550 }
1551
1552
1553 SWIGINTERNSHORT int
1554 SWIG_CheckUnsignedLongInRange(unsigned long value,
1555 unsigned long max_value,
1556 const char *errmsg)
1557 {
1558 if (value > max_value) {
1559 if (errmsg) {
1560 PyErr_Format(PyExc_OverflowError,
1561 "value %lu is greater than '%s' minimum %lu",
1562 value, errmsg, max_value);
1563 }
1564 return 0;
1565 }
1566 return 1;
1567 }
1568
1569
1570 SWIGINTERN int
1571 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1572 {
1573 const char* errmsg = val ? "unsigned char" : (char*)0;
1574 unsigned long v;
1575 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1576 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1577 if (val) *val = (unsigned char)(v);
1578 return 1;
1579 } else {
1580 return 0;
1581 }
1582 } else {
1583 PyErr_Clear();
1584 }
1585 if (val) {
1586 SWIG_type_error(errmsg, obj);
1587 }
1588 return 0;
1589 }
1590
1591
1592 SWIGINTERNSHORT unsigned char
1593 SWIG_As_unsigned_SS_char(PyObject* obj)
1594 {
1595 unsigned char v;
1596 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1597 /*
1598 this is needed to make valgrind/purify happier.
1599 */
1600 memset((void*)&v, 0, sizeof(unsigned char));
1601 }
1602 return v;
1603 }
1604
1605
1606 SWIGINTERNSHORT int
1607 SWIG_Check_unsigned_SS_char(PyObject* obj)
1608 {
1609 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1610 }
1611
1612
1613 SWIGINTERNSHORT unsigned long
1614 SWIG_As_unsigned_SS_long(PyObject* obj)
1615 {
1616 unsigned long v;
1617 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(unsigned long));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_unsigned_SS_long(PyObject* obj)
1629 {
1630 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1631 }
1632
1633
1634 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1635 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1636 /*@@*/
1637
1638
1639 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1640 #define SWIG_From_long PyInt_FromLong
1641 /*@@*/
1642
1643 static PyObject *wxColour_Get(wxColour *self){
1644 PyObject* rv = PyTuple_New(3);
1645 int red = -1;
1646 int green = -1;
1647 int blue = -1;
1648 if (self->Ok()) {
1649 red = self->Red();
1650 green = self->Green();
1651 blue = self->Blue();
1652 }
1653 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1654 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1655 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1656 return rv;
1657 }
1658 static unsigned long wxColour_GetRGB(wxColour *self){
1659 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1660 }
1661
1662 SWIGINTERNSHORT PyObject*
1663 SWIG_From_unsigned_SS_long(unsigned long value)
1664 {
1665 return (value > LONG_MAX) ?
1666 PyLong_FromUnsignedLong(value)
1667 : PyInt_FromLong((long)(value));
1668 }
1669
1670
1671 SWIGINTERNSHORT int
1672 SWIG_As_int(PyObject* obj)
1673 {
1674 int v;
1675 if (!SWIG_AsVal_int(obj, &v)) {
1676 /*
1677 this is needed to make valgrind/purify happier.
1678 */
1679 memset((void*)&v, 0, sizeof(int));
1680 }
1681 return v;
1682 }
1683
1684
1685 SWIGINTERNSHORT int
1686 SWIG_Check_int(PyObject* obj)
1687 {
1688 return SWIG_AsVal_int(obj, (int*)0);
1689 }
1690
1691
1692 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1693 #define SWIG_From_int PyInt_FromLong
1694 /*@@*/
1695
1696
1697 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1698 PyObject* o2;
1699 PyObject* o3;
1700
1701 if (!target) {
1702 target = o;
1703 } else if (target == Py_None) {
1704 Py_DECREF(Py_None);
1705 target = o;
1706 } else {
1707 if (!PyTuple_Check(target)) {
1708 o2 = target;
1709 target = PyTuple_New(1);
1710 PyTuple_SetItem(target, 0, o2);
1711 }
1712 o3 = PyTuple_New(1);
1713 PyTuple_SetItem(o3, 0, o);
1714
1715 o2 = target;
1716 target = PySequence_Concat(o2, o3);
1717 Py_DECREF(o2);
1718 Py_DECREF(o3);
1719 }
1720 return target;
1721 }
1722
1723
1724 static PyObject *wxPen_GetDashes(wxPen *self){
1725 wxDash* dashes;
1726 int count = self->GetDashes(&dashes);
1727 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1728 PyObject* retval = PyList_New(0);
1729 for (int x=0; x<count; x++) {
1730 PyObject* pyint = PyInt_FromLong(dashes[x]);
1731 PyList_Append(retval, pyint);
1732 Py_DECREF(pyint);
1733 }
1734 wxPyEndBlockThreads(blocked);
1735 return retval;
1736 }
1737 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1739 int size = PyList_Size(pyDashes);
1740 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1741
1742 // black magic warning! The array of wxDashes needs to exist as
1743 // long as the pen does because wxPen does not copy the array. So
1744 // stick a copy in a Python string object and attach it to _self,
1745 // and then call SetDashes with a pointer to that array. Then
1746 // when the Python pen object is destroyed the array will be
1747 // cleaned up too.
1748 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1749 PyObject_SetAttrString(_self, "_dashes", strDashes);
1750
1751 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1752 delete [] dashes;
1753 Py_DECREF(strDashes);
1754 wxPyEndBlockThreads(blocked);
1755 }
1756 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1757 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1758
1759 #include <wx/image.h>
1760
1761 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1762 char** cArray = NULL;
1763 int count;
1764
1765 if (!PyList_Check(listOfStrings)) {
1766 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1767 return NULL;
1768 }
1769 count = PyList_Size(listOfStrings);
1770 cArray = new char*[count];
1771
1772 for(int x=0; x<count; x++) {
1773 // TODO: Need some validation and error checking here
1774 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1775 }
1776 return cArray;
1777 }
1778
1779
1780 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1781 char** cArray = NULL;
1782 wxBitmap* bmp;
1783
1784 cArray = ConvertListOfStrings(listOfStrings);
1785 if (! cArray)
1786 return NULL;
1787 bmp = new wxBitmap(cArray);
1788 delete [] cArray;
1789 return bmp;
1790 }
1791 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1792 char* buf;
1793 int length;
1794 PyString_AsStringAndSize(bits, &buf, &length);
1795 return new wxBitmap(buf, width, height, depth);
1796 }
1797 static wxSize wxBitmap_GetSize(wxBitmap *self){
1798 wxSize size(self->GetWidth(), self->GetHeight());
1799 return size;
1800 }
1801 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1802 wxMask *mask = new wxMask(*self, colour);
1803 self->SetMask(mask);
1804 }
1805 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1806 self->SetWidth(size.x);
1807 self->SetHeight(size.y);
1808 }
1809 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1810 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1811 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1812 if ( !colour.Ok() )
1813 return new wxMask(bitmap, *wxBLACK);
1814 else
1815 return new wxMask(bitmap, colour);
1816 }
1817
1818 #include <wx/iconbndl.h>
1819
1820 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1821 wxIcon* icon = new wxIcon();
1822 icon->CopyFromBitmap(bmp);
1823 return icon;
1824 }
1825 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1826 char** cArray = NULL;
1827 wxIcon* icon;
1828
1829 cArray = ConvertListOfStrings(listOfStrings);
1830 if (! cArray)
1831 return NULL;
1832 icon = new wxIcon(cArray);
1833 delete [] cArray;
1834 return icon;
1835 }
1836 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1837
1838
1839
1840 return new wxIconLocation(*filename);
1841
1842 }
1843 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1844
1845
1846
1847 // do nothing
1848
1849 }
1850 static int wxIconLocation_GetIndex(wxIconLocation *self){
1851
1852
1853
1854 return -1;
1855
1856 }
1857
1858 SWIGINTERNSHORT long
1859 SWIG_As_long(PyObject* obj)
1860 {
1861 long v;
1862 if (!SWIG_AsVal_long(obj, &v)) {
1863 /*
1864 this is needed to make valgrind/purify happier.
1865 */
1866 memset((void*)&v, 0, sizeof(long));
1867 }
1868 return v;
1869 }
1870
1871
1872 SWIGINTERNSHORT int
1873 SWIG_Check_long(PyObject* obj)
1874 {
1875 return SWIG_AsVal_long(obj, (long*)0);
1876 }
1877
1878 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1879 #ifdef __WXGTK__
1880 wxImage img(cursorName, type);
1881 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1882 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1883 return new wxCursor(img);
1884 #else
1885 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1886 #endif
1887 }
1888
1889
1890 static void wxRegionIterator_Next(wxRegionIterator *self){
1891 (*self) ++;
1892 }
1893 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1894 return self->operator bool();
1895 }
1896
1897 #include <wx/fontutil.h>
1898 #include <wx/fontmap.h>
1899 #include <wx/fontenum.h>
1900
1901 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1902 return self->ToString();
1903 }
1904
1905 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1906 static wxNativeEncodingInfo info;
1907 if ( wxGetNativeFontEncoding(encoding, &info) )
1908 return &info;
1909 else
1910 return NULL;
1911 }
1912
1913 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1914 wxFontEncoding alt_enc;
1915 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1916 return PyInt_FromLong(alt_enc);
1917 else {
1918 Py_INCREF(Py_None);
1919 return Py_None;
1920 }
1921 }
1922 static wxFont *new_wxFont(wxString const &info){
1923 wxNativeFontInfo nfi;
1924 nfi.FromString(info);
1925 return new wxFont(nfi);
1926 }
1927 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1928 return wxFont::New(pointSize, family, flags, face, encoding);
1929 }
1930 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1931 return wxFontBase::New(pixelSize, family,
1932 style, weight, underlined,
1933 face, encoding);
1934 }
1935 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1936 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1937 }
1938 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1939 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1940
1941 class wxPyFontEnumerator : public wxFontEnumerator {
1942 public:
1943 wxPyFontEnumerator() {}
1944 ~wxPyFontEnumerator() {}
1945
1946 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1947 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1948
1949 PYPRIVATE;
1950 };
1951
1952 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1953 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1954
1955
1956 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1957 wxArrayString* arr = self->GetEncodings();
1958 if (arr)
1959 return wxArrayString2PyList_helper(*arr);
1960 else
1961 return PyList_New(0);
1962 }
1963 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1964 wxArrayString* arr = self->GetFacenames();
1965 if (arr)
1966 return wxArrayString2PyList_helper(*arr);
1967 else
1968 return PyList_New(0);
1969 }
1970
1971 #include <locale.h>
1972
1973 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1974 wxLocale* loc;
1975 if (language == -1)
1976 loc = new wxLocale();
1977 else
1978 loc = new wxLocale(language, flags);
1979 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1980 // for the floating point conversions and such to work right.
1981 #if PY_VERSION_HEX < 0x02040000
1982 setlocale(LC_NUMERIC, "C");
1983 #endif
1984 return loc;
1985 }
1986 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1987 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1988 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1989 // for the floating point conversions and such to work right.
1990 #if PY_VERSION_HEX < 0x02040000
1991 setlocale(LC_NUMERIC, "C");
1992 #endif
1993 return rc;
1994 }
1995 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1996 bool rc = self->Init(language, flags);
1997 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1998 // for the floating point conversions and such to work right.
1999 #if PY_VERSION_HEX < 0x02040000
2000 setlocale(LC_NUMERIC, "C");
2001 #endif
2002 return rc;
2003 }
2004
2005 #include "wx/wxPython/pydrawxxx.h"
2006
2007 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2008 wxColour col;
2009 self->GetPixel(x, y, &col);
2010 return col;
2011 }
2012 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2013 wxColour col;
2014 self->GetPixel(pt, &col);
2015 return col;
2016 }
2017
2018 SWIGINTERN int
2019 SWIG_AsVal_double(PyObject *obj, double* val)
2020 {
2021 if (PyNumber_Check(obj)) {
2022 if (val) *val = PyFloat_AsDouble(obj);
2023 return 1;
2024 }
2025 else {
2026 SWIG_type_error("number", obj);
2027 }
2028 return 0;
2029 }
2030
2031
2032 SWIGINTERNSHORT double
2033 SWIG_As_double(PyObject* obj)
2034 {
2035 double v;
2036 if (!SWIG_AsVal_double(obj, &v)) {
2037 /*
2038 this is needed to make valgrind/purify happier.
2039 */
2040 memset((void*)&v, 0, sizeof(double));
2041 }
2042 return v;
2043 }
2044
2045
2046 SWIGINTERNSHORT int
2047 SWIG_Check_double(PyObject* obj)
2048 {
2049 return SWIG_AsVal_double(obj, (double*)0);
2050 }
2051
2052 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2053 wxRect rv;
2054 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2055 return rv;
2056 }
2057
2058 static wxRect wxDC_GetClippingRect(wxDC *self){
2059 wxRect rect;
2060 self->GetClippingBox(rect);
2061 return rect;
2062 }
2063 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2064 wxArrayInt widths;
2065 self->GetPartialTextExtents(text, widths);
2066 return widths;
2067 }
2068
2069 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2070 #define SWIG_From_double PyFloat_FromDouble
2071 /*@@*/
2072
2073
2074 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2075 self->SetLogicalOrigin(point.x, point.y);
2076 }
2077 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2078 self->SetDeviceOrigin(point.x, point.y);
2079 }
2080 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2081 self->CalcBoundingBox(point.x, point.y);
2082 }
2083 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2084 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2085 }
2086 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2087 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2088 }
2089 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2090 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2091 }
2092 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2093 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2094 }
2095 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2096 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2097 }
2098 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2099 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2100 }
2101
2102 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2103 *x1 = dc->MinX();
2104 *y1 = dc->MinY();
2105 *x2 = dc->MaxX();
2106 *y2 = dc->MaxY();
2107 }
2108
2109
2110 #include <wx/dcbuffer.h>
2111
2112
2113 #include <wx/dcps.h>
2114
2115
2116 class wxMetaFile : public wxObject {
2117 public:
2118 wxMetaFile(const wxString&)
2119 { wxPyRaiseNotImplemented(); }
2120 };
2121
2122 class wxMetaFileDC : public wxClientDC {
2123 public:
2124 wxMetaFileDC(const wxString&, int, int, const wxString&)
2125 { wxPyRaiseNotImplemented(); }
2126 };
2127
2128
2129
2130 class wxPrinterDC : public wxClientDC {
2131 public:
2132 wxPrinterDC(const wxPrintData&)
2133 { wxPyRaiseNotImplemented(); }
2134
2135 };
2136
2137
2138
2139 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2140 self->AddColour(name, wxColour(red, green, blue));
2141 }
2142
2143 #include <wx/effects.h>
2144
2145
2146 #include "wx/renderer.h"
2147
2148
2149 SWIGINTERNSHORT PyObject*
2150 SWIG_From_bool(bool value)
2151 {
2152 PyObject *obj = value ? Py_True : Py_False;
2153 Py_INCREF(obj);
2154 return obj;
2155 }
2156
2157 #ifdef __cplusplus
2158 extern "C" {
2159 #endif
2160 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2161 PyObject *resultobj;
2162 wxGDIObject *result;
2163 char *kwnames[] = {
2164 NULL
2165 };
2166
2167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2168 {
2169 if (!wxPyCheckForApp()) SWIG_fail;
2170 PyThreadState* __tstate = wxPyBeginAllowThreads();
2171 result = (wxGDIObject *)new wxGDIObject();
2172
2173 wxPyEndAllowThreads(__tstate);
2174 if (PyErr_Occurred()) SWIG_fail;
2175 }
2176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2177 return resultobj;
2178 fail:
2179 return NULL;
2180 }
2181
2182
2183 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2184 PyObject *resultobj;
2185 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2186 PyObject * obj0 = 0 ;
2187 char *kwnames[] = {
2188 (char *) "self", NULL
2189 };
2190
2191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2193 if (SWIG_arg_fail(1)) SWIG_fail;
2194 {
2195 PyThreadState* __tstate = wxPyBeginAllowThreads();
2196 delete arg1;
2197
2198 wxPyEndAllowThreads(__tstate);
2199 if (PyErr_Occurred()) SWIG_fail;
2200 }
2201 Py_INCREF(Py_None); resultobj = Py_None;
2202 return resultobj;
2203 fail:
2204 return NULL;
2205 }
2206
2207
2208 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2209 PyObject *resultobj;
2210 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2211 bool result;
2212 PyObject * obj0 = 0 ;
2213 char *kwnames[] = {
2214 (char *) "self", NULL
2215 };
2216
2217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2219 if (SWIG_arg_fail(1)) SWIG_fail;
2220 {
2221 PyThreadState* __tstate = wxPyBeginAllowThreads();
2222 result = (bool)(arg1)->GetVisible();
2223
2224 wxPyEndAllowThreads(__tstate);
2225 if (PyErr_Occurred()) SWIG_fail;
2226 }
2227 {
2228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2229 }
2230 return resultobj;
2231 fail:
2232 return NULL;
2233 }
2234
2235
2236 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2237 PyObject *resultobj;
2238 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2239 bool arg2 ;
2240 PyObject * obj0 = 0 ;
2241 PyObject * obj1 = 0 ;
2242 char *kwnames[] = {
2243 (char *) "self",(char *) "visible", NULL
2244 };
2245
2246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2248 if (SWIG_arg_fail(1)) SWIG_fail;
2249 {
2250 arg2 = (bool)(SWIG_As_bool(obj1));
2251 if (SWIG_arg_fail(2)) SWIG_fail;
2252 }
2253 {
2254 PyThreadState* __tstate = wxPyBeginAllowThreads();
2255 (arg1)->SetVisible(arg2);
2256
2257 wxPyEndAllowThreads(__tstate);
2258 if (PyErr_Occurred()) SWIG_fail;
2259 }
2260 Py_INCREF(Py_None); resultobj = Py_None;
2261 return resultobj;
2262 fail:
2263 return NULL;
2264 }
2265
2266
2267 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2268 PyObject *resultobj;
2269 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2270 bool result;
2271 PyObject * obj0 = 0 ;
2272 char *kwnames[] = {
2273 (char *) "self", NULL
2274 };
2275
2276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2278 if (SWIG_arg_fail(1)) SWIG_fail;
2279 {
2280 PyThreadState* __tstate = wxPyBeginAllowThreads();
2281 result = (bool)(arg1)->IsNull();
2282
2283 wxPyEndAllowThreads(__tstate);
2284 if (PyErr_Occurred()) SWIG_fail;
2285 }
2286 {
2287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2288 }
2289 return resultobj;
2290 fail:
2291 return NULL;
2292 }
2293
2294
2295 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2296 PyObject *obj;
2297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2298 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2299 Py_INCREF(obj);
2300 return Py_BuildValue((char *)"");
2301 }
2302 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2303 PyObject *resultobj;
2304 byte arg1 = (byte) 0 ;
2305 byte arg2 = (byte) 0 ;
2306 byte arg3 = (byte) 0 ;
2307 wxColour *result;
2308 PyObject * obj0 = 0 ;
2309 PyObject * obj1 = 0 ;
2310 PyObject * obj2 = 0 ;
2311 char *kwnames[] = {
2312 (char *) "red",(char *) "green",(char *) "blue", NULL
2313 };
2314
2315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2316 if (obj0) {
2317 {
2318 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2319 if (SWIG_arg_fail(1)) SWIG_fail;
2320 }
2321 }
2322 if (obj1) {
2323 {
2324 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2325 if (SWIG_arg_fail(2)) SWIG_fail;
2326 }
2327 }
2328 if (obj2) {
2329 {
2330 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2331 if (SWIG_arg_fail(3)) SWIG_fail;
2332 }
2333 }
2334 {
2335 PyThreadState* __tstate = wxPyBeginAllowThreads();
2336 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2337
2338 wxPyEndAllowThreads(__tstate);
2339 if (PyErr_Occurred()) SWIG_fail;
2340 }
2341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2342 return resultobj;
2343 fail:
2344 return NULL;
2345 }
2346
2347
2348 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2349 PyObject *resultobj;
2350 wxString *arg1 = 0 ;
2351 wxColour *result;
2352 bool temp1 = false ;
2353 PyObject * obj0 = 0 ;
2354 char *kwnames[] = {
2355 (char *) "colorName", NULL
2356 };
2357
2358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2359 {
2360 arg1 = wxString_in_helper(obj0);
2361 if (arg1 == NULL) SWIG_fail;
2362 temp1 = true;
2363 }
2364 {
2365 if (!wxPyCheckForApp()) SWIG_fail;
2366 PyThreadState* __tstate = wxPyBeginAllowThreads();
2367 result = (wxColour *)new wxColour((wxString const &)*arg1);
2368
2369 wxPyEndAllowThreads(__tstate);
2370 if (PyErr_Occurred()) SWIG_fail;
2371 }
2372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2373 {
2374 if (temp1)
2375 delete arg1;
2376 }
2377 return resultobj;
2378 fail:
2379 {
2380 if (temp1)
2381 delete arg1;
2382 }
2383 return NULL;
2384 }
2385
2386
2387 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2388 PyObject *resultobj;
2389 unsigned long arg1 ;
2390 wxColour *result;
2391 PyObject * obj0 = 0 ;
2392 char *kwnames[] = {
2393 (char *) "colRGB", NULL
2394 };
2395
2396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2397 {
2398 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2399 if (SWIG_arg_fail(1)) SWIG_fail;
2400 }
2401 {
2402 PyThreadState* __tstate = wxPyBeginAllowThreads();
2403 result = (wxColour *)new wxColour(arg1);
2404
2405 wxPyEndAllowThreads(__tstate);
2406 if (PyErr_Occurred()) SWIG_fail;
2407 }
2408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2409 return resultobj;
2410 fail:
2411 return NULL;
2412 }
2413
2414
2415 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2416 PyObject *resultobj;
2417 wxColour *arg1 = (wxColour *) 0 ;
2418 PyObject * obj0 = 0 ;
2419 char *kwnames[] = {
2420 (char *) "self", NULL
2421 };
2422
2423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2425 if (SWIG_arg_fail(1)) SWIG_fail;
2426 {
2427 PyThreadState* __tstate = wxPyBeginAllowThreads();
2428 delete arg1;
2429
2430 wxPyEndAllowThreads(__tstate);
2431 if (PyErr_Occurred()) SWIG_fail;
2432 }
2433 Py_INCREF(Py_None); resultobj = Py_None;
2434 return resultobj;
2435 fail:
2436 return NULL;
2437 }
2438
2439
2440 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2441 PyObject *resultobj;
2442 wxColour *arg1 = (wxColour *) 0 ;
2443 byte result;
2444 PyObject * obj0 = 0 ;
2445 char *kwnames[] = {
2446 (char *) "self", NULL
2447 };
2448
2449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2451 if (SWIG_arg_fail(1)) SWIG_fail;
2452 {
2453 PyThreadState* __tstate = wxPyBeginAllowThreads();
2454 result = (byte)(arg1)->Red();
2455
2456 wxPyEndAllowThreads(__tstate);
2457 if (PyErr_Occurred()) SWIG_fail;
2458 }
2459 {
2460 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2461 }
2462 return resultobj;
2463 fail:
2464 return NULL;
2465 }
2466
2467
2468 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2469 PyObject *resultobj;
2470 wxColour *arg1 = (wxColour *) 0 ;
2471 byte result;
2472 PyObject * obj0 = 0 ;
2473 char *kwnames[] = {
2474 (char *) "self", NULL
2475 };
2476
2477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2479 if (SWIG_arg_fail(1)) SWIG_fail;
2480 {
2481 PyThreadState* __tstate = wxPyBeginAllowThreads();
2482 result = (byte)(arg1)->Green();
2483
2484 wxPyEndAllowThreads(__tstate);
2485 if (PyErr_Occurred()) SWIG_fail;
2486 }
2487 {
2488 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2489 }
2490 return resultobj;
2491 fail:
2492 return NULL;
2493 }
2494
2495
2496 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2497 PyObject *resultobj;
2498 wxColour *arg1 = (wxColour *) 0 ;
2499 byte result;
2500 PyObject * obj0 = 0 ;
2501 char *kwnames[] = {
2502 (char *) "self", NULL
2503 };
2504
2505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2507 if (SWIG_arg_fail(1)) SWIG_fail;
2508 {
2509 PyThreadState* __tstate = wxPyBeginAllowThreads();
2510 result = (byte)(arg1)->Blue();
2511
2512 wxPyEndAllowThreads(__tstate);
2513 if (PyErr_Occurred()) SWIG_fail;
2514 }
2515 {
2516 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2517 }
2518 return resultobj;
2519 fail:
2520 return NULL;
2521 }
2522
2523
2524 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2525 PyObject *resultobj;
2526 wxColour *arg1 = (wxColour *) 0 ;
2527 bool result;
2528 PyObject * obj0 = 0 ;
2529 char *kwnames[] = {
2530 (char *) "self", NULL
2531 };
2532
2533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2535 if (SWIG_arg_fail(1)) SWIG_fail;
2536 {
2537 PyThreadState* __tstate = wxPyBeginAllowThreads();
2538 result = (bool)(arg1)->Ok();
2539
2540 wxPyEndAllowThreads(__tstate);
2541 if (PyErr_Occurred()) SWIG_fail;
2542 }
2543 {
2544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2545 }
2546 return resultobj;
2547 fail:
2548 return NULL;
2549 }
2550
2551
2552 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2553 PyObject *resultobj;
2554 wxColour *arg1 = (wxColour *) 0 ;
2555 byte arg2 ;
2556 byte arg3 ;
2557 byte arg4 ;
2558 PyObject * obj0 = 0 ;
2559 PyObject * obj1 = 0 ;
2560 PyObject * obj2 = 0 ;
2561 PyObject * obj3 = 0 ;
2562 char *kwnames[] = {
2563 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2564 };
2565
2566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2568 if (SWIG_arg_fail(1)) SWIG_fail;
2569 {
2570 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2571 if (SWIG_arg_fail(2)) SWIG_fail;
2572 }
2573 {
2574 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2575 if (SWIG_arg_fail(3)) SWIG_fail;
2576 }
2577 {
2578 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2579 if (SWIG_arg_fail(4)) SWIG_fail;
2580 }
2581 {
2582 PyThreadState* __tstate = wxPyBeginAllowThreads();
2583 (arg1)->Set(arg2,arg3,arg4);
2584
2585 wxPyEndAllowThreads(__tstate);
2586 if (PyErr_Occurred()) SWIG_fail;
2587 }
2588 Py_INCREF(Py_None); resultobj = Py_None;
2589 return resultobj;
2590 fail:
2591 return NULL;
2592 }
2593
2594
2595 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2596 PyObject *resultobj;
2597 wxColour *arg1 = (wxColour *) 0 ;
2598 unsigned long arg2 ;
2599 PyObject * obj0 = 0 ;
2600 PyObject * obj1 = 0 ;
2601 char *kwnames[] = {
2602 (char *) "self",(char *) "colRGB", NULL
2603 };
2604
2605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2607 if (SWIG_arg_fail(1)) SWIG_fail;
2608 {
2609 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2610 if (SWIG_arg_fail(2)) SWIG_fail;
2611 }
2612 {
2613 PyThreadState* __tstate = wxPyBeginAllowThreads();
2614 (arg1)->Set(arg2);
2615
2616 wxPyEndAllowThreads(__tstate);
2617 if (PyErr_Occurred()) SWIG_fail;
2618 }
2619 Py_INCREF(Py_None); resultobj = Py_None;
2620 return resultobj;
2621 fail:
2622 return NULL;
2623 }
2624
2625
2626 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2627 PyObject *resultobj;
2628 wxColour *arg1 = (wxColour *) 0 ;
2629 wxString *arg2 = 0 ;
2630 bool temp2 = false ;
2631 PyObject * obj0 = 0 ;
2632 PyObject * obj1 = 0 ;
2633 char *kwnames[] = {
2634 (char *) "self",(char *) "colourName", NULL
2635 };
2636
2637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2639 if (SWIG_arg_fail(1)) SWIG_fail;
2640 {
2641 arg2 = wxString_in_helper(obj1);
2642 if (arg2 == NULL) SWIG_fail;
2643 temp2 = true;
2644 }
2645 {
2646 PyThreadState* __tstate = wxPyBeginAllowThreads();
2647 (arg1)->InitFromName((wxString const &)*arg2);
2648
2649 wxPyEndAllowThreads(__tstate);
2650 if (PyErr_Occurred()) SWIG_fail;
2651 }
2652 Py_INCREF(Py_None); resultobj = Py_None;
2653 {
2654 if (temp2)
2655 delete arg2;
2656 }
2657 return resultobj;
2658 fail:
2659 {
2660 if (temp2)
2661 delete arg2;
2662 }
2663 return NULL;
2664 }
2665
2666
2667 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2668 PyObject *resultobj;
2669 wxColour *arg1 = (wxColour *) 0 ;
2670 long result;
2671 PyObject * obj0 = 0 ;
2672 char *kwnames[] = {
2673 (char *) "self", NULL
2674 };
2675
2676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2678 if (SWIG_arg_fail(1)) SWIG_fail;
2679 {
2680 PyThreadState* __tstate = wxPyBeginAllowThreads();
2681 result = (long)((wxColour const *)arg1)->GetPixel();
2682
2683 wxPyEndAllowThreads(__tstate);
2684 if (PyErr_Occurred()) SWIG_fail;
2685 }
2686 {
2687 resultobj = SWIG_From_long((long)(result));
2688 }
2689 return resultobj;
2690 fail:
2691 return NULL;
2692 }
2693
2694
2695 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2696 PyObject *resultobj;
2697 wxColour *arg1 = (wxColour *) 0 ;
2698 wxColour *arg2 = 0 ;
2699 bool result;
2700 wxColour temp2 ;
2701 PyObject * obj0 = 0 ;
2702 PyObject * obj1 = 0 ;
2703 char *kwnames[] = {
2704 (char *) "self",(char *) "colour", NULL
2705 };
2706
2707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2709 if (SWIG_arg_fail(1)) SWIG_fail;
2710 {
2711 arg2 = &temp2;
2712 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2713 }
2714 {
2715 PyThreadState* __tstate = wxPyBeginAllowThreads();
2716 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2717
2718 wxPyEndAllowThreads(__tstate);
2719 if (PyErr_Occurred()) SWIG_fail;
2720 }
2721 {
2722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2723 }
2724 return resultobj;
2725 fail:
2726 return NULL;
2727 }
2728
2729
2730 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2731 PyObject *resultobj;
2732 wxColour *arg1 = (wxColour *) 0 ;
2733 wxColour *arg2 = 0 ;
2734 bool result;
2735 wxColour temp2 ;
2736 PyObject * obj0 = 0 ;
2737 PyObject * obj1 = 0 ;
2738 char *kwnames[] = {
2739 (char *) "self",(char *) "colour", NULL
2740 };
2741
2742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2744 if (SWIG_arg_fail(1)) SWIG_fail;
2745 {
2746 arg2 = &temp2;
2747 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2748 }
2749 {
2750 PyThreadState* __tstate = wxPyBeginAllowThreads();
2751 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2752
2753 wxPyEndAllowThreads(__tstate);
2754 if (PyErr_Occurred()) SWIG_fail;
2755 }
2756 {
2757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2758 }
2759 return resultobj;
2760 fail:
2761 return NULL;
2762 }
2763
2764
2765 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2766 PyObject *resultobj;
2767 wxColour *arg1 = (wxColour *) 0 ;
2768 PyObject *result;
2769 PyObject * obj0 = 0 ;
2770 char *kwnames[] = {
2771 (char *) "self", NULL
2772 };
2773
2774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2776 if (SWIG_arg_fail(1)) SWIG_fail;
2777 {
2778 PyThreadState* __tstate = wxPyBeginAllowThreads();
2779 result = (PyObject *)wxColour_Get(arg1);
2780
2781 wxPyEndAllowThreads(__tstate);
2782 if (PyErr_Occurred()) SWIG_fail;
2783 }
2784 resultobj = result;
2785 return resultobj;
2786 fail:
2787 return NULL;
2788 }
2789
2790
2791 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2792 PyObject *resultobj;
2793 wxColour *arg1 = (wxColour *) 0 ;
2794 unsigned long result;
2795 PyObject * obj0 = 0 ;
2796 char *kwnames[] = {
2797 (char *) "self", NULL
2798 };
2799
2800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2802 if (SWIG_arg_fail(1)) SWIG_fail;
2803 {
2804 PyThreadState* __tstate = wxPyBeginAllowThreads();
2805 result = (unsigned long)wxColour_GetRGB(arg1);
2806
2807 wxPyEndAllowThreads(__tstate);
2808 if (PyErr_Occurred()) SWIG_fail;
2809 }
2810 {
2811 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2812 }
2813 return resultobj;
2814 fail:
2815 return NULL;
2816 }
2817
2818
2819 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2820 PyObject *obj;
2821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2822 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2823 Py_INCREF(obj);
2824 return Py_BuildValue((char *)"");
2825 }
2826 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2827 PyObject *resultobj;
2828 int arg1 ;
2829 unsigned char *arg2 = (unsigned char *) 0 ;
2830 unsigned char *arg3 = (unsigned char *) 0 ;
2831 unsigned char *arg4 = (unsigned char *) 0 ;
2832 wxPalette *result;
2833 PyObject * obj0 = 0 ;
2834 PyObject * obj1 = 0 ;
2835 PyObject * obj2 = 0 ;
2836 PyObject * obj3 = 0 ;
2837 char *kwnames[] = {
2838 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2839 };
2840
2841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2842 {
2843 arg1 = (int)(SWIG_As_int(obj0));
2844 if (SWIG_arg_fail(1)) SWIG_fail;
2845 }
2846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2847 if (SWIG_arg_fail(2)) SWIG_fail;
2848 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2849 if (SWIG_arg_fail(3)) SWIG_fail;
2850 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2851 if (SWIG_arg_fail(4)) SWIG_fail;
2852 {
2853 if (!wxPyCheckForApp()) SWIG_fail;
2854 PyThreadState* __tstate = wxPyBeginAllowThreads();
2855 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2856
2857 wxPyEndAllowThreads(__tstate);
2858 if (PyErr_Occurred()) SWIG_fail;
2859 }
2860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2861 return resultobj;
2862 fail:
2863 return NULL;
2864 }
2865
2866
2867 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2868 PyObject *resultobj;
2869 wxPalette *arg1 = (wxPalette *) 0 ;
2870 PyObject * obj0 = 0 ;
2871 char *kwnames[] = {
2872 (char *) "self", NULL
2873 };
2874
2875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2877 if (SWIG_arg_fail(1)) SWIG_fail;
2878 {
2879 PyThreadState* __tstate = wxPyBeginAllowThreads();
2880 delete arg1;
2881
2882 wxPyEndAllowThreads(__tstate);
2883 if (PyErr_Occurred()) SWIG_fail;
2884 }
2885 Py_INCREF(Py_None); resultobj = Py_None;
2886 return resultobj;
2887 fail:
2888 return NULL;
2889 }
2890
2891
2892 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2893 PyObject *resultobj;
2894 wxPalette *arg1 = (wxPalette *) 0 ;
2895 byte arg2 ;
2896 byte arg3 ;
2897 byte arg4 ;
2898 int result;
2899 PyObject * obj0 = 0 ;
2900 PyObject * obj1 = 0 ;
2901 PyObject * obj2 = 0 ;
2902 PyObject * obj3 = 0 ;
2903 char *kwnames[] = {
2904 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2905 };
2906
2907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2909 if (SWIG_arg_fail(1)) SWIG_fail;
2910 {
2911 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2912 if (SWIG_arg_fail(2)) SWIG_fail;
2913 }
2914 {
2915 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2916 if (SWIG_arg_fail(3)) SWIG_fail;
2917 }
2918 {
2919 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2920 if (SWIG_arg_fail(4)) SWIG_fail;
2921 }
2922 {
2923 PyThreadState* __tstate = wxPyBeginAllowThreads();
2924 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2925
2926 wxPyEndAllowThreads(__tstate);
2927 if (PyErr_Occurred()) SWIG_fail;
2928 }
2929 {
2930 resultobj = SWIG_From_int((int)(result));
2931 }
2932 return resultobj;
2933 fail:
2934 return NULL;
2935 }
2936
2937
2938 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2939 PyObject *resultobj;
2940 wxPalette *arg1 = (wxPalette *) 0 ;
2941 int arg2 ;
2942 byte *arg3 = (byte *) 0 ;
2943 byte *arg4 = (byte *) 0 ;
2944 byte *arg5 = (byte *) 0 ;
2945 bool result;
2946 byte temp3 ;
2947 int res3 = 0 ;
2948 byte temp4 ;
2949 int res4 = 0 ;
2950 byte temp5 ;
2951 int res5 = 0 ;
2952 PyObject * obj0 = 0 ;
2953 PyObject * obj1 = 0 ;
2954 char *kwnames[] = {
2955 (char *) "self",(char *) "pixel", NULL
2956 };
2957
2958 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2959 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2960 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2963 if (SWIG_arg_fail(1)) SWIG_fail;
2964 {
2965 arg2 = (int)(SWIG_As_int(obj1));
2966 if (SWIG_arg_fail(2)) SWIG_fail;
2967 }
2968 {
2969 PyThreadState* __tstate = wxPyBeginAllowThreads();
2970 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2971
2972 wxPyEndAllowThreads(__tstate);
2973 if (PyErr_Occurred()) SWIG_fail;
2974 }
2975 {
2976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2977 }
2978 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2979 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2980 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2981 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2982 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2983 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2984 return resultobj;
2985 fail:
2986 return NULL;
2987 }
2988
2989
2990 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2991 PyObject *resultobj;
2992 wxPalette *arg1 = (wxPalette *) 0 ;
2993 int result;
2994 PyObject * obj0 = 0 ;
2995 char *kwnames[] = {
2996 (char *) "self", NULL
2997 };
2998
2999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3001 if (SWIG_arg_fail(1)) SWIG_fail;
3002 {
3003 PyThreadState* __tstate = wxPyBeginAllowThreads();
3004 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3005
3006 wxPyEndAllowThreads(__tstate);
3007 if (PyErr_Occurred()) SWIG_fail;
3008 }
3009 {
3010 resultobj = SWIG_From_int((int)(result));
3011 }
3012 return resultobj;
3013 fail:
3014 return NULL;
3015 }
3016
3017
3018 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3019 PyObject *resultobj;
3020 wxPalette *arg1 = (wxPalette *) 0 ;
3021 bool result;
3022 PyObject * obj0 = 0 ;
3023 char *kwnames[] = {
3024 (char *) "self", NULL
3025 };
3026
3027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3029 if (SWIG_arg_fail(1)) SWIG_fail;
3030 {
3031 PyThreadState* __tstate = wxPyBeginAllowThreads();
3032 result = (bool)(arg1)->Ok();
3033
3034 wxPyEndAllowThreads(__tstate);
3035 if (PyErr_Occurred()) SWIG_fail;
3036 }
3037 {
3038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3039 }
3040 return resultobj;
3041 fail:
3042 return NULL;
3043 }
3044
3045
3046 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3047 PyObject *obj;
3048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3049 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3050 Py_INCREF(obj);
3051 return Py_BuildValue((char *)"");
3052 }
3053 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3054 PyObject *resultobj;
3055 wxColour *arg1 = 0 ;
3056 int arg2 = (int) 1 ;
3057 int arg3 = (int) wxSOLID ;
3058 wxPen *result;
3059 wxColour temp1 ;
3060 PyObject * obj0 = 0 ;
3061 PyObject * obj1 = 0 ;
3062 PyObject * obj2 = 0 ;
3063 char *kwnames[] = {
3064 (char *) "colour",(char *) "width",(char *) "style", NULL
3065 };
3066
3067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3068 {
3069 arg1 = &temp1;
3070 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3071 }
3072 if (obj1) {
3073 {
3074 arg2 = (int)(SWIG_As_int(obj1));
3075 if (SWIG_arg_fail(2)) SWIG_fail;
3076 }
3077 }
3078 if (obj2) {
3079 {
3080 arg3 = (int)(SWIG_As_int(obj2));
3081 if (SWIG_arg_fail(3)) SWIG_fail;
3082 }
3083 }
3084 {
3085 if (!wxPyCheckForApp()) SWIG_fail;
3086 PyThreadState* __tstate = wxPyBeginAllowThreads();
3087 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3088
3089 wxPyEndAllowThreads(__tstate);
3090 if (PyErr_Occurred()) SWIG_fail;
3091 }
3092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3093 return resultobj;
3094 fail:
3095 return NULL;
3096 }
3097
3098
3099 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3100 PyObject *resultobj;
3101 wxPen *arg1 = (wxPen *) 0 ;
3102 PyObject * obj0 = 0 ;
3103 char *kwnames[] = {
3104 (char *) "self", NULL
3105 };
3106
3107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3109 if (SWIG_arg_fail(1)) SWIG_fail;
3110 {
3111 PyThreadState* __tstate = wxPyBeginAllowThreads();
3112 delete arg1;
3113
3114 wxPyEndAllowThreads(__tstate);
3115 if (PyErr_Occurred()) SWIG_fail;
3116 }
3117 Py_INCREF(Py_None); resultobj = Py_None;
3118 return resultobj;
3119 fail:
3120 return NULL;
3121 }
3122
3123
3124 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3125 PyObject *resultobj;
3126 wxPen *arg1 = (wxPen *) 0 ;
3127 int result;
3128 PyObject * obj0 = 0 ;
3129 char *kwnames[] = {
3130 (char *) "self", NULL
3131 };
3132
3133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3135 if (SWIG_arg_fail(1)) SWIG_fail;
3136 {
3137 PyThreadState* __tstate = wxPyBeginAllowThreads();
3138 result = (int)(arg1)->GetCap();
3139
3140 wxPyEndAllowThreads(__tstate);
3141 if (PyErr_Occurred()) SWIG_fail;
3142 }
3143 {
3144 resultobj = SWIG_From_int((int)(result));
3145 }
3146 return resultobj;
3147 fail:
3148 return NULL;
3149 }
3150
3151
3152 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3153 PyObject *resultobj;
3154 wxPen *arg1 = (wxPen *) 0 ;
3155 wxColour result;
3156 PyObject * obj0 = 0 ;
3157 char *kwnames[] = {
3158 (char *) "self", NULL
3159 };
3160
3161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3163 if (SWIG_arg_fail(1)) SWIG_fail;
3164 {
3165 PyThreadState* __tstate = wxPyBeginAllowThreads();
3166 result = (arg1)->GetColour();
3167
3168 wxPyEndAllowThreads(__tstate);
3169 if (PyErr_Occurred()) SWIG_fail;
3170 }
3171 {
3172 wxColour * resultptr;
3173 resultptr = new wxColour((wxColour &)(result));
3174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3175 }
3176 return resultobj;
3177 fail:
3178 return NULL;
3179 }
3180
3181
3182 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3183 PyObject *resultobj;
3184 wxPen *arg1 = (wxPen *) 0 ;
3185 int result;
3186 PyObject * obj0 = 0 ;
3187 char *kwnames[] = {
3188 (char *) "self", NULL
3189 };
3190
3191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3193 if (SWIG_arg_fail(1)) SWIG_fail;
3194 {
3195 PyThreadState* __tstate = wxPyBeginAllowThreads();
3196 result = (int)(arg1)->GetJoin();
3197
3198 wxPyEndAllowThreads(__tstate);
3199 if (PyErr_Occurred()) SWIG_fail;
3200 }
3201 {
3202 resultobj = SWIG_From_int((int)(result));
3203 }
3204 return resultobj;
3205 fail:
3206 return NULL;
3207 }
3208
3209
3210 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3211 PyObject *resultobj;
3212 wxPen *arg1 = (wxPen *) 0 ;
3213 int result;
3214 PyObject * obj0 = 0 ;
3215 char *kwnames[] = {
3216 (char *) "self", NULL
3217 };
3218
3219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3221 if (SWIG_arg_fail(1)) SWIG_fail;
3222 {
3223 PyThreadState* __tstate = wxPyBeginAllowThreads();
3224 result = (int)(arg1)->GetStyle();
3225
3226 wxPyEndAllowThreads(__tstate);
3227 if (PyErr_Occurred()) SWIG_fail;
3228 }
3229 {
3230 resultobj = SWIG_From_int((int)(result));
3231 }
3232 return resultobj;
3233 fail:
3234 return NULL;
3235 }
3236
3237
3238 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3239 PyObject *resultobj;
3240 wxPen *arg1 = (wxPen *) 0 ;
3241 int result;
3242 PyObject * obj0 = 0 ;
3243 char *kwnames[] = {
3244 (char *) "self", NULL
3245 };
3246
3247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3249 if (SWIG_arg_fail(1)) SWIG_fail;
3250 {
3251 PyThreadState* __tstate = wxPyBeginAllowThreads();
3252 result = (int)(arg1)->GetWidth();
3253
3254 wxPyEndAllowThreads(__tstate);
3255 if (PyErr_Occurred()) SWIG_fail;
3256 }
3257 {
3258 resultobj = SWIG_From_int((int)(result));
3259 }
3260 return resultobj;
3261 fail:
3262 return NULL;
3263 }
3264
3265
3266 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3267 PyObject *resultobj;
3268 wxPen *arg1 = (wxPen *) 0 ;
3269 bool result;
3270 PyObject * obj0 = 0 ;
3271 char *kwnames[] = {
3272 (char *) "self", NULL
3273 };
3274
3275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3277 if (SWIG_arg_fail(1)) SWIG_fail;
3278 {
3279 PyThreadState* __tstate = wxPyBeginAllowThreads();
3280 result = (bool)(arg1)->Ok();
3281
3282 wxPyEndAllowThreads(__tstate);
3283 if (PyErr_Occurred()) SWIG_fail;
3284 }
3285 {
3286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3287 }
3288 return resultobj;
3289 fail:
3290 return NULL;
3291 }
3292
3293
3294 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3295 PyObject *resultobj;
3296 wxPen *arg1 = (wxPen *) 0 ;
3297 int arg2 ;
3298 PyObject * obj0 = 0 ;
3299 PyObject * obj1 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self",(char *) "cap_style", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 arg2 = (int)(SWIG_As_int(obj1));
3309 if (SWIG_arg_fail(2)) SWIG_fail;
3310 }
3311 {
3312 PyThreadState* __tstate = wxPyBeginAllowThreads();
3313 (arg1)->SetCap(arg2);
3314
3315 wxPyEndAllowThreads(__tstate);
3316 if (PyErr_Occurred()) SWIG_fail;
3317 }
3318 Py_INCREF(Py_None); resultobj = Py_None;
3319 return resultobj;
3320 fail:
3321 return NULL;
3322 }
3323
3324
3325 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxPen *arg1 = (wxPen *) 0 ;
3328 wxColour *arg2 = 0 ;
3329 wxColour temp2 ;
3330 PyObject * obj0 = 0 ;
3331 PyObject * obj1 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "self",(char *) "colour", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3338 if (SWIG_arg_fail(1)) SWIG_fail;
3339 {
3340 arg2 = &temp2;
3341 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3342 }
3343 {
3344 PyThreadState* __tstate = wxPyBeginAllowThreads();
3345 (arg1)->SetColour(*arg2);
3346
3347 wxPyEndAllowThreads(__tstate);
3348 if (PyErr_Occurred()) SWIG_fail;
3349 }
3350 Py_INCREF(Py_None); resultobj = Py_None;
3351 return resultobj;
3352 fail:
3353 return NULL;
3354 }
3355
3356
3357 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3358 PyObject *resultobj;
3359 wxPen *arg1 = (wxPen *) 0 ;
3360 int arg2 ;
3361 PyObject * obj0 = 0 ;
3362 PyObject * obj1 = 0 ;
3363 char *kwnames[] = {
3364 (char *) "self",(char *) "join_style", NULL
3365 };
3366
3367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3369 if (SWIG_arg_fail(1)) SWIG_fail;
3370 {
3371 arg2 = (int)(SWIG_As_int(obj1));
3372 if (SWIG_arg_fail(2)) SWIG_fail;
3373 }
3374 {
3375 PyThreadState* __tstate = wxPyBeginAllowThreads();
3376 (arg1)->SetJoin(arg2);
3377
3378 wxPyEndAllowThreads(__tstate);
3379 if (PyErr_Occurred()) SWIG_fail;
3380 }
3381 Py_INCREF(Py_None); resultobj = Py_None;
3382 return resultobj;
3383 fail:
3384 return NULL;
3385 }
3386
3387
3388 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3389 PyObject *resultobj;
3390 wxPen *arg1 = (wxPen *) 0 ;
3391 int arg2 ;
3392 PyObject * obj0 = 0 ;
3393 PyObject * obj1 = 0 ;
3394 char *kwnames[] = {
3395 (char *) "self",(char *) "style", NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3400 if (SWIG_arg_fail(1)) SWIG_fail;
3401 {
3402 arg2 = (int)(SWIG_As_int(obj1));
3403 if (SWIG_arg_fail(2)) SWIG_fail;
3404 }
3405 {
3406 PyThreadState* __tstate = wxPyBeginAllowThreads();
3407 (arg1)->SetStyle(arg2);
3408
3409 wxPyEndAllowThreads(__tstate);
3410 if (PyErr_Occurred()) SWIG_fail;
3411 }
3412 Py_INCREF(Py_None); resultobj = Py_None;
3413 return resultobj;
3414 fail:
3415 return NULL;
3416 }
3417
3418
3419 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3420 PyObject *resultobj;
3421 wxPen *arg1 = (wxPen *) 0 ;
3422 int arg2 ;
3423 PyObject * obj0 = 0 ;
3424 PyObject * obj1 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "self",(char *) "width", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 {
3433 arg2 = (int)(SWIG_As_int(obj1));
3434 if (SWIG_arg_fail(2)) SWIG_fail;
3435 }
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 (arg1)->SetWidth(arg2);
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 return resultobj;
3445 fail:
3446 return NULL;
3447 }
3448
3449
3450 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3451 PyObject *resultobj;
3452 wxPen *arg1 = (wxPen *) 0 ;
3453 int arg2 ;
3454 wxDash *arg3 = (wxDash *) 0 ;
3455 PyObject * obj0 = 0 ;
3456 PyObject * obj1 = 0 ;
3457 char *kwnames[] = {
3458 (char *) "self",(char *) "dashes", NULL
3459 };
3460
3461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3463 if (SWIG_arg_fail(1)) SWIG_fail;
3464 {
3465 arg2 = PyList_Size(obj1);
3466 arg3 = (wxDash*)byte_LIST_helper(obj1);
3467 if (arg3 == NULL) SWIG_fail;
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 (arg1)->SetDashes(arg2,arg3);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 Py_INCREF(Py_None); resultobj = Py_None;
3477 {
3478 if (arg3) delete [] arg3;
3479 }
3480 return resultobj;
3481 fail:
3482 {
3483 if (arg3) delete [] arg3;
3484 }
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj;
3491 wxPen *arg1 = (wxPen *) 0 ;
3492 PyObject *result;
3493 PyObject * obj0 = 0 ;
3494 char *kwnames[] = {
3495 (char *) "self", NULL
3496 };
3497
3498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3500 if (SWIG_arg_fail(1)) SWIG_fail;
3501 {
3502 PyThreadState* __tstate = wxPyBeginAllowThreads();
3503 result = (PyObject *)wxPen_GetDashes(arg1);
3504
3505 wxPyEndAllowThreads(__tstate);
3506 if (PyErr_Occurred()) SWIG_fail;
3507 }
3508 resultobj = result;
3509 return resultobj;
3510 fail:
3511 return NULL;
3512 }
3513
3514
3515 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3516 PyObject *resultobj;
3517 wxPen *arg1 = (wxPen *) 0 ;
3518 PyObject *arg2 = (PyObject *) 0 ;
3519 PyObject *arg3 = (PyObject *) 0 ;
3520 PyObject * obj0 = 0 ;
3521 PyObject * obj1 = 0 ;
3522 PyObject * obj2 = 0 ;
3523 char *kwnames[] = {
3524 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3525 };
3526
3527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3529 if (SWIG_arg_fail(1)) SWIG_fail;
3530 arg2 = obj1;
3531 arg3 = obj2;
3532 {
3533 PyThreadState* __tstate = wxPyBeginAllowThreads();
3534 wxPen__SetDashes(arg1,arg2,arg3);
3535
3536 wxPyEndAllowThreads(__tstate);
3537 if (PyErr_Occurred()) SWIG_fail;
3538 }
3539 Py_INCREF(Py_None); resultobj = Py_None;
3540 return resultobj;
3541 fail:
3542 return NULL;
3543 }
3544
3545
3546 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3547 PyObject *resultobj;
3548 wxPen *arg1 = (wxPen *) 0 ;
3549 int result;
3550 PyObject * obj0 = 0 ;
3551 char *kwnames[] = {
3552 (char *) "self", NULL
3553 };
3554
3555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3557 if (SWIG_arg_fail(1)) SWIG_fail;
3558 {
3559 PyThreadState* __tstate = wxPyBeginAllowThreads();
3560 result = (int)((wxPen const *)arg1)->GetDashCount();
3561
3562 wxPyEndAllowThreads(__tstate);
3563 if (PyErr_Occurred()) SWIG_fail;
3564 }
3565 {
3566 resultobj = SWIG_From_int((int)(result));
3567 }
3568 return resultobj;
3569 fail:
3570 return NULL;
3571 }
3572
3573
3574 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3575 PyObject *resultobj;
3576 wxPen *arg1 = (wxPen *) 0 ;
3577 wxPen *arg2 = (wxPen *) 0 ;
3578 bool result;
3579 PyObject * obj0 = 0 ;
3580 PyObject * obj1 = 0 ;
3581 char *kwnames[] = {
3582 (char *) "self",(char *) "other", NULL
3583 };
3584
3585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3587 if (SWIG_arg_fail(1)) SWIG_fail;
3588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3589 if (SWIG_arg_fail(2)) SWIG_fail;
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3599 }
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3607 PyObject *resultobj;
3608 wxPen *arg1 = (wxPen *) 0 ;
3609 wxPen *arg2 = (wxPen *) 0 ;
3610 bool result;
3611 PyObject * obj0 = 0 ;
3612 PyObject * obj1 = 0 ;
3613 char *kwnames[] = {
3614 (char *) "self",(char *) "other", NULL
3615 };
3616
3617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3619 if (SWIG_arg_fail(1)) SWIG_fail;
3620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3621 if (SWIG_arg_fail(2)) SWIG_fail;
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3631 }
3632 return resultobj;
3633 fail:
3634 return NULL;
3635 }
3636
3637
3638 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3639 PyObject *obj;
3640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3641 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3642 Py_INCREF(obj);
3643 return Py_BuildValue((char *)"");
3644 }
3645 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3646 PyObject *resultobj;
3647 wxColour *arg1 = 0 ;
3648 int arg2 = (int) wxSOLID ;
3649 wxBrush *result;
3650 wxColour temp1 ;
3651 PyObject * obj0 = 0 ;
3652 PyObject * obj1 = 0 ;
3653 char *kwnames[] = {
3654 (char *) "colour",(char *) "style", NULL
3655 };
3656
3657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3658 {
3659 arg1 = &temp1;
3660 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3661 }
3662 if (obj1) {
3663 {
3664 arg2 = (int)(SWIG_As_int(obj1));
3665 if (SWIG_arg_fail(2)) SWIG_fail;
3666 }
3667 }
3668 {
3669 if (!wxPyCheckForApp()) SWIG_fail;
3670 PyThreadState* __tstate = wxPyBeginAllowThreads();
3671 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3672
3673 wxPyEndAllowThreads(__tstate);
3674 if (PyErr_Occurred()) SWIG_fail;
3675 }
3676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3677 return resultobj;
3678 fail:
3679 return NULL;
3680 }
3681
3682
3683 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3684 PyObject *resultobj;
3685 wxBitmap *arg1 = 0 ;
3686 wxBrush *result;
3687 PyObject * obj0 = 0 ;
3688 char *kwnames[] = {
3689 (char *) "stippleBitmap", NULL
3690 };
3691
3692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3693 {
3694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3695 if (SWIG_arg_fail(1)) SWIG_fail;
3696 if (arg1 == NULL) {
3697 SWIG_null_ref("wxBitmap");
3698 }
3699 if (SWIG_arg_fail(1)) SWIG_fail;
3700 }
3701 {
3702 if (!wxPyCheckForApp()) SWIG_fail;
3703 PyThreadState* __tstate = wxPyBeginAllowThreads();
3704 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3705
3706 wxPyEndAllowThreads(__tstate);
3707 if (PyErr_Occurred()) SWIG_fail;
3708 }
3709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3710 return resultobj;
3711 fail:
3712 return NULL;
3713 }
3714
3715
3716 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3717 PyObject *resultobj;
3718 wxBrush *arg1 = (wxBrush *) 0 ;
3719 PyObject * obj0 = 0 ;
3720 char *kwnames[] = {
3721 (char *) "self", NULL
3722 };
3723
3724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3726 if (SWIG_arg_fail(1)) SWIG_fail;
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 delete arg1;
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 Py_INCREF(Py_None); resultobj = Py_None;
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxBrush *arg1 = (wxBrush *) 0 ;
3744 wxColour *arg2 = 0 ;
3745 wxColour temp2 ;
3746 PyObject * obj0 = 0 ;
3747 PyObject * obj1 = 0 ;
3748 char *kwnames[] = {
3749 (char *) "self",(char *) "col", NULL
3750 };
3751
3752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3754 if (SWIG_arg_fail(1)) SWIG_fail;
3755 {
3756 arg2 = &temp2;
3757 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3758 }
3759 {
3760 PyThreadState* __tstate = wxPyBeginAllowThreads();
3761 (arg1)->SetColour((wxColour const &)*arg2);
3762
3763 wxPyEndAllowThreads(__tstate);
3764 if (PyErr_Occurred()) SWIG_fail;
3765 }
3766 Py_INCREF(Py_None); resultobj = Py_None;
3767 return resultobj;
3768 fail:
3769 return NULL;
3770 }
3771
3772
3773 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3774 PyObject *resultobj;
3775 wxBrush *arg1 = (wxBrush *) 0 ;
3776 int arg2 ;
3777 PyObject * obj0 = 0 ;
3778 PyObject * obj1 = 0 ;
3779 char *kwnames[] = {
3780 (char *) "self",(char *) "style", NULL
3781 };
3782
3783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3785 if (SWIG_arg_fail(1)) SWIG_fail;
3786 {
3787 arg2 = (int)(SWIG_As_int(obj1));
3788 if (SWIG_arg_fail(2)) SWIG_fail;
3789 }
3790 {
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 (arg1)->SetStyle(arg2);
3793
3794 wxPyEndAllowThreads(__tstate);
3795 if (PyErr_Occurred()) SWIG_fail;
3796 }
3797 Py_INCREF(Py_None); resultobj = Py_None;
3798 return resultobj;
3799 fail:
3800 return NULL;
3801 }
3802
3803
3804 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3805 PyObject *resultobj;
3806 wxBrush *arg1 = (wxBrush *) 0 ;
3807 wxBitmap *arg2 = 0 ;
3808 PyObject * obj0 = 0 ;
3809 PyObject * obj1 = 0 ;
3810 char *kwnames[] = {
3811 (char *) "self",(char *) "stipple", NULL
3812 };
3813
3814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3816 if (SWIG_arg_fail(1)) SWIG_fail;
3817 {
3818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3819 if (SWIG_arg_fail(2)) SWIG_fail;
3820 if (arg2 == NULL) {
3821 SWIG_null_ref("wxBitmap");
3822 }
3823 if (SWIG_arg_fail(2)) SWIG_fail;
3824 }
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 (arg1)->SetStipple((wxBitmap const &)*arg2);
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 Py_INCREF(Py_None); resultobj = Py_None;
3833 return resultobj;
3834 fail:
3835 return NULL;
3836 }
3837
3838
3839 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3840 PyObject *resultobj;
3841 wxBrush *arg1 = (wxBrush *) 0 ;
3842 wxColour result;
3843 PyObject * obj0 = 0 ;
3844 char *kwnames[] = {
3845 (char *) "self", NULL
3846 };
3847
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3850 if (SWIG_arg_fail(1)) SWIG_fail;
3851 {
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 result = ((wxBrush const *)arg1)->GetColour();
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 {
3859 wxColour * resultptr;
3860 resultptr = new wxColour((wxColour &)(result));
3861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxBrush *arg1 = (wxBrush *) 0 ;
3872 int result;
3873 PyObject * obj0 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (int)((wxBrush const *)arg1)->GetStyle();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = SWIG_From_int((int)(result));
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxBrush *arg1 = (wxBrush *) 0 ;
3900 wxBitmap *result;
3901 PyObject * obj0 = 0 ;
3902 char *kwnames[] = {
3903 (char *) "self", NULL
3904 };
3905
3906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3908 if (SWIG_arg_fail(1)) SWIG_fail;
3909 {
3910 PyThreadState* __tstate = wxPyBeginAllowThreads();
3911 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3912
3913 wxPyEndAllowThreads(__tstate);
3914 if (PyErr_Occurred()) SWIG_fail;
3915 }
3916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3917 return resultobj;
3918 fail:
3919 return NULL;
3920 }
3921
3922
3923 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3924 PyObject *resultobj;
3925 wxBrush *arg1 = (wxBrush *) 0 ;
3926 bool result;
3927 PyObject * obj0 = 0 ;
3928 char *kwnames[] = {
3929 (char *) "self", NULL
3930 };
3931
3932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3934 if (SWIG_arg_fail(1)) SWIG_fail;
3935 {
3936 PyThreadState* __tstate = wxPyBeginAllowThreads();
3937 result = (bool)((wxBrush const *)arg1)->IsHatch();
3938
3939 wxPyEndAllowThreads(__tstate);
3940 if (PyErr_Occurred()) SWIG_fail;
3941 }
3942 {
3943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3944 }
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj;
3953 wxBrush *arg1 = (wxBrush *) 0 ;
3954 bool result;
3955 PyObject * obj0 = 0 ;
3956 char *kwnames[] = {
3957 (char *) "self", NULL
3958 };
3959
3960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3962 if (SWIG_arg_fail(1)) SWIG_fail;
3963 {
3964 PyThreadState* __tstate = wxPyBeginAllowThreads();
3965 result = (bool)(arg1)->Ok();
3966
3967 wxPyEndAllowThreads(__tstate);
3968 if (PyErr_Occurred()) SWIG_fail;
3969 }
3970 {
3971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3972 }
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3980 PyObject *obj;
3981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3982 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3983 Py_INCREF(obj);
3984 return Py_BuildValue((char *)"");
3985 }
3986 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3987 PyObject *resultobj;
3988 wxString *arg1 = 0 ;
3989 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3990 wxBitmap *result;
3991 bool temp1 = false ;
3992 PyObject * obj0 = 0 ;
3993 PyObject * obj1 = 0 ;
3994 char *kwnames[] = {
3995 (char *) "name",(char *) "type", NULL
3996 };
3997
3998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3999 {
4000 arg1 = wxString_in_helper(obj0);
4001 if (arg1 == NULL) SWIG_fail;
4002 temp1 = true;
4003 }
4004 if (obj1) {
4005 {
4006 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4007 if (SWIG_arg_fail(2)) SWIG_fail;
4008 }
4009 }
4010 {
4011 if (!wxPyCheckForApp()) SWIG_fail;
4012 PyThreadState* __tstate = wxPyBeginAllowThreads();
4013 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4014
4015 wxPyEndAllowThreads(__tstate);
4016 if (PyErr_Occurred()) SWIG_fail;
4017 }
4018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4019 {
4020 if (temp1)
4021 delete arg1;
4022 }
4023 return resultobj;
4024 fail:
4025 {
4026 if (temp1)
4027 delete arg1;
4028 }
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 wxBitmap *arg1 = (wxBitmap *) 0 ;
4036 PyObject * obj0 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "self", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4043 if (SWIG_arg_fail(1)) SWIG_fail;
4044 {
4045 PyThreadState* __tstate = wxPyBeginAllowThreads();
4046 delete arg1;
4047
4048 wxPyEndAllowThreads(__tstate);
4049 if (PyErr_Occurred()) SWIG_fail;
4050 }
4051 Py_INCREF(Py_None); resultobj = Py_None;
4052 return resultobj;
4053 fail:
4054 return NULL;
4055 }
4056
4057
4058 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4059 PyObject *resultobj;
4060 int arg1 ;
4061 int arg2 ;
4062 int arg3 = (int) -1 ;
4063 wxBitmap *result;
4064 PyObject * obj0 = 0 ;
4065 PyObject * obj1 = 0 ;
4066 PyObject * obj2 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "width",(char *) "height",(char *) "depth", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4072 {
4073 arg1 = (int)(SWIG_As_int(obj0));
4074 if (SWIG_arg_fail(1)) SWIG_fail;
4075 }
4076 {
4077 arg2 = (int)(SWIG_As_int(obj1));
4078 if (SWIG_arg_fail(2)) SWIG_fail;
4079 }
4080 if (obj2) {
4081 {
4082 arg3 = (int)(SWIG_As_int(obj2));
4083 if (SWIG_arg_fail(3)) SWIG_fail;
4084 }
4085 }
4086 {
4087 if (!wxPyCheckForApp()) SWIG_fail;
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj;
4103 wxIcon *arg1 = 0 ;
4104 wxBitmap *result;
4105 PyObject * obj0 = 0 ;
4106 char *kwnames[] = {
4107 (char *) "icon", NULL
4108 };
4109
4110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4111 {
4112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4113 if (SWIG_arg_fail(1)) SWIG_fail;
4114 if (arg1 == NULL) {
4115 SWIG_null_ref("wxIcon");
4116 }
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 }
4119 {
4120 if (!wxPyCheckForApp()) SWIG_fail;
4121 PyThreadState* __tstate = wxPyBeginAllowThreads();
4122 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4123
4124 wxPyEndAllowThreads(__tstate);
4125 if (PyErr_Occurred()) SWIG_fail;
4126 }
4127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4128 return resultobj;
4129 fail:
4130 return NULL;
4131 }
4132
4133
4134 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4135 PyObject *resultobj;
4136 wxImage *arg1 = 0 ;
4137 int arg2 = (int) -1 ;
4138 wxBitmap *result;
4139 PyObject * obj0 = 0 ;
4140 PyObject * obj1 = 0 ;
4141 char *kwnames[] = {
4142 (char *) "image",(char *) "depth", NULL
4143 };
4144
4145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4146 {
4147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4148 if (SWIG_arg_fail(1)) SWIG_fail;
4149 if (arg1 == NULL) {
4150 SWIG_null_ref("wxImage");
4151 }
4152 if (SWIG_arg_fail(1)) SWIG_fail;
4153 }
4154 if (obj1) {
4155 {
4156 arg2 = (int)(SWIG_As_int(obj1));
4157 if (SWIG_arg_fail(2)) SWIG_fail;
4158 }
4159 }
4160 {
4161 if (!wxPyCheckForApp()) SWIG_fail;
4162 PyThreadState* __tstate = wxPyBeginAllowThreads();
4163 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4164
4165 wxPyEndAllowThreads(__tstate);
4166 if (PyErr_Occurred()) SWIG_fail;
4167 }
4168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4169 return resultobj;
4170 fail:
4171 return NULL;
4172 }
4173
4174
4175 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4176 PyObject *resultobj;
4177 PyObject *arg1 = (PyObject *) 0 ;
4178 wxBitmap *result;
4179 PyObject * obj0 = 0 ;
4180 char *kwnames[] = {
4181 (char *) "listOfStrings", NULL
4182 };
4183
4184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4185 arg1 = obj0;
4186 {
4187 if (!wxPyCheckForApp()) SWIG_fail;
4188 PyThreadState* __tstate = wxPyBeginAllowThreads();
4189 result = (wxBitmap *)new_wxBitmap(arg1);
4190
4191 wxPyEndAllowThreads(__tstate);
4192 if (PyErr_Occurred()) SWIG_fail;
4193 }
4194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4195 return resultobj;
4196 fail:
4197 return NULL;
4198 }
4199
4200
4201 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4202 PyObject *resultobj;
4203 PyObject *arg1 = (PyObject *) 0 ;
4204 int arg2 ;
4205 int arg3 ;
4206 int arg4 = (int) 1 ;
4207 wxBitmap *result;
4208 PyObject * obj0 = 0 ;
4209 PyObject * obj1 = 0 ;
4210 PyObject * obj2 = 0 ;
4211 PyObject * obj3 = 0 ;
4212 char *kwnames[] = {
4213 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4214 };
4215
4216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4217 arg1 = obj0;
4218 {
4219 arg2 = (int)(SWIG_As_int(obj1));
4220 if (SWIG_arg_fail(2)) SWIG_fail;
4221 }
4222 {
4223 arg3 = (int)(SWIG_As_int(obj2));
4224 if (SWIG_arg_fail(3)) SWIG_fail;
4225 }
4226 if (obj3) {
4227 {
4228 arg4 = (int)(SWIG_As_int(obj3));
4229 if (SWIG_arg_fail(4)) SWIG_fail;
4230 }
4231 }
4232 {
4233 if (!wxPyCheckForApp()) SWIG_fail;
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4236
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj;
4249 wxBitmap *arg1 = (wxBitmap *) 0 ;
4250 bool result;
4251 PyObject * obj0 = 0 ;
4252 char *kwnames[] = {
4253 (char *) "self", NULL
4254 };
4255
4256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4258 if (SWIG_arg_fail(1)) SWIG_fail;
4259 {
4260 PyThreadState* __tstate = wxPyBeginAllowThreads();
4261 result = (bool)(arg1)->Ok();
4262
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 {
4267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4268 }
4269 return resultobj;
4270 fail:
4271 return NULL;
4272 }
4273
4274
4275 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4276 PyObject *resultobj;
4277 wxBitmap *arg1 = (wxBitmap *) 0 ;
4278 int result;
4279 PyObject * obj0 = 0 ;
4280 char *kwnames[] = {
4281 (char *) "self", NULL
4282 };
4283
4284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4286 if (SWIG_arg_fail(1)) SWIG_fail;
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 result = (int)(arg1)->GetWidth();
4290
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 {
4295 resultobj = SWIG_From_int((int)(result));
4296 }
4297 return resultobj;
4298 fail:
4299 return NULL;
4300 }
4301
4302
4303 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4304 PyObject *resultobj;
4305 wxBitmap *arg1 = (wxBitmap *) 0 ;
4306 int result;
4307 PyObject * obj0 = 0 ;
4308 char *kwnames[] = {
4309 (char *) "self", NULL
4310 };
4311
4312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4314 if (SWIG_arg_fail(1)) SWIG_fail;
4315 {
4316 PyThreadState* __tstate = wxPyBeginAllowThreads();
4317 result = (int)(arg1)->GetHeight();
4318
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 {
4323 resultobj = SWIG_From_int((int)(result));
4324 }
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4332 PyObject *resultobj;
4333 wxBitmap *arg1 = (wxBitmap *) 0 ;
4334 int result;
4335 PyObject * obj0 = 0 ;
4336 char *kwnames[] = {
4337 (char *) "self", NULL
4338 };
4339
4340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4342 if (SWIG_arg_fail(1)) SWIG_fail;
4343 {
4344 PyThreadState* __tstate = wxPyBeginAllowThreads();
4345 result = (int)(arg1)->GetDepth();
4346
4347 wxPyEndAllowThreads(__tstate);
4348 if (PyErr_Occurred()) SWIG_fail;
4349 }
4350 {
4351 resultobj = SWIG_From_int((int)(result));
4352 }
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxBitmap *arg1 = (wxBitmap *) 0 ;
4362 wxSize result;
4363 PyObject * obj0 = 0 ;
4364 char *kwnames[] = {
4365 (char *) "self", NULL
4366 };
4367
4368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4370 if (SWIG_arg_fail(1)) SWIG_fail;
4371 {
4372 PyThreadState* __tstate = wxPyBeginAllowThreads();
4373 result = wxBitmap_GetSize(arg1);
4374
4375 wxPyEndAllowThreads(__tstate);
4376 if (PyErr_Occurred()) SWIG_fail;
4377 }
4378 {
4379 wxSize * resultptr;
4380 resultptr = new wxSize((wxSize &)(result));
4381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4382 }
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
4389 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4390 PyObject *resultobj;
4391 wxBitmap *arg1 = (wxBitmap *) 0 ;
4392 SwigValueWrapper<wxImage > result;
4393 PyObject * obj0 = 0 ;
4394 char *kwnames[] = {
4395 (char *) "self", NULL
4396 };
4397
4398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4400 if (SWIG_arg_fail(1)) SWIG_fail;
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 result = ((wxBitmap const *)arg1)->ConvertToImage();
4404
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 {
4409 wxImage * resultptr;
4410 resultptr = new wxImage((wxImage &)(result));
4411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4412 }
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 wxBitmap *arg1 = (wxBitmap *) 0 ;
4422 wxMask *result;
4423 PyObject * obj0 = 0 ;
4424 char *kwnames[] = {
4425 (char *) "self", NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4430 if (SWIG_arg_fail(1)) SWIG_fail;
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4434
4435 wxPyEndAllowThreads(__tstate);
4436 if (PyErr_Occurred()) SWIG_fail;
4437 }
4438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4439 return resultobj;
4440 fail:
4441 return NULL;
4442 }
4443
4444
4445 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4446 PyObject *resultobj;
4447 wxBitmap *arg1 = (wxBitmap *) 0 ;
4448 wxMask *arg2 = (wxMask *) 0 ;
4449 PyObject * obj0 = 0 ;
4450 PyObject * obj1 = 0 ;
4451 char *kwnames[] = {
4452 (char *) "self",(char *) "mask", NULL
4453 };
4454
4455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4457 if (SWIG_arg_fail(1)) SWIG_fail;
4458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4459 if (SWIG_arg_fail(2)) SWIG_fail;
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 (arg1)->SetMask(arg2);
4463
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 Py_INCREF(Py_None); resultobj = Py_None;
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4475 PyObject *resultobj;
4476 wxBitmap *arg1 = (wxBitmap *) 0 ;
4477 wxColour *arg2 = 0 ;
4478 wxColour temp2 ;
4479 PyObject * obj0 = 0 ;
4480 PyObject * obj1 = 0 ;
4481 char *kwnames[] = {
4482 (char *) "self",(char *) "colour", NULL
4483 };
4484
4485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4487 if (SWIG_arg_fail(1)) SWIG_fail;
4488 {
4489 arg2 = &temp2;
4490 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4491 }
4492 {
4493 PyThreadState* __tstate = wxPyBeginAllowThreads();
4494 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4495
4496 wxPyEndAllowThreads(__tstate);
4497 if (PyErr_Occurred()) SWIG_fail;
4498 }
4499 Py_INCREF(Py_None); resultobj = Py_None;
4500 return resultobj;
4501 fail:
4502 return NULL;
4503 }
4504
4505
4506 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4507 PyObject *resultobj;
4508 wxBitmap *arg1 = (wxBitmap *) 0 ;
4509 wxRect *arg2 = 0 ;
4510 SwigValueWrapper<wxBitmap > result;
4511 wxRect temp2 ;
4512 PyObject * obj0 = 0 ;
4513 PyObject * obj1 = 0 ;
4514 char *kwnames[] = {
4515 (char *) "self",(char *) "rect", NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(1)) SWIG_fail;
4521 {
4522 arg2 = &temp2;
4523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4528
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 {
4533 wxBitmap * resultptr;
4534 resultptr = new wxBitmap((wxBitmap &)(result));
4535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4536 }
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4544 PyObject *resultobj;
4545 wxBitmap *arg1 = (wxBitmap *) 0 ;
4546 wxString *arg2 = 0 ;
4547 wxBitmapType arg3 ;
4548 wxPalette *arg4 = (wxPalette *) NULL ;
4549 bool result;
4550 bool temp2 = false ;
4551 PyObject * obj0 = 0 ;
4552 PyObject * obj1 = 0 ;
4553 PyObject * obj2 = 0 ;
4554 PyObject * obj3 = 0 ;
4555 char *kwnames[] = {
4556 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4557 };
4558
4559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4561 if (SWIG_arg_fail(1)) SWIG_fail;
4562 {
4563 arg2 = wxString_in_helper(obj1);
4564 if (arg2 == NULL) SWIG_fail;
4565 temp2 = true;
4566 }
4567 {
4568 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4569 if (SWIG_arg_fail(3)) SWIG_fail;
4570 }
4571 if (obj3) {
4572 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4573 if (SWIG_arg_fail(4)) SWIG_fail;
4574 }
4575 {
4576 PyThreadState* __tstate = wxPyBeginAllowThreads();
4577 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4578
4579 wxPyEndAllowThreads(__tstate);
4580 if (PyErr_Occurred()) SWIG_fail;
4581 }
4582 {
4583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4584 }
4585 {
4586 if (temp2)
4587 delete arg2;
4588 }
4589 return resultobj;
4590 fail:
4591 {
4592 if (temp2)
4593 delete arg2;
4594 }
4595 return NULL;
4596 }
4597
4598
4599 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj;
4601 wxBitmap *arg1 = (wxBitmap *) 0 ;
4602 wxString *arg2 = 0 ;
4603 wxBitmapType arg3 ;
4604 bool result;
4605 bool temp2 = false ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 PyObject * obj2 = 0 ;
4609 char *kwnames[] = {
4610 (char *) "self",(char *) "name",(char *) "type", NULL
4611 };
4612
4613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4615 if (SWIG_arg_fail(1)) SWIG_fail;
4616 {
4617 arg2 = wxString_in_helper(obj1);
4618 if (arg2 == NULL) SWIG_fail;
4619 temp2 = true;
4620 }
4621 {
4622 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4623 if (SWIG_arg_fail(3)) SWIG_fail;
4624 }
4625 {
4626 PyThreadState* __tstate = wxPyBeginAllowThreads();
4627 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4628
4629 wxPyEndAllowThreads(__tstate);
4630 if (PyErr_Occurred()) SWIG_fail;
4631 }
4632 {
4633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4634 }
4635 {
4636 if (temp2)
4637 delete arg2;
4638 }
4639 return resultobj;
4640 fail:
4641 {
4642 if (temp2)
4643 delete arg2;
4644 }
4645 return NULL;
4646 }
4647
4648
4649 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4650 PyObject *resultobj;
4651 wxBitmap *arg1 = (wxBitmap *) 0 ;
4652 wxPalette *result;
4653 PyObject * obj0 = 0 ;
4654 char *kwnames[] = {
4655 (char *) "self", NULL
4656 };
4657
4658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4660 if (SWIG_arg_fail(1)) SWIG_fail;
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4664
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj;
4677 wxBitmap *arg1 = (wxBitmap *) 0 ;
4678 wxIcon *arg2 = 0 ;
4679 bool result;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 char *kwnames[] = {
4683 (char *) "self",(char *) "icon", NULL
4684 };
4685
4686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4688 if (SWIG_arg_fail(1)) SWIG_fail;
4689 {
4690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4691 if (SWIG_arg_fail(2)) SWIG_fail;
4692 if (arg2 == NULL) {
4693 SWIG_null_ref("wxIcon");
4694 }
4695 if (SWIG_arg_fail(2)) SWIG_fail;
4696 }
4697 {
4698 PyThreadState* __tstate = wxPyBeginAllowThreads();
4699 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4700
4701 wxPyEndAllowThreads(__tstate);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 {
4705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4706 }
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj;
4715 wxBitmap *arg1 = (wxBitmap *) 0 ;
4716 int arg2 ;
4717 PyObject * obj0 = 0 ;
4718 PyObject * obj1 = 0 ;
4719 char *kwnames[] = {
4720 (char *) "self",(char *) "height", NULL
4721 };
4722
4723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4725 if (SWIG_arg_fail(1)) SWIG_fail;
4726 {
4727 arg2 = (int)(SWIG_As_int(obj1));
4728 if (SWIG_arg_fail(2)) SWIG_fail;
4729 }
4730 {
4731 PyThreadState* __tstate = wxPyBeginAllowThreads();
4732 (arg1)->SetHeight(arg2);
4733
4734 wxPyEndAllowThreads(__tstate);
4735 if (PyErr_Occurred()) SWIG_fail;
4736 }
4737 Py_INCREF(Py_None); resultobj = Py_None;
4738 return resultobj;
4739 fail:
4740 return NULL;
4741 }
4742
4743
4744 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj;
4746 wxBitmap *arg1 = (wxBitmap *) 0 ;
4747 int arg2 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char *kwnames[] = {
4751 (char *) "self",(char *) "width", NULL
4752 };
4753
4754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4756 if (SWIG_arg_fail(1)) SWIG_fail;
4757 {
4758 arg2 = (int)(SWIG_As_int(obj1));
4759 if (SWIG_arg_fail(2)) SWIG_fail;
4760 }
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 (arg1)->SetWidth(arg2);
4764
4765 wxPyEndAllowThreads(__tstate);
4766 if (PyErr_Occurred()) SWIG_fail;
4767 }
4768 Py_INCREF(Py_None); resultobj = Py_None;
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj;
4777 wxBitmap *arg1 = (wxBitmap *) 0 ;
4778 int arg2 ;
4779 PyObject * obj0 = 0 ;
4780 PyObject * obj1 = 0 ;
4781 char *kwnames[] = {
4782 (char *) "self",(char *) "depth", NULL
4783 };
4784
4785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4787 if (SWIG_arg_fail(1)) SWIG_fail;
4788 {
4789 arg2 = (int)(SWIG_As_int(obj1));
4790 if (SWIG_arg_fail(2)) SWIG_fail;
4791 }
4792 {
4793 PyThreadState* __tstate = wxPyBeginAllowThreads();
4794 (arg1)->SetDepth(arg2);
4795
4796 wxPyEndAllowThreads(__tstate);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 Py_INCREF(Py_None); resultobj = Py_None;
4800 return resultobj;
4801 fail:
4802 return NULL;
4803 }
4804
4805
4806 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4807 PyObject *resultobj;
4808 wxBitmap *arg1 = (wxBitmap *) 0 ;
4809 wxSize *arg2 = 0 ;
4810 wxSize temp2 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char *kwnames[] = {
4814 (char *) "self",(char *) "size", NULL
4815 };
4816
4817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4819 if (SWIG_arg_fail(1)) SWIG_fail;
4820 {
4821 arg2 = &temp2;
4822 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4823 }
4824 {
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4827
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 Py_INCREF(Py_None); resultobj = Py_None;
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxBitmap *arg1 = (wxBitmap *) 0 ;
4841 wxBitmap *arg2 = (wxBitmap *) 0 ;
4842 bool result;
4843 PyObject * obj0 = 0 ;
4844 PyObject * obj1 = 0 ;
4845 char *kwnames[] = {
4846 (char *) "self",(char *) "other", NULL
4847 };
4848
4849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4851 if (SWIG_arg_fail(1)) SWIG_fail;
4852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4853 if (SWIG_arg_fail(2)) SWIG_fail;
4854 {
4855 PyThreadState* __tstate = wxPyBeginAllowThreads();
4856 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4857
4858 wxPyEndAllowThreads(__tstate);
4859 if (PyErr_Occurred()) SWIG_fail;
4860 }
4861 {
4862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4863 }
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj;
4872 wxBitmap *arg1 = (wxBitmap *) 0 ;
4873 wxBitmap *arg2 = (wxBitmap *) 0 ;
4874 bool result;
4875 PyObject * obj0 = 0 ;
4876 PyObject * obj1 = 0 ;
4877 char *kwnames[] = {
4878 (char *) "self",(char *) "other", NULL
4879 };
4880
4881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4883 if (SWIG_arg_fail(1)) SWIG_fail;
4884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4885 if (SWIG_arg_fail(2)) SWIG_fail;
4886 {
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 {
4894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4895 }
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4903 PyObject *obj;
4904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4905 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4906 Py_INCREF(obj);
4907 return Py_BuildValue((char *)"");
4908 }
4909 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4910 PyObject *resultobj;
4911 wxBitmap *arg1 = 0 ;
4912 wxColour const &arg2_defvalue = wxNullColour ;
4913 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4914 wxMask *result;
4915 wxColour temp2 ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 char *kwnames[] = {
4919 (char *) "bitmap",(char *) "colour", NULL
4920 };
4921
4922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4923 {
4924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4925 if (SWIG_arg_fail(1)) SWIG_fail;
4926 if (arg1 == NULL) {
4927 SWIG_null_ref("wxBitmap");
4928 }
4929 if (SWIG_arg_fail(1)) SWIG_fail;
4930 }
4931 if (obj1) {
4932 {
4933 arg2 = &temp2;
4934 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4935 }
4936 }
4937 {
4938 if (!wxPyCheckForApp()) SWIG_fail;
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4941
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4953 PyObject *obj;
4954 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4955 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4956 Py_INCREF(obj);
4957 return Py_BuildValue((char *)"");
4958 }
4959 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj;
4961 wxString *arg1 = 0 ;
4962 wxBitmapType arg2 ;
4963 int arg3 = (int) -1 ;
4964 int arg4 = (int) -1 ;
4965 wxIcon *result;
4966 bool temp1 = false ;
4967 PyObject * obj0 = 0 ;
4968 PyObject * obj1 = 0 ;
4969 PyObject * obj2 = 0 ;
4970 PyObject * obj3 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4976 {
4977 arg1 = wxString_in_helper(obj0);
4978 if (arg1 == NULL) SWIG_fail;
4979 temp1 = true;
4980 }
4981 {
4982 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4983 if (SWIG_arg_fail(2)) SWIG_fail;
4984 }
4985 if (obj2) {
4986 {
4987 arg3 = (int)(SWIG_As_int(obj2));
4988 if (SWIG_arg_fail(3)) SWIG_fail;
4989 }
4990 }
4991 if (obj3) {
4992 {
4993 arg4 = (int)(SWIG_As_int(obj3));
4994 if (SWIG_arg_fail(4)) SWIG_fail;
4995 }
4996 }
4997 {
4998 if (!wxPyCheckForApp()) SWIG_fail;
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5006 {
5007 if (temp1)
5008 delete arg1;
5009 }
5010 return resultobj;
5011 fail:
5012 {
5013 if (temp1)
5014 delete arg1;
5015 }
5016 return NULL;
5017 }
5018
5019
5020 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj;
5022 wxIcon *arg1 = (wxIcon *) 0 ;
5023 PyObject * obj0 = 0 ;
5024 char *kwnames[] = {
5025 (char *) "self", NULL
5026 };
5027
5028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(1)) SWIG_fail;
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 delete arg1;
5034
5035 wxPyEndAllowThreads(__tstate);
5036 if (PyErr_Occurred()) SWIG_fail;
5037 }
5038 Py_INCREF(Py_None); resultobj = Py_None;
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj;
5047 wxIcon *result;
5048 char *kwnames[] = {
5049 NULL
5050 };
5051
5052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5053 {
5054 if (!wxPyCheckForApp()) SWIG_fail;
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (wxIcon *)new wxIcon();
5057
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj;
5070 wxIconLocation *arg1 = 0 ;
5071 wxIcon *result;
5072 PyObject * obj0 = 0 ;
5073 char *kwnames[] = {
5074 (char *) "loc", NULL
5075 };
5076
5077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5078 {
5079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5080 if (SWIG_arg_fail(1)) SWIG_fail;
5081 if (arg1 == NULL) {
5082 SWIG_null_ref("wxIconLocation");
5083 }
5084 if (SWIG_arg_fail(1)) SWIG_fail;
5085 }
5086 {
5087 if (!wxPyCheckForApp()) SWIG_fail;
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5090
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5095 return resultobj;
5096 fail:
5097 return NULL;
5098 }
5099
5100
5101 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5102 PyObject *resultobj;
5103 wxBitmap *arg1 = 0 ;
5104 wxIcon *result;
5105 PyObject * obj0 = 0 ;
5106 char *kwnames[] = {
5107 (char *) "bmp", NULL
5108 };
5109
5110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5111 {
5112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5113 if (SWIG_arg_fail(1)) SWIG_fail;
5114 if (arg1 == NULL) {
5115 SWIG_null_ref("wxBitmap");
5116 }
5117 if (SWIG_arg_fail(1)) SWIG_fail;
5118 }
5119 {
5120 if (!wxPyCheckForApp()) SWIG_fail;
5121 PyThreadState* __tstate = wxPyBeginAllowThreads();
5122 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5123
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj;
5136 PyObject *arg1 = (PyObject *) 0 ;
5137 wxIcon *result;
5138 PyObject * obj0 = 0 ;
5139 char *kwnames[] = {
5140 (char *) "listOfStrings", NULL
5141 };
5142
5143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5144 arg1 = obj0;
5145 {
5146 if (!wxPyCheckForApp()) SWIG_fail;
5147 PyThreadState* __tstate = wxPyBeginAllowThreads();
5148 result = (wxIcon *)new_wxIcon(arg1);
5149
5150 wxPyEndAllowThreads(__tstate);
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5161 PyObject *resultobj;
5162 wxIcon *arg1 = (wxIcon *) 0 ;
5163 wxString *arg2 = 0 ;
5164 wxBitmapType arg3 ;
5165 bool result;
5166 bool temp2 = false ;
5167 PyObject * obj0 = 0 ;
5168 PyObject * obj1 = 0 ;
5169 PyObject * obj2 = 0 ;
5170 char *kwnames[] = {
5171 (char *) "self",(char *) "name",(char *) "type", NULL
5172 };
5173
5174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5176 if (SWIG_arg_fail(1)) SWIG_fail;
5177 {
5178 arg2 = wxString_in_helper(obj1);
5179 if (arg2 == NULL) SWIG_fail;
5180 temp2 = true;
5181 }
5182 {
5183 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5184 if (SWIG_arg_fail(3)) SWIG_fail;
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 {
5194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5195 }
5196 {
5197 if (temp2)
5198 delete arg2;
5199 }
5200 return resultobj;
5201 fail:
5202 {
5203 if (temp2)
5204 delete arg2;
5205 }
5206 return NULL;
5207 }
5208
5209
5210 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5211 PyObject *resultobj;
5212 wxIcon *arg1 = (wxIcon *) 0 ;
5213 bool result;
5214 PyObject * obj0 = 0 ;
5215 char *kwnames[] = {
5216 (char *) "self", NULL
5217 };
5218
5219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5221 if (SWIG_arg_fail(1)) SWIG_fail;
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 result = (bool)(arg1)->Ok();
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 {
5230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5231 }
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5239 PyObject *resultobj;
5240 wxIcon *arg1 = (wxIcon *) 0 ;
5241 int result;
5242 PyObject * obj0 = 0 ;
5243 char *kwnames[] = {
5244 (char *) "self", NULL
5245 };
5246
5247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5249 if (SWIG_arg_fail(1)) SWIG_fail;
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 result = (int)(arg1)->GetWidth();
5253
5254 wxPyEndAllowThreads(__tstate);
5255 if (PyErr_Occurred()) SWIG_fail;
5256 }
5257 {
5258 resultobj = SWIG_From_int((int)(result));
5259 }
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj;
5268 wxIcon *arg1 = (wxIcon *) 0 ;
5269 int result;
5270 PyObject * obj0 = 0 ;
5271 char *kwnames[] = {
5272 (char *) "self", NULL
5273 };
5274
5275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5277 if (SWIG_arg_fail(1)) SWIG_fail;
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 result = (int)(arg1)->GetHeight();
5281
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 {
5286 resultobj = SWIG_From_int((int)(result));
5287 }
5288 return resultobj;
5289 fail:
5290 return NULL;
5291 }
5292
5293
5294 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5295 PyObject *resultobj;
5296 wxIcon *arg1 = (wxIcon *) 0 ;
5297 int result;
5298 PyObject * obj0 = 0 ;
5299 char *kwnames[] = {
5300 (char *) "self", NULL
5301 };
5302
5303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5305 if (SWIG_arg_fail(1)) SWIG_fail;
5306 {
5307 PyThreadState* __tstate = wxPyBeginAllowThreads();
5308 result = (int)(arg1)->GetDepth();
5309
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 {
5314 resultobj = SWIG_From_int((int)(result));
5315 }
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5323 PyObject *resultobj;
5324 wxIcon *arg1 = (wxIcon *) 0 ;
5325 int arg2 ;
5326 PyObject * obj0 = 0 ;
5327 PyObject * obj1 = 0 ;
5328 char *kwnames[] = {
5329 (char *) "self",(char *) "w", NULL
5330 };
5331
5332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5334 if (SWIG_arg_fail(1)) SWIG_fail;
5335 {
5336 arg2 = (int)(SWIG_As_int(obj1));
5337 if (SWIG_arg_fail(2)) SWIG_fail;
5338 }
5339 {
5340 PyThreadState* __tstate = wxPyBeginAllowThreads();
5341 (arg1)->SetWidth(arg2);
5342
5343 wxPyEndAllowThreads(__tstate);
5344 if (PyErr_Occurred()) SWIG_fail;
5345 }
5346 Py_INCREF(Py_None); resultobj = Py_None;
5347 return resultobj;
5348 fail:
5349 return NULL;
5350 }
5351
5352
5353 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5354 PyObject *resultobj;
5355 wxIcon *arg1 = (wxIcon *) 0 ;
5356 int arg2 ;
5357 PyObject * obj0 = 0 ;
5358 PyObject * obj1 = 0 ;
5359 char *kwnames[] = {
5360 (char *) "self",(char *) "h", NULL
5361 };
5362
5363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5365 if (SWIG_arg_fail(1)) SWIG_fail;
5366 {
5367 arg2 = (int)(SWIG_As_int(obj1));
5368 if (SWIG_arg_fail(2)) SWIG_fail;
5369 }
5370 {
5371 PyThreadState* __tstate = wxPyBeginAllowThreads();
5372 (arg1)->SetHeight(arg2);
5373
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 Py_INCREF(Py_None); resultobj = Py_None;
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5385 PyObject *resultobj;
5386 wxIcon *arg1 = (wxIcon *) 0 ;
5387 int arg2 ;
5388 PyObject * obj0 = 0 ;
5389 PyObject * obj1 = 0 ;
5390 char *kwnames[] = {
5391 (char *) "self",(char *) "d", NULL
5392 };
5393
5394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5396 if (SWIG_arg_fail(1)) SWIG_fail;
5397 {
5398 arg2 = (int)(SWIG_As_int(obj1));
5399 if (SWIG_arg_fail(2)) SWIG_fail;
5400 }
5401 {
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 (arg1)->SetDepth(arg2);
5404
5405 wxPyEndAllowThreads(__tstate);
5406 if (PyErr_Occurred()) SWIG_fail;
5407 }
5408 Py_INCREF(Py_None); resultobj = Py_None;
5409 return resultobj;
5410 fail:
5411 return NULL;
5412 }
5413
5414
5415 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5416 PyObject *resultobj;
5417 wxIcon *arg1 = (wxIcon *) 0 ;
5418 wxBitmap *arg2 = 0 ;
5419 PyObject * obj0 = 0 ;
5420 PyObject * obj1 = 0 ;
5421 char *kwnames[] = {
5422 (char *) "self",(char *) "bmp", NULL
5423 };
5424
5425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5427 if (SWIG_arg_fail(1)) SWIG_fail;
5428 {
5429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5430 if (SWIG_arg_fail(2)) SWIG_fail;
5431 if (arg2 == NULL) {
5432 SWIG_null_ref("wxBitmap");
5433 }
5434 if (SWIG_arg_fail(2)) SWIG_fail;
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 Py_INCREF(Py_None); resultobj = Py_None;
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5451 PyObject *obj;
5452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5453 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5454 Py_INCREF(obj);
5455 return Py_BuildValue((char *)"");
5456 }
5457 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5458 PyObject *resultobj;
5459 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5460 int arg2 = (int) 0 ;
5461 wxIconLocation *result;
5462 bool temp1 = false ;
5463 PyObject * obj0 = 0 ;
5464 PyObject * obj1 = 0 ;
5465 char *kwnames[] = {
5466 (char *) "filename",(char *) "num", NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5470 if (obj0) {
5471 {
5472 arg1 = wxString_in_helper(obj0);
5473 if (arg1 == NULL) SWIG_fail;
5474 temp1 = true;
5475 }
5476 }
5477 if (obj1) {
5478 {
5479 arg2 = (int)(SWIG_As_int(obj1));
5480 if (SWIG_arg_fail(2)) SWIG_fail;
5481 }
5482 }
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5486
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5491 {
5492 if (temp1)
5493 delete arg1;
5494 }
5495 return resultobj;
5496 fail:
5497 {
5498 if (temp1)
5499 delete arg1;
5500 }
5501 return NULL;
5502 }
5503
5504
5505 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj;
5507 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 delete arg1;
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 Py_INCREF(Py_None); resultobj = Py_None;
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj;
5532 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5533 bool result;
5534 PyObject * obj0 = 0 ;
5535 char *kwnames[] = {
5536 (char *) "self", NULL
5537 };
5538
5539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5541 if (SWIG_arg_fail(1)) SWIG_fail;
5542 {
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5545
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 {
5550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5551 }
5552 return resultobj;
5553 fail:
5554 return NULL;
5555 }
5556
5557
5558 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5559 PyObject *resultobj;
5560 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5561 wxString *arg2 = 0 ;
5562 bool temp2 = false ;
5563 PyObject * obj0 = 0 ;
5564 PyObject * obj1 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self",(char *) "filename", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 arg2 = wxString_in_helper(obj1);
5574 if (arg2 == NULL) SWIG_fail;
5575 temp2 = true;
5576 }
5577 {
5578 PyThreadState* __tstate = wxPyBeginAllowThreads();
5579 (arg1)->SetFileName((wxString const &)*arg2);
5580
5581 wxPyEndAllowThreads(__tstate);
5582 if (PyErr_Occurred()) SWIG_fail;
5583 }
5584 Py_INCREF(Py_None); resultobj = Py_None;
5585 {
5586 if (temp2)
5587 delete arg2;
5588 }
5589 return resultobj;
5590 fail:
5591 {
5592 if (temp2)
5593 delete arg2;
5594 }
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5602 wxString *result;
5603 PyObject * obj0 = 0 ;
5604 char *kwnames[] = {
5605 (char *) "self", NULL
5606 };
5607
5608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5610 if (SWIG_arg_fail(1)) SWIG_fail;
5611 {
5612 PyThreadState* __tstate = wxPyBeginAllowThreads();
5613 {
5614 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5615 result = (wxString *) &_result_ref;
5616 }
5617
5618 wxPyEndAllowThreads(__tstate);
5619 if (PyErr_Occurred()) SWIG_fail;
5620 }
5621 {
5622 #if wxUSE_UNICODE
5623 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5624 #else
5625 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5626 #endif
5627 }
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5635 PyObject *resultobj;
5636 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5637 int arg2 ;
5638 PyObject * obj0 = 0 ;
5639 PyObject * obj1 = 0 ;
5640 char *kwnames[] = {
5641 (char *) "self",(char *) "num", NULL
5642 };
5643
5644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5646 if (SWIG_arg_fail(1)) SWIG_fail;
5647 {
5648 arg2 = (int)(SWIG_As_int(obj1));
5649 if (SWIG_arg_fail(2)) SWIG_fail;
5650 }
5651 {
5652 PyThreadState* __tstate = wxPyBeginAllowThreads();
5653 wxIconLocation_SetIndex(arg1,arg2);
5654
5655 wxPyEndAllowThreads(__tstate);
5656 if (PyErr_Occurred()) SWIG_fail;
5657 }
5658 Py_INCREF(Py_None); resultobj = Py_None;
5659 return resultobj;
5660 fail:
5661 return NULL;
5662 }
5663
5664
5665 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5666 PyObject *resultobj;
5667 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5668 int result;
5669 PyObject * obj0 = 0 ;
5670 char *kwnames[] = {
5671 (char *) "self", NULL
5672 };
5673
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5676 if (SWIG_arg_fail(1)) SWIG_fail;
5677 {
5678 PyThreadState* __tstate = wxPyBeginAllowThreads();
5679 result = (int)wxIconLocation_GetIndex(arg1);
5680
5681 wxPyEndAllowThreads(__tstate);
5682 if (PyErr_Occurred()) SWIG_fail;
5683 }
5684 {
5685 resultobj = SWIG_From_int((int)(result));
5686 }
5687 return resultobj;
5688 fail:
5689 return NULL;
5690 }
5691
5692
5693 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5694 PyObject *obj;
5695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5696 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5697 Py_INCREF(obj);
5698 return Py_BuildValue((char *)"");
5699 }
5700 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj;
5702 wxIconBundle *result;
5703 char *kwnames[] = {
5704 NULL
5705 };
5706
5707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5708 {
5709 PyThreadState* __tstate = wxPyBeginAllowThreads();
5710 result = (wxIconBundle *)new wxIconBundle();
5711
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5723 PyObject *resultobj;
5724 wxString *arg1 = 0 ;
5725 long arg2 ;
5726 wxIconBundle *result;
5727 bool temp1 = false ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 char *kwnames[] = {
5731 (char *) "file",(char *) "type", NULL
5732 };
5733
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5735 {
5736 arg1 = wxString_in_helper(obj0);
5737 if (arg1 == NULL) SWIG_fail;
5738 temp1 = true;
5739 }
5740 {
5741 arg2 = (long)(SWIG_As_long(obj1));
5742 if (SWIG_arg_fail(2)) SWIG_fail;
5743 }
5744 {
5745 PyThreadState* __tstate = wxPyBeginAllowThreads();
5746 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5747
5748 wxPyEndAllowThreads(__tstate);
5749 if (PyErr_Occurred()) SWIG_fail;
5750 }
5751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5752 {
5753 if (temp1)
5754 delete arg1;
5755 }
5756 return resultobj;
5757 fail:
5758 {
5759 if (temp1)
5760 delete arg1;
5761 }
5762 return NULL;
5763 }
5764
5765
5766 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj;
5768 wxIcon *arg1 = 0 ;
5769 wxIconBundle *result;
5770 PyObject * obj0 = 0 ;
5771 char *kwnames[] = {
5772 (char *) "icon", NULL
5773 };
5774
5775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5776 {
5777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5778 if (SWIG_arg_fail(1)) SWIG_fail;
5779 if (arg1 == NULL) {
5780 SWIG_null_ref("wxIcon");
5781 }
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 }
5784 {
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj;
5800 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5801 PyObject * obj0 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 delete arg1;
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 Py_INCREF(Py_None); resultobj = Py_None;
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj;
5825 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5826 wxIcon *arg2 = 0 ;
5827 PyObject * obj0 = 0 ;
5828 PyObject * obj1 = 0 ;
5829 char *kwnames[] = {
5830 (char *) "self",(char *) "icon", NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5835 if (SWIG_arg_fail(1)) SWIG_fail;
5836 {
5837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5838 if (SWIG_arg_fail(2)) SWIG_fail;
5839 if (arg2 == NULL) {
5840 SWIG_null_ref("wxIcon");
5841 }
5842 if (SWIG_arg_fail(2)) SWIG_fail;
5843 }
5844 {
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 (arg1)->AddIcon((wxIcon const &)*arg2);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 Py_INCREF(Py_None); resultobj = Py_None;
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5861 wxString *arg2 = 0 ;
5862 long arg3 ;
5863 bool temp2 = false ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 PyObject * obj2 = 0 ;
5867 char *kwnames[] = {
5868 (char *) "self",(char *) "file",(char *) "type", NULL
5869 };
5870
5871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5873 if (SWIG_arg_fail(1)) SWIG_fail;
5874 {
5875 arg2 = wxString_in_helper(obj1);
5876 if (arg2 == NULL) SWIG_fail;
5877 temp2 = true;
5878 }
5879 {
5880 arg3 = (long)(SWIG_As_long(obj2));
5881 if (SWIG_arg_fail(3)) SWIG_fail;
5882 }
5883 {
5884 PyThreadState* __tstate = wxPyBeginAllowThreads();
5885 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5886
5887 wxPyEndAllowThreads(__tstate);
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 Py_INCREF(Py_None); resultobj = Py_None;
5891 {
5892 if (temp2)
5893 delete arg2;
5894 }
5895 return resultobj;
5896 fail:
5897 {
5898 if (temp2)
5899 delete arg2;
5900 }
5901 return NULL;
5902 }
5903
5904
5905 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj;
5907 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5908 wxSize *arg2 = 0 ;
5909 wxIcon *result;
5910 wxSize temp2 ;
5911 PyObject * obj0 = 0 ;
5912 PyObject * obj1 = 0 ;
5913 char *kwnames[] = {
5914 (char *) "self",(char *) "size", NULL
5915 };
5916
5917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5919 if (SWIG_arg_fail(1)) SWIG_fail;
5920 {
5921 arg2 = &temp2;
5922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5923 }
5924 {
5925 PyThreadState* __tstate = wxPyBeginAllowThreads();
5926 {
5927 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5928 result = (wxIcon *) &_result_ref;
5929 }
5930
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 wxIcon* resultptr = new wxIcon(*result);
5936 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5937 }
5938 return resultobj;
5939 fail:
5940 return NULL;
5941 }
5942
5943
5944 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5945 PyObject *obj;
5946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5947 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5948 Py_INCREF(obj);
5949 return Py_BuildValue((char *)"");
5950 }
5951 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5952 PyObject *resultobj;
5953 wxString *arg1 = 0 ;
5954 long arg2 ;
5955 int arg3 = (int) 0 ;
5956 int arg4 = (int) 0 ;
5957 wxCursor *result;
5958 bool temp1 = false ;
5959 PyObject * obj0 = 0 ;
5960 PyObject * obj1 = 0 ;
5961 PyObject * obj2 = 0 ;
5962 PyObject * obj3 = 0 ;
5963 char *kwnames[] = {
5964 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5968 {
5969 arg1 = wxString_in_helper(obj0);
5970 if (arg1 == NULL) SWIG_fail;
5971 temp1 = true;
5972 }
5973 {
5974 arg2 = (long)(SWIG_As_long(obj1));
5975 if (SWIG_arg_fail(2)) SWIG_fail;
5976 }
5977 if (obj2) {
5978 {
5979 arg3 = (int)(SWIG_As_int(obj2));
5980 if (SWIG_arg_fail(3)) SWIG_fail;
5981 }
5982 }
5983 if (obj3) {
5984 {
5985 arg4 = (int)(SWIG_As_int(obj3));
5986 if (SWIG_arg_fail(4)) SWIG_fail;
5987 }
5988 }
5989 {
5990 if (!wxPyCheckForApp()) SWIG_fail;
5991 PyThreadState* __tstate = wxPyBeginAllowThreads();
5992 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5993
5994 wxPyEndAllowThreads(__tstate);
5995 if (PyErr_Occurred()) SWIG_fail;
5996 }
5997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5998 {
5999 if (temp1)
6000 delete arg1;
6001 }
6002 return resultobj;
6003 fail:
6004 {
6005 if (temp1)
6006 delete arg1;
6007 }
6008 return NULL;
6009 }
6010
6011
6012 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6013 PyObject *resultobj;
6014 wxCursor *arg1 = (wxCursor *) 0 ;
6015 PyObject * obj0 = 0 ;
6016 char *kwnames[] = {
6017 (char *) "self", NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6022 if (SWIG_arg_fail(1)) SWIG_fail;
6023 {
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 delete arg1;
6026
6027 wxPyEndAllowThreads(__tstate);
6028 if (PyErr_Occurred()) SWIG_fail;
6029 }
6030 Py_INCREF(Py_None); resultobj = Py_None;
6031 return resultobj;
6032 fail:
6033 return NULL;
6034 }
6035
6036
6037 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6038 PyObject *resultobj;
6039 int arg1 ;
6040 wxCursor *result;
6041 PyObject * obj0 = 0 ;
6042 char *kwnames[] = {
6043 (char *) "id", NULL
6044 };
6045
6046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6047 {
6048 arg1 = (int)(SWIG_As_int(obj0));
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 }
6051 {
6052 if (!wxPyCheckForApp()) SWIG_fail;
6053 PyThreadState* __tstate = wxPyBeginAllowThreads();
6054 result = (wxCursor *)new wxCursor(arg1);
6055
6056 wxPyEndAllowThreads(__tstate);
6057 if (PyErr_Occurred()) SWIG_fail;
6058 }
6059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6060 return resultobj;
6061 fail:
6062 return NULL;
6063 }
6064
6065
6066 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj;
6068 wxImage *arg1 = 0 ;
6069 wxCursor *result;
6070 PyObject * obj0 = 0 ;
6071 char *kwnames[] = {
6072 (char *) "image", NULL
6073 };
6074
6075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6076 {
6077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6078 if (SWIG_arg_fail(1)) SWIG_fail;
6079 if (arg1 == NULL) {
6080 SWIG_null_ref("wxImage");
6081 }
6082 if (SWIG_arg_fail(1)) SWIG_fail;
6083 }
6084 {
6085 if (!wxPyCheckForApp()) SWIG_fail;
6086 PyThreadState* __tstate = wxPyBeginAllowThreads();
6087 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6088
6089 wxPyEndAllowThreads(__tstate);
6090 if (PyErr_Occurred()) SWIG_fail;
6091 }
6092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6093 return resultobj;
6094 fail:
6095 return NULL;
6096 }
6097
6098
6099 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6100 PyObject *resultobj;
6101 wxCursor *arg1 = (wxCursor *) 0 ;
6102 bool result;
6103 PyObject * obj0 = 0 ;
6104 char *kwnames[] = {
6105 (char *) "self", NULL
6106 };
6107
6108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6110 if (SWIG_arg_fail(1)) SWIG_fail;
6111 {
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 result = (bool)(arg1)->Ok();
6114
6115 wxPyEndAllowThreads(__tstate);
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 {
6119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6120 }
6121 return resultobj;
6122 fail:
6123 return NULL;
6124 }
6125
6126
6127 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6128 PyObject *obj;
6129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6130 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6131 Py_INCREF(obj);
6132 return Py_BuildValue((char *)"");
6133 }
6134 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 int arg1 = (int) 0 ;
6137 int arg2 = (int) 0 ;
6138 int arg3 = (int) 0 ;
6139 int arg4 = (int) 0 ;
6140 wxRegion *result;
6141 PyObject * obj0 = 0 ;
6142 PyObject * obj1 = 0 ;
6143 PyObject * obj2 = 0 ;
6144 PyObject * obj3 = 0 ;
6145 char *kwnames[] = {
6146 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6147 };
6148
6149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6150 if (obj0) {
6151 {
6152 arg1 = (int)(SWIG_As_int(obj0));
6153 if (SWIG_arg_fail(1)) SWIG_fail;
6154 }
6155 }
6156 if (obj1) {
6157 {
6158 arg2 = (int)(SWIG_As_int(obj1));
6159 if (SWIG_arg_fail(2)) SWIG_fail;
6160 }
6161 }
6162 if (obj2) {
6163 {
6164 arg3 = (int)(SWIG_As_int(obj2));
6165 if (SWIG_arg_fail(3)) SWIG_fail;
6166 }
6167 }
6168 if (obj3) {
6169 {
6170 arg4 = (int)(SWIG_As_int(obj3));
6171 if (SWIG_arg_fail(4)) SWIG_fail;
6172 }
6173 }
6174 {
6175 if (!wxPyCheckForApp()) SWIG_fail;
6176 PyThreadState* __tstate = wxPyBeginAllowThreads();
6177 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6178
6179 wxPyEndAllowThreads(__tstate);
6180 if (PyErr_Occurred()) SWIG_fail;
6181 }
6182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6183 return resultobj;
6184 fail:
6185 return NULL;
6186 }
6187
6188
6189 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6190 PyObject *resultobj;
6191 wxBitmap *arg1 = 0 ;
6192 wxRegion *result;
6193 PyObject * obj0 = 0 ;
6194 char *kwnames[] = {
6195 (char *) "bmp", NULL
6196 };
6197
6198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6199 {
6200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 if (arg1 == NULL) {
6203 SWIG_null_ref("wxBitmap");
6204 }
6205 if (SWIG_arg_fail(1)) SWIG_fail;
6206 }
6207 {
6208 if (!wxPyCheckForApp()) SWIG_fail;
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6211
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj;
6224 wxBitmap *arg1 = 0 ;
6225 wxColour *arg2 = 0 ;
6226 int arg3 = (int) 0 ;
6227 wxRegion *result;
6228 wxColour temp2 ;
6229 PyObject * obj0 = 0 ;
6230 PyObject * obj1 = 0 ;
6231 PyObject * obj2 = 0 ;
6232 char *kwnames[] = {
6233 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6234 };
6235
6236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6237 {
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 if (arg1 == NULL) {
6241 SWIG_null_ref("wxBitmap");
6242 }
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 }
6245 {
6246 arg2 = &temp2;
6247 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6248 }
6249 if (obj2) {
6250 {
6251 arg3 = (int)(SWIG_As_int(obj2));
6252 if (SWIG_arg_fail(3)) SWIG_fail;
6253 }
6254 }
6255 {
6256 if (!wxPyCheckForApp()) SWIG_fail;
6257 PyThreadState* __tstate = wxPyBeginAllowThreads();
6258 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6259
6260 wxPyEndAllowThreads(__tstate);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj;
6272 int arg1 ;
6273 wxPoint *arg2 = (wxPoint *) 0 ;
6274 int arg3 = (int) wxWINDING_RULE ;
6275 wxRegion *result;
6276 PyObject * obj0 = 0 ;
6277 PyObject * obj1 = 0 ;
6278 char *kwnames[] = {
6279 (char *) "points",(char *) "fillStyle", NULL
6280 };
6281
6282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6283 {
6284 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6285 if (arg2 == NULL) SWIG_fail;
6286 }
6287 if (obj1) {
6288 {
6289 arg3 = (int)(SWIG_As_int(obj1));
6290 if (SWIG_arg_fail(3)) SWIG_fail;
6291 }
6292 }
6293 {
6294 if (!wxPyCheckForApp()) SWIG_fail;
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6297
6298 wxPyEndAllowThreads(__tstate);
6299 if (PyErr_Occurred()) SWIG_fail;
6300 }
6301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6302 {
6303 if (arg2) delete [] arg2;
6304 }
6305 return resultobj;
6306 fail:
6307 {
6308 if (arg2) delete [] arg2;
6309 }
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRegion *arg1 = (wxRegion *) 0 ;
6317 PyObject * obj0 = 0 ;
6318 char *kwnames[] = {
6319 (char *) "self", NULL
6320 };
6321
6322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6324 if (SWIG_arg_fail(1)) SWIG_fail;
6325 {
6326 PyThreadState* __tstate = wxPyBeginAllowThreads();
6327 delete arg1;
6328
6329 wxPyEndAllowThreads(__tstate);
6330 if (PyErr_Occurred()) SWIG_fail;
6331 }
6332 Py_INCREF(Py_None); resultobj = Py_None;
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6340 PyObject *resultobj;
6341 wxRegion *arg1 = (wxRegion *) 0 ;
6342 PyObject * obj0 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 {
6351 PyThreadState* __tstate = wxPyBeginAllowThreads();
6352 (arg1)->Clear();
6353
6354 wxPyEndAllowThreads(__tstate);
6355 if (PyErr_Occurred()) SWIG_fail;
6356 }
6357 Py_INCREF(Py_None); resultobj = Py_None;
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj;
6366 wxRegion *arg1 = (wxRegion *) 0 ;
6367 int arg2 ;
6368 int arg3 ;
6369 bool result;
6370 PyObject * obj0 = 0 ;
6371 PyObject * obj1 = 0 ;
6372 PyObject * obj2 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "self",(char *) "x",(char *) "y", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6379 if (SWIG_arg_fail(1)) SWIG_fail;
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 {
6385 arg3 = (int)(SWIG_As_int(obj2));
6386 if (SWIG_arg_fail(3)) SWIG_fail;
6387 }
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (bool)(arg1)->Offset(arg2,arg3);
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 {
6396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6397 }
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 wxRegion *arg1 = (wxRegion *) 0 ;
6407 int arg2 ;
6408 int arg3 ;
6409 wxRegionContain result;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 PyObject * obj2 = 0 ;
6413 char *kwnames[] = {
6414 (char *) "self",(char *) "x",(char *) "y", NULL
6415 };
6416
6417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(1)) SWIG_fail;
6420 {
6421 arg2 = (int)(SWIG_As_int(obj1));
6422 if (SWIG_arg_fail(2)) SWIG_fail;
6423 }
6424 {
6425 arg3 = (int)(SWIG_As_int(obj2));
6426 if (SWIG_arg_fail(3)) SWIG_fail;
6427 }
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6431
6432 wxPyEndAllowThreads(__tstate);
6433 if (PyErr_Occurred()) SWIG_fail;
6434 }
6435 resultobj = SWIG_From_int((result));
6436 return resultobj;
6437 fail:
6438 return NULL;
6439 }
6440
6441
6442 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6443 PyObject *resultobj;
6444 wxRegion *arg1 = (wxRegion *) 0 ;
6445 wxPoint *arg2 = 0 ;
6446 wxRegionContain result;
6447 wxPoint temp2 ;
6448 PyObject * obj0 = 0 ;
6449 PyObject * obj1 = 0 ;
6450 char *kwnames[] = {
6451 (char *) "self",(char *) "pt", NULL
6452 };
6453
6454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6456 if (SWIG_arg_fail(1)) SWIG_fail;
6457 {
6458 arg2 = &temp2;
6459 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6460 }
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6464
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_From_int((result));
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj;
6477 wxRegion *arg1 = (wxRegion *) 0 ;
6478 wxRect *arg2 = 0 ;
6479 wxRegionContain result;
6480 wxRect temp2 ;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char *kwnames[] = {
6484 (char *) "self",(char *) "rect", NULL
6485 };
6486
6487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6489 if (SWIG_arg_fail(1)) SWIG_fail;
6490 {
6491 arg2 = &temp2;
6492 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6493 }
6494 {
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6497
6498 wxPyEndAllowThreads(__tstate);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_From_int((result));
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj;
6510 wxRegion *arg1 = (wxRegion *) 0 ;
6511 int arg2 ;
6512 int arg3 ;
6513 int arg4 ;
6514 int arg5 ;
6515 wxRegionContain result;
6516 PyObject * obj0 = 0 ;
6517 PyObject * obj1 = 0 ;
6518 PyObject * obj2 = 0 ;
6519 PyObject * obj3 = 0 ;
6520 PyObject * obj4 = 0 ;
6521 char *kwnames[] = {
6522 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6523 };
6524
6525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6527 if (SWIG_arg_fail(1)) SWIG_fail;
6528 {
6529 arg2 = (int)(SWIG_As_int(obj1));
6530 if (SWIG_arg_fail(2)) SWIG_fail;
6531 }
6532 {
6533 arg3 = (int)(SWIG_As_int(obj2));
6534 if (SWIG_arg_fail(3)) SWIG_fail;
6535 }
6536 {
6537 arg4 = (int)(SWIG_As_int(obj3));
6538 if (SWIG_arg_fail(4)) SWIG_fail;
6539 }
6540 {
6541 arg5 = (int)(SWIG_As_int(obj4));
6542 if (SWIG_arg_fail(5)) SWIG_fail;
6543 }
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_From_int((result));
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxRegion *arg1 = (wxRegion *) 0 ;
6561 wxRect result;
6562 PyObject * obj0 = 0 ;
6563 char *kwnames[] = {
6564 (char *) "self", NULL
6565 };
6566
6567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6569 if (SWIG_arg_fail(1)) SWIG_fail;
6570 {
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 result = (arg1)->GetBox();
6573
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 {
6578 wxRect * resultptr;
6579 resultptr = new wxRect((wxRect &)(result));
6580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6581 }
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6589 PyObject *resultobj;
6590 wxRegion *arg1 = (wxRegion *) 0 ;
6591 int arg2 ;
6592 int arg3 ;
6593 int arg4 ;
6594 int arg5 ;
6595 bool result;
6596 PyObject * obj0 = 0 ;
6597 PyObject * obj1 = 0 ;
6598 PyObject * obj2 = 0 ;
6599 PyObject * obj3 = 0 ;
6600 PyObject * obj4 = 0 ;
6601 char *kwnames[] = {
6602 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6603 };
6604
6605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6607 if (SWIG_arg_fail(1)) SWIG_fail;
6608 {
6609 arg2 = (int)(SWIG_As_int(obj1));
6610 if (SWIG_arg_fail(2)) SWIG_fail;
6611 }
6612 {
6613 arg3 = (int)(SWIG_As_int(obj2));
6614 if (SWIG_arg_fail(3)) SWIG_fail;
6615 }
6616 {
6617 arg4 = (int)(SWIG_As_int(obj3));
6618 if (SWIG_arg_fail(4)) SWIG_fail;
6619 }
6620 {
6621 arg5 = (int)(SWIG_As_int(obj4));
6622 if (SWIG_arg_fail(5)) SWIG_fail;
6623 }
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6627
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 {
6632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6633 }
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj;
6642 wxRegion *arg1 = (wxRegion *) 0 ;
6643 wxRect *arg2 = 0 ;
6644 bool result;
6645 wxRect temp2 ;
6646 PyObject * obj0 = 0 ;
6647 PyObject * obj1 = 0 ;
6648 char *kwnames[] = {
6649 (char *) "self",(char *) "rect", NULL
6650 };
6651
6652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6654 if (SWIG_arg_fail(1)) SWIG_fail;
6655 {
6656 arg2 = &temp2;
6657 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6658 }
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 {
6667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6668 }
6669 return resultobj;
6670 fail:
6671 return NULL;
6672 }
6673
6674
6675 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6676 PyObject *resultobj;
6677 wxRegion *arg1 = (wxRegion *) 0 ;
6678 wxRegion *arg2 = 0 ;
6679 bool result;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self",(char *) "region", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6691 if (SWIG_arg_fail(2)) SWIG_fail;
6692 if (arg2 == NULL) {
6693 SWIG_null_ref("wxRegion");
6694 }
6695 if (SWIG_arg_fail(2)) SWIG_fail;
6696 }
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 {
6705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6706 }
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxRegion *arg1 = (wxRegion *) 0 ;
6716 bool result;
6717 PyObject * obj0 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "self", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6724 if (SWIG_arg_fail(1)) SWIG_fail;
6725 {
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (bool)(arg1)->IsEmpty();
6728
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 {
6733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6734 }
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxRegion *arg1 = (wxRegion *) 0 ;
6744 int arg2 ;
6745 int arg3 ;
6746 int arg4 ;
6747 int arg5 ;
6748 bool result;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 PyObject * obj2 = 0 ;
6752 PyObject * obj3 = 0 ;
6753 PyObject * obj4 = 0 ;
6754 char *kwnames[] = {
6755 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6756 };
6757
6758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6760 if (SWIG_arg_fail(1)) SWIG_fail;
6761 {
6762 arg2 = (int)(SWIG_As_int(obj1));
6763 if (SWIG_arg_fail(2)) SWIG_fail;
6764 }
6765 {
6766 arg3 = (int)(SWIG_As_int(obj2));
6767 if (SWIG_arg_fail(3)) SWIG_fail;
6768 }
6769 {
6770 arg4 = (int)(SWIG_As_int(obj3));
6771 if (SWIG_arg_fail(4)) SWIG_fail;
6772 }
6773 {
6774 arg5 = (int)(SWIG_As_int(obj4));
6775 if (SWIG_arg_fail(5)) SWIG_fail;
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj;
6795 wxRegion *arg1 = (wxRegion *) 0 ;
6796 wxRect *arg2 = 0 ;
6797 bool result;
6798 wxRect temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char *kwnames[] = {
6802 (char *) "self",(char *) "rect", NULL
6803 };
6804
6805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6807 if (SWIG_arg_fail(1)) SWIG_fail;
6808 {
6809 arg2 = &temp2;
6810 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6811 }
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6815
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 {
6820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6821 }
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6829 PyObject *resultobj;
6830 wxRegion *arg1 = (wxRegion *) 0 ;
6831 wxRegion *arg2 = 0 ;
6832 bool result;
6833 PyObject * obj0 = 0 ;
6834 PyObject * obj1 = 0 ;
6835 char *kwnames[] = {
6836 (char *) "self",(char *) "region", NULL
6837 };
6838
6839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6841 if (SWIG_arg_fail(1)) SWIG_fail;
6842 {
6843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(2)) SWIG_fail;
6845 if (arg2 == NULL) {
6846 SWIG_null_ref("wxRegion");
6847 }
6848 if (SWIG_arg_fail(2)) SWIG_fail;
6849 }
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6853
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 {
6858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6859 }
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6867 PyObject *resultobj;
6868 wxRegion *arg1 = (wxRegion *) 0 ;
6869 int arg2 ;
6870 int arg3 ;
6871 int arg4 ;
6872 int arg5 ;
6873 bool result;
6874 PyObject * obj0 = 0 ;
6875 PyObject * obj1 = 0 ;
6876 PyObject * obj2 = 0 ;
6877 PyObject * obj3 = 0 ;
6878 PyObject * obj4 = 0 ;
6879 char *kwnames[] = {
6880 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6881 };
6882
6883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6885 if (SWIG_arg_fail(1)) SWIG_fail;
6886 {
6887 arg2 = (int)(SWIG_As_int(obj1));
6888 if (SWIG_arg_fail(2)) SWIG_fail;
6889 }
6890 {
6891 arg3 = (int)(SWIG_As_int(obj2));
6892 if (SWIG_arg_fail(3)) SWIG_fail;
6893 }
6894 {
6895 arg4 = (int)(SWIG_As_int(obj3));
6896 if (SWIG_arg_fail(4)) SWIG_fail;
6897 }
6898 {
6899 arg5 = (int)(SWIG_As_int(obj4));
6900 if (SWIG_arg_fail(5)) SWIG_fail;
6901 }
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 {
6910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6919 PyObject *resultobj;
6920 wxRegion *arg1 = (wxRegion *) 0 ;
6921 wxRect *arg2 = 0 ;
6922 bool result;
6923 wxRect temp2 ;
6924 PyObject * obj0 = 0 ;
6925 PyObject * obj1 = 0 ;
6926 char *kwnames[] = {
6927 (char *) "self",(char *) "rect", NULL
6928 };
6929
6930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6932 if (SWIG_arg_fail(1)) SWIG_fail;
6933 {
6934 arg2 = &temp2;
6935 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6936 }
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 {
6945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6946 }
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6954 PyObject *resultobj;
6955 wxRegion *arg1 = (wxRegion *) 0 ;
6956 wxRegion *arg2 = 0 ;
6957 bool result;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 char *kwnames[] = {
6961 (char *) "self",(char *) "region", NULL
6962 };
6963
6964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6966 if (SWIG_arg_fail(1)) SWIG_fail;
6967 {
6968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6969 if (SWIG_arg_fail(2)) SWIG_fail;
6970 if (arg2 == NULL) {
6971 SWIG_null_ref("wxRegion");
6972 }
6973 if (SWIG_arg_fail(2)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 {
6983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6984 }
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxRegion *arg1 = (wxRegion *) 0 ;
6994 int arg2 ;
6995 int arg3 ;
6996 int arg4 ;
6997 int arg5 ;
6998 bool result;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 PyObject * obj2 = 0 ;
7002 PyObject * obj3 = 0 ;
7003 PyObject * obj4 = 0 ;
7004 char *kwnames[] = {
7005 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7006 };
7007
7008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7010 if (SWIG_arg_fail(1)) SWIG_fail;
7011 {
7012 arg2 = (int)(SWIG_As_int(obj1));
7013 if (SWIG_arg_fail(2)) SWIG_fail;
7014 }
7015 {
7016 arg3 = (int)(SWIG_As_int(obj2));
7017 if (SWIG_arg_fail(3)) SWIG_fail;
7018 }
7019 {
7020 arg4 = (int)(SWIG_As_int(obj3));
7021 if (SWIG_arg_fail(4)) SWIG_fail;
7022 }
7023 {
7024 arg5 = (int)(SWIG_As_int(obj4));
7025 if (SWIG_arg_fail(5)) SWIG_fail;
7026 }
7027 {
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 {
7035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7036 }
7037 return resultobj;
7038 fail:
7039 return NULL;
7040 }
7041
7042
7043 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxRegion *arg1 = (wxRegion *) 0 ;
7046 wxRect *arg2 = 0 ;
7047 bool result;
7048 wxRect temp2 ;
7049 PyObject * obj0 = 0 ;
7050 PyObject * obj1 = 0 ;
7051 char *kwnames[] = {
7052 (char *) "self",(char *) "rect", NULL
7053 };
7054
7055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7057 if (SWIG_arg_fail(1)) SWIG_fail;
7058 {
7059 arg2 = &temp2;
7060 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7061 }
7062 {
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7065
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 {
7070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7071 }
7072 return resultobj;
7073 fail:
7074 return NULL;
7075 }
7076
7077
7078 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7079 PyObject *resultobj;
7080 wxRegion *arg1 = (wxRegion *) 0 ;
7081 wxRegion *arg2 = 0 ;
7082 bool result;
7083 PyObject * obj0 = 0 ;
7084 PyObject * obj1 = 0 ;
7085 char *kwnames[] = {
7086 (char *) "self",(char *) "region", NULL
7087 };
7088
7089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7091 if (SWIG_arg_fail(1)) SWIG_fail;
7092 {
7093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7094 if (SWIG_arg_fail(2)) SWIG_fail;
7095 if (arg2 == NULL) {
7096 SWIG_null_ref("wxRegion");
7097 }
7098 if (SWIG_arg_fail(2)) SWIG_fail;
7099 }
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7103
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 {
7108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7109 }
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj;
7118 wxRegion *arg1 = (wxRegion *) 0 ;
7119 SwigValueWrapper<wxBitmap > result;
7120 PyObject * obj0 = 0 ;
7121 char *kwnames[] = {
7122 (char *) "self", NULL
7123 };
7124
7125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7127 if (SWIG_arg_fail(1)) SWIG_fail;
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 result = (arg1)->ConvertToBitmap();
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 wxBitmap * resultptr;
7137 resultptr = new wxBitmap((wxBitmap &)(result));
7138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7139 }
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxRegion *arg1 = (wxRegion *) 0 ;
7149 wxBitmap *arg2 = 0 ;
7150 bool result;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "self",(char *) "bmp", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7159 if (SWIG_arg_fail(1)) SWIG_fail;
7160 {
7161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7162 if (SWIG_arg_fail(2)) SWIG_fail;
7163 if (arg2 == NULL) {
7164 SWIG_null_ref("wxBitmap");
7165 }
7166 if (SWIG_arg_fail(2)) SWIG_fail;
7167 }
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7171
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj;
7186 wxRegion *arg1 = (wxRegion *) 0 ;
7187 wxBitmap *arg2 = 0 ;
7188 wxColour *arg3 = 0 ;
7189 int arg4 = (int) 0 ;
7190 bool result;
7191 wxColour temp3 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 PyObject * obj2 = 0 ;
7195 PyObject * obj3 = 0 ;
7196 char *kwnames[] = {
7197 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7198 };
7199
7200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7202 if (SWIG_arg_fail(1)) SWIG_fail;
7203 {
7204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(2)) SWIG_fail;
7206 if (arg2 == NULL) {
7207 SWIG_null_ref("wxBitmap");
7208 }
7209 if (SWIG_arg_fail(2)) SWIG_fail;
7210 }
7211 {
7212 arg3 = &temp3;
7213 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7214 }
7215 if (obj3) {
7216 {
7217 arg4 = (int)(SWIG_As_int(obj3));
7218 if (SWIG_arg_fail(4)) SWIG_fail;
7219 }
7220 }
7221 {
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7224
7225 wxPyEndAllowThreads(__tstate);
7226 if (PyErr_Occurred()) SWIG_fail;
7227 }
7228 {
7229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7230 }
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7238 PyObject *obj;
7239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7240 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7241 Py_INCREF(obj);
7242 return Py_BuildValue((char *)"");
7243 }
7244 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxRegion *arg1 = 0 ;
7247 wxRegionIterator *result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "region", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7254 {
7255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7256 if (SWIG_arg_fail(1)) SWIG_fail;
7257 if (arg1 == NULL) {
7258 SWIG_null_ref("wxRegion");
7259 }
7260 if (SWIG_arg_fail(1)) SWIG_fail;
7261 }
7262 {
7263 if (!wxPyCheckForApp()) SWIG_fail;
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7280 PyObject * obj0 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 delete arg1;
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 Py_INCREF(Py_None); resultobj = Py_None;
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7303 PyObject *resultobj;
7304 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7305 int result;
7306 PyObject * obj0 = 0 ;
7307 char *kwnames[] = {
7308 (char *) "self", NULL
7309 };
7310
7311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7313 if (SWIG_arg_fail(1)) SWIG_fail;
7314 {
7315 PyThreadState* __tstate = wxPyBeginAllowThreads();
7316 result = (int)(arg1)->GetX();
7317
7318 wxPyEndAllowThreads(__tstate);
7319 if (PyErr_Occurred()) SWIG_fail;
7320 }
7321 {
7322 resultobj = SWIG_From_int((int)(result));
7323 }
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj;
7332 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7333 int result;
7334 PyObject * obj0 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 result = (int)(arg1)->GetY();
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 {
7350 resultobj = SWIG_From_int((int)(result));
7351 }
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7361 int result;
7362 PyObject * obj0 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (int)(arg1)->GetW();
7373
7374 wxPyEndAllowThreads(__tstate);
7375 if (PyErr_Occurred()) SWIG_fail;
7376 }
7377 {
7378 resultobj = SWIG_From_int((int)(result));
7379 }
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7387 PyObject *resultobj;
7388 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7389 int result;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7397 if (SWIG_arg_fail(1)) SWIG_fail;
7398 {
7399 PyThreadState* __tstate = wxPyBeginAllowThreads();
7400 result = (int)(arg1)->GetWidth();
7401
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 {
7406 resultobj = SWIG_From_int((int)(result));
7407 }
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7415 PyObject *resultobj;
7416 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7417 int result;
7418 PyObject * obj0 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 {
7427 PyThreadState* __tstate = wxPyBeginAllowThreads();
7428 result = (int)(arg1)->GetH();
7429
7430 wxPyEndAllowThreads(__tstate);
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 {
7434 resultobj = SWIG_From_int((int)(result));
7435 }
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7445 int result;
7446 PyObject * obj0 = 0 ;
7447 char *kwnames[] = {
7448 (char *) "self", NULL
7449 };
7450
7451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7453 if (SWIG_arg_fail(1)) SWIG_fail;
7454 {
7455 PyThreadState* __tstate = wxPyBeginAllowThreads();
7456 result = (int)(arg1)->GetHeight();
7457
7458 wxPyEndAllowThreads(__tstate);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 {
7462 resultobj = SWIG_From_int((int)(result));
7463 }
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj;
7472 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7473 wxRect result;
7474 PyObject * obj0 = 0 ;
7475 char *kwnames[] = {
7476 (char *) "self", NULL
7477 };
7478
7479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7481 if (SWIG_arg_fail(1)) SWIG_fail;
7482 {
7483 PyThreadState* __tstate = wxPyBeginAllowThreads();
7484 result = (arg1)->GetRect();
7485
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 {
7490 wxRect * resultptr;
7491 resultptr = new wxRect((wxRect &)(result));
7492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7493 }
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj;
7502 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7503 bool result;
7504 PyObject * obj0 = 0 ;
7505 char *kwnames[] = {
7506 (char *) "self", NULL
7507 };
7508
7509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7511 if (SWIG_arg_fail(1)) SWIG_fail;
7512 {
7513 PyThreadState* __tstate = wxPyBeginAllowThreads();
7514 result = (bool)(arg1)->HaveRects();
7515
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj;
7530 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7531 PyObject * obj0 = 0 ;
7532 char *kwnames[] = {
7533 (char *) "self", NULL
7534 };
7535
7536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7538 if (SWIG_arg_fail(1)) SWIG_fail;
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 (arg1)->Reset();
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 Py_INCREF(Py_None); resultobj = Py_None;
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj;
7555 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7556 PyObject * obj0 = 0 ;
7557 char *kwnames[] = {
7558 (char *) "self", NULL
7559 };
7560
7561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(1)) SWIG_fail;
7564 {
7565 PyThreadState* __tstate = wxPyBeginAllowThreads();
7566 wxRegionIterator_Next(arg1);
7567
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 Py_INCREF(Py_None); resultobj = Py_None;
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7581 bool result;
7582 PyObject * obj0 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (bool)wxRegionIterator___nonzero__(arg1);
7593
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7607 PyObject *obj;
7608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7609 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7610 Py_INCREF(obj);
7611 return Py_BuildValue((char *)"");
7612 }
7613 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj;
7615 wxNativeFontInfo *result;
7616 char *kwnames[] = {
7617 NULL
7618 };
7619
7620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7624
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7636 PyObject *resultobj;
7637 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7638 PyObject * obj0 = 0 ;
7639 char *kwnames[] = {
7640 (char *) "self", NULL
7641 };
7642
7643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7645 if (SWIG_arg_fail(1)) SWIG_fail;
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 delete arg1;
7649
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 Py_INCREF(Py_None); resultobj = Py_None;
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj;
7662 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 (arg1)->Init();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 Py_INCREF(Py_None); resultobj = Py_None;
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj;
7687 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7688 wxFont *arg2 = 0 ;
7689 PyObject * obj0 = 0 ;
7690 PyObject * obj1 = 0 ;
7691 char *kwnames[] = {
7692 (char *) "self",(char *) "font", NULL
7693 };
7694
7695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7697 if (SWIG_arg_fail(1)) SWIG_fail;
7698 {
7699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7700 if (SWIG_arg_fail(2)) SWIG_fail;
7701 if (arg2 == NULL) {
7702 SWIG_null_ref("wxFont");
7703 }
7704 if (SWIG_arg_fail(2)) SWIG_fail;
7705 }
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 (arg1)->InitFromFont((wxFont const &)*arg2);
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 Py_INCREF(Py_None); resultobj = Py_None;
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj;
7722 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7723 int result;
7724 PyObject * obj0 = 0 ;
7725 char *kwnames[] = {
7726 (char *) "self", NULL
7727 };
7728
7729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7731 if (SWIG_arg_fail(1)) SWIG_fail;
7732 {
7733 PyThreadState* __tstate = wxPyBeginAllowThreads();
7734 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7735
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 {
7740 resultobj = SWIG_From_int((int)(result));
7741 }
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7749 PyObject *resultobj;
7750 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7751 wxFontStyle result;
7752 PyObject * obj0 = 0 ;
7753 char *kwnames[] = {
7754 (char *) "self", NULL
7755 };
7756
7757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7759 if (SWIG_arg_fail(1)) SWIG_fail;
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 resultobj = SWIG_From_int((result));
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj;
7776 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7777 wxFontWeight result;
7778 PyObject * obj0 = 0 ;
7779 char *kwnames[] = {
7780 (char *) "self", NULL
7781 };
7782
7783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7785 if (SWIG_arg_fail(1)) SWIG_fail;
7786 {
7787 PyThreadState* __tstate = wxPyBeginAllowThreads();
7788 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7789
7790 wxPyEndAllowThreads(__tstate);
7791 if (PyErr_Occurred()) SWIG_fail;
7792 }
7793 resultobj = SWIG_From_int((result));
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj;
7802 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 char *kwnames[] = {
7806 (char *) "self", NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7811 if (SWIG_arg_fail(1)) SWIG_fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 {
7820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7821 }
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj;
7830 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7831 wxString result;
7832 PyObject * obj0 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "self", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 PyThreadState* __tstate = wxPyBeginAllowThreads();
7842 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7843
7844 wxPyEndAllowThreads(__tstate);
7845 if (PyErr_Occurred()) SWIG_fail;
7846 }
7847 {
7848 #if wxUSE_UNICODE
7849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7850 #else
7851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7852 #endif
7853 }
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj;
7862 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7863 wxFontFamily result;
7864 PyObject * obj0 = 0 ;
7865 char *kwnames[] = {
7866 (char *) "self", NULL
7867 };
7868
7869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7871 if (SWIG_arg_fail(1)) SWIG_fail;
7872 {
7873 PyThreadState* __tstate = wxPyBeginAllowThreads();
7874 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7875
7876 wxPyEndAllowThreads(__tstate);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 resultobj = SWIG_From_int((result));
7880 return resultobj;
7881 fail:
7882 return NULL;
7883 }
7884
7885
7886 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7887 PyObject *resultobj;
7888 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7889 wxFontEncoding result;
7890 PyObject * obj0 = 0 ;
7891 char *kwnames[] = {
7892 (char *) "self", NULL
7893 };
7894
7895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7897 if (SWIG_arg_fail(1)) SWIG_fail;
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7901
7902 wxPyEndAllowThreads(__tstate);
7903 if (PyErr_Occurred()) SWIG_fail;
7904 }
7905 resultobj = SWIG_From_int((result));
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7913 PyObject *resultobj;
7914 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7915 int arg2 ;
7916 PyObject * obj0 = 0 ;
7917 PyObject * obj1 = 0 ;
7918 char *kwnames[] = {
7919 (char *) "self",(char *) "pointsize", NULL
7920 };
7921
7922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7924 if (SWIG_arg_fail(1)) SWIG_fail;
7925 {
7926 arg2 = (int)(SWIG_As_int(obj1));
7927 if (SWIG_arg_fail(2)) SWIG_fail;
7928 }
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 (arg1)->SetPointSize(arg2);
7932
7933 wxPyEndAllowThreads(__tstate);
7934 if (PyErr_Occurred()) SWIG_fail;
7935 }
7936 Py_INCREF(Py_None); resultobj = Py_None;
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7944 PyObject *resultobj;
7945 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7946 wxFontStyle arg2 ;
7947 PyObject * obj0 = 0 ;
7948 PyObject * obj1 = 0 ;
7949 char *kwnames[] = {
7950 (char *) "self",(char *) "style", NULL
7951 };
7952
7953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7955 if (SWIG_arg_fail(1)) SWIG_fail;
7956 {
7957 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7958 if (SWIG_arg_fail(2)) SWIG_fail;
7959 }
7960 {
7961 PyThreadState* __tstate = wxPyBeginAllowThreads();
7962 (arg1)->SetStyle((wxFontStyle )arg2);
7963
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 Py_INCREF(Py_None); resultobj = Py_None;
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj;
7976 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7977 wxFontWeight arg2 ;
7978 PyObject * obj0 = 0 ;
7979 PyObject * obj1 = 0 ;
7980 char *kwnames[] = {
7981 (char *) "self",(char *) "weight", NULL
7982 };
7983
7984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7986 if (SWIG_arg_fail(1)) SWIG_fail;
7987 {
7988 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7989 if (SWIG_arg_fail(2)) SWIG_fail;
7990 }
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 (arg1)->SetWeight((wxFontWeight )arg2);
7994
7995 wxPyEndAllowThreads(__tstate);
7996 if (PyErr_Occurred()) SWIG_fail;
7997 }
7998 Py_INCREF(Py_None); resultobj = Py_None;
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj;
8007 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8008 bool arg2 ;
8009 PyObject * obj0 = 0 ;
8010 PyObject * obj1 = 0 ;
8011 char *kwnames[] = {
8012 (char *) "self",(char *) "underlined", NULL
8013 };
8014
8015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8017 if (SWIG_arg_fail(1)) SWIG_fail;
8018 {
8019 arg2 = (bool)(SWIG_As_bool(obj1));
8020 if (SWIG_arg_fail(2)) SWIG_fail;
8021 }
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 (arg1)->SetUnderlined(arg2);
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 Py_INCREF(Py_None); resultobj = Py_None;
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8037 PyObject *resultobj;
8038 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8039 wxString arg2 ;
8040 PyObject * obj0 = 0 ;
8041 PyObject * obj1 = 0 ;
8042 char *kwnames[] = {
8043 (char *) "self",(char *) "facename", NULL
8044 };
8045
8046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8048 if (SWIG_arg_fail(1)) SWIG_fail;
8049 {
8050 wxString* sptr = wxString_in_helper(obj1);
8051 if (sptr == NULL) SWIG_fail;
8052 arg2 = *sptr;
8053 delete sptr;
8054 }
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 (arg1)->SetFaceName(arg2);
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 Py_INCREF(Py_None); resultobj = Py_None;
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8070 PyObject *resultobj;
8071 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8072 wxFontFamily arg2 ;
8073 PyObject * obj0 = 0 ;
8074 PyObject * obj1 = 0 ;
8075 char *kwnames[] = {
8076 (char *) "self",(char *) "family", NULL
8077 };
8078
8079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8081 if (SWIG_arg_fail(1)) SWIG_fail;
8082 {
8083 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8084 if (SWIG_arg_fail(2)) SWIG_fail;
8085 }
8086 {
8087 PyThreadState* __tstate = wxPyBeginAllowThreads();
8088 (arg1)->SetFamily((wxFontFamily )arg2);
8089
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 Py_INCREF(Py_None); resultobj = Py_None;
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj;
8102 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8103 wxFontEncoding arg2 ;
8104 PyObject * obj0 = 0 ;
8105 PyObject * obj1 = 0 ;
8106 char *kwnames[] = {
8107 (char *) "self",(char *) "encoding", NULL
8108 };
8109
8110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8112 if (SWIG_arg_fail(1)) SWIG_fail;
8113 {
8114 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8115 if (SWIG_arg_fail(2)) SWIG_fail;
8116 }
8117 {
8118 PyThreadState* __tstate = wxPyBeginAllowThreads();
8119 (arg1)->SetEncoding((wxFontEncoding )arg2);
8120
8121 wxPyEndAllowThreads(__tstate);
8122 if (PyErr_Occurred()) SWIG_fail;
8123 }
8124 Py_INCREF(Py_None); resultobj = Py_None;
8125 return resultobj;
8126 fail:
8127 return NULL;
8128 }
8129
8130
8131 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8132 PyObject *resultobj;
8133 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8134 wxString *arg2 = 0 ;
8135 bool result;
8136 bool temp2 = false ;
8137 PyObject * obj0 = 0 ;
8138 PyObject * obj1 = 0 ;
8139 char *kwnames[] = {
8140 (char *) "self",(char *) "s", NULL
8141 };
8142
8143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8145 if (SWIG_arg_fail(1)) SWIG_fail;
8146 {
8147 arg2 = wxString_in_helper(obj1);
8148 if (arg2 == NULL) SWIG_fail;
8149 temp2 = true;
8150 }
8151 {
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8154
8155 wxPyEndAllowThreads(__tstate);
8156 if (PyErr_Occurred()) SWIG_fail;
8157 }
8158 {
8159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8160 }
8161 {
8162 if (temp2)
8163 delete arg2;
8164 }
8165 return resultobj;
8166 fail:
8167 {
8168 if (temp2)
8169 delete arg2;
8170 }
8171 return NULL;
8172 }
8173
8174
8175 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj;
8177 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8178 wxString result;
8179 PyObject * obj0 = 0 ;
8180 char *kwnames[] = {
8181 (char *) "self", NULL
8182 };
8183
8184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8186 if (SWIG_arg_fail(1)) SWIG_fail;
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 result = ((wxNativeFontInfo const *)arg1)->ToString();
8190
8191 wxPyEndAllowThreads(__tstate);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 {
8195 #if wxUSE_UNICODE
8196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8197 #else
8198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8199 #endif
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8210 wxString result;
8211 PyObject * obj0 = 0 ;
8212 char *kwnames[] = {
8213 (char *) "self", NULL
8214 };
8215
8216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = wxNativeFontInfo___str__(arg1);
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 #if wxUSE_UNICODE
8228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8229 #else
8230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8231 #endif
8232 }
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj;
8241 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8242 wxString *arg2 = 0 ;
8243 bool result;
8244 bool temp2 = false ;
8245 PyObject * obj0 = 0 ;
8246 PyObject * obj1 = 0 ;
8247 char *kwnames[] = {
8248 (char *) "self",(char *) "s", NULL
8249 };
8250
8251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8253 if (SWIG_arg_fail(1)) SWIG_fail;
8254 {
8255 arg2 = wxString_in_helper(obj1);
8256 if (arg2 == NULL) SWIG_fail;
8257 temp2 = true;
8258 }
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 {
8267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8268 }
8269 {
8270 if (temp2)
8271 delete arg2;
8272 }
8273 return resultobj;
8274 fail:
8275 {
8276 if (temp2)
8277 delete arg2;
8278 }
8279 return NULL;
8280 }
8281
8282
8283 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8284 PyObject *resultobj;
8285 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8286 wxString result;
8287 PyObject * obj0 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 #if wxUSE_UNICODE
8304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8305 #else
8306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8307 #endif
8308 }
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8316 PyObject *obj;
8317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8318 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8319 Py_INCREF(obj);
8320 return Py_BuildValue((char *)"");
8321 }
8322 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj;
8324 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8325 wxString *arg2 = (wxString *) 0 ;
8326 bool temp2 = false ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "facename", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 arg2 = wxString_in_helper(obj1);
8338 if (arg2 == NULL) SWIG_fail;
8339 temp2 = true;
8340 }
8341 if (arg1) (arg1)->facename = *arg2;
8342
8343 Py_INCREF(Py_None); resultobj = Py_None;
8344 {
8345 if (temp2)
8346 delete arg2;
8347 }
8348 return resultobj;
8349 fail:
8350 {
8351 if (temp2)
8352 delete arg2;
8353 }
8354 return NULL;
8355 }
8356
8357
8358 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj;
8360 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8361 wxString *result;
8362 PyObject * obj0 = 0 ;
8363 char *kwnames[] = {
8364 (char *) "self", NULL
8365 };
8366
8367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8369 if (SWIG_arg_fail(1)) SWIG_fail;
8370 result = (wxString *)& ((arg1)->facename);
8371
8372 {
8373 #if wxUSE_UNICODE
8374 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8375 #else
8376 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8377 #endif
8378 }
8379 return resultobj;
8380 fail:
8381 return NULL;
8382 }
8383
8384
8385 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8386 PyObject *resultobj;
8387 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8388 wxFontEncoding arg2 ;
8389 PyObject * obj0 = 0 ;
8390 PyObject * obj1 = 0 ;
8391 char *kwnames[] = {
8392 (char *) "self",(char *) "encoding", NULL
8393 };
8394
8395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8397 if (SWIG_arg_fail(1)) SWIG_fail;
8398 {
8399 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8400 if (SWIG_arg_fail(2)) SWIG_fail;
8401 }
8402 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8403
8404 Py_INCREF(Py_None); resultobj = Py_None;
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8412 PyObject *resultobj;
8413 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8414 wxFontEncoding result;
8415 PyObject * obj0 = 0 ;
8416 char *kwnames[] = {
8417 (char *) "self", NULL
8418 };
8419
8420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8422 if (SWIG_arg_fail(1)) SWIG_fail;
8423 result = (wxFontEncoding) ((arg1)->encoding);
8424
8425 resultobj = SWIG_From_int((result));
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8433 PyObject *resultobj;
8434 wxNativeEncodingInfo *result;
8435 char *kwnames[] = {
8436 NULL
8437 };
8438
8439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj;
8456 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8457 PyObject * obj0 = 0 ;
8458 char *kwnames[] = {
8459 (char *) "self", NULL
8460 };
8461
8462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8464 if (SWIG_arg_fail(1)) SWIG_fail;
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 delete arg1;
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 Py_INCREF(Py_None); resultobj = Py_None;
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8480 PyObject *resultobj;
8481 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8482 wxString *arg2 = 0 ;
8483 bool result;
8484 bool temp2 = false ;
8485 PyObject * obj0 = 0 ;
8486 PyObject * obj1 = 0 ;
8487 char *kwnames[] = {
8488 (char *) "self",(char *) "s", NULL
8489 };
8490
8491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8493 if (SWIG_arg_fail(1)) SWIG_fail;
8494 {
8495 arg2 = wxString_in_helper(obj1);
8496 if (arg2 == NULL) SWIG_fail;
8497 temp2 = true;
8498 }
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8502
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 {
8507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8508 }
8509 {
8510 if (temp2)
8511 delete arg2;
8512 }
8513 return resultobj;
8514 fail:
8515 {
8516 if (temp2)
8517 delete arg2;
8518 }
8519 return NULL;
8520 }
8521
8522
8523 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8524 PyObject *resultobj;
8525 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8526 wxString result;
8527 PyObject * obj0 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "self", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 {
8543 #if wxUSE_UNICODE
8544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8545 #else
8546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8547 #endif
8548 }
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8556 PyObject *obj;
8557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8558 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8559 Py_INCREF(obj);
8560 return Py_BuildValue((char *)"");
8561 }
8562 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj;
8564 wxFontEncoding arg1 ;
8565 wxNativeEncodingInfo *result;
8566 PyObject * obj0 = 0 ;
8567 char *kwnames[] = {
8568 (char *) "encoding", NULL
8569 };
8570
8571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8572 {
8573 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 }
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8579
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj;
8592 wxNativeEncodingInfo *arg1 = 0 ;
8593 bool result;
8594 PyObject * obj0 = 0 ;
8595 char *kwnames[] = {
8596 (char *) "info", NULL
8597 };
8598
8599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8600 {
8601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8602 if (SWIG_arg_fail(1)) SWIG_fail;
8603 if (arg1 == NULL) {
8604 SWIG_null_ref("wxNativeEncodingInfo");
8605 }
8606 if (SWIG_arg_fail(1)) SWIG_fail;
8607 }
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 {
8616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8617 }
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj;
8626 wxFontMapper *result;
8627 char *kwnames[] = {
8628 NULL
8629 };
8630
8631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 result = (wxFontMapper *)new wxFontMapper();
8635
8636 wxPyEndAllowThreads(__tstate);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj;
8648 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8649 PyObject * obj0 = 0 ;
8650 char *kwnames[] = {
8651 (char *) "self", NULL
8652 };
8653
8654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8656 if (SWIG_arg_fail(1)) SWIG_fail;
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 delete arg1;
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 Py_INCREF(Py_None); resultobj = Py_None;
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj;
8673 wxFontMapper *result;
8674 char *kwnames[] = {
8675 NULL
8676 };
8677
8678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8679 {
8680 PyThreadState* __tstate = wxPyBeginAllowThreads();
8681 result = (wxFontMapper *)wxFontMapper::Get();
8682
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj;
8695 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8696 wxFontMapper *result;
8697 PyObject * obj0 = 0 ;
8698 char *kwnames[] = {
8699 (char *) "mapper", NULL
8700 };
8701
8702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8704 if (SWIG_arg_fail(1)) SWIG_fail;
8705 {
8706 PyThreadState* __tstate = wxPyBeginAllowThreads();
8707 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8708
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj;
8721 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8722 wxString *arg2 = 0 ;
8723 bool arg3 = (bool) true ;
8724 wxFontEncoding result;
8725 bool temp2 = false ;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 PyObject * obj2 = 0 ;
8729 char *kwnames[] = {
8730 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8731 };
8732
8733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8735 if (SWIG_arg_fail(1)) SWIG_fail;
8736 {
8737 arg2 = wxString_in_helper(obj1);
8738 if (arg2 == NULL) SWIG_fail;
8739 temp2 = true;
8740 }
8741 if (obj2) {
8742 {
8743 arg3 = (bool)(SWIG_As_bool(obj2));
8744 if (SWIG_arg_fail(3)) SWIG_fail;
8745 }
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_From_int((result));
8755 {
8756 if (temp2)
8757 delete arg2;
8758 }
8759 return resultobj;
8760 fail:
8761 {
8762 if (temp2)
8763 delete arg2;
8764 }
8765 return NULL;
8766 }
8767
8768
8769 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8770 PyObject *resultobj;
8771 size_t result;
8772 char *kwnames[] = {
8773 NULL
8774 };
8775
8776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8777 {
8778 PyThreadState* __tstate = wxPyBeginAllowThreads();
8779 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8780
8781 wxPyEndAllowThreads(__tstate);
8782 if (PyErr_Occurred()) SWIG_fail;
8783 }
8784 {
8785 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8786 }
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 size_t arg1 ;
8796 wxFontEncoding result;
8797 PyObject * obj0 = 0 ;
8798 char *kwnames[] = {
8799 (char *) "n", NULL
8800 };
8801
8802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8803 {
8804 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8805 if (SWIG_arg_fail(1)) SWIG_fail;
8806 }
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 resultobj = SWIG_From_int((result));
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8822 PyObject *resultobj;
8823 wxFontEncoding arg1 ;
8824 wxString result;
8825 PyObject * obj0 = 0 ;
8826 char *kwnames[] = {
8827 (char *) "encoding", NULL
8828 };
8829
8830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8831 {
8832 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8833 if (SWIG_arg_fail(1)) SWIG_fail;
8834 }
8835 {
8836 PyThreadState* __tstate = wxPyBeginAllowThreads();
8837 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8838
8839 wxPyEndAllowThreads(__tstate);
8840 if (PyErr_Occurred()) SWIG_fail;
8841 }
8842 {
8843 #if wxUSE_UNICODE
8844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8845 #else
8846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8847 #endif
8848 }
8849 return resultobj;
8850 fail:
8851 return NULL;
8852 }
8853
8854
8855 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8856 PyObject *resultobj;
8857 wxFontEncoding arg1 ;
8858 wxString result;
8859 PyObject * obj0 = 0 ;
8860 char *kwnames[] = {
8861 (char *) "encoding", NULL
8862 };
8863
8864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8865 {
8866 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8867 if (SWIG_arg_fail(1)) SWIG_fail;
8868 }
8869 {
8870 PyThreadState* __tstate = wxPyBeginAllowThreads();
8871 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8872
8873 wxPyEndAllowThreads(__tstate);
8874 if (PyErr_Occurred()) SWIG_fail;
8875 }
8876 {
8877 #if wxUSE_UNICODE
8878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8879 #else
8880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8881 #endif
8882 }
8883 return resultobj;
8884 fail:
8885 return NULL;
8886 }
8887
8888
8889 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8890 PyObject *resultobj;
8891 wxString *arg1 = 0 ;
8892 wxFontEncoding result;
8893 bool temp1 = false ;
8894 PyObject * obj0 = 0 ;
8895 char *kwnames[] = {
8896 (char *) "name", NULL
8897 };
8898
8899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8900 {
8901 arg1 = wxString_in_helper(obj0);
8902 if (arg1 == NULL) SWIG_fail;
8903 temp1 = true;
8904 }
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8908
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_From_int((result));
8913 {
8914 if (temp1)
8915 delete arg1;
8916 }
8917 return resultobj;
8918 fail:
8919 {
8920 if (temp1)
8921 delete arg1;
8922 }
8923 return NULL;
8924 }
8925
8926
8927 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8928 PyObject *resultobj;
8929 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8930 wxString *arg2 = 0 ;
8931 bool temp2 = false ;
8932 PyObject * obj0 = 0 ;
8933 PyObject * obj1 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "prefix", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",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 {
8942 arg2 = wxString_in_helper(obj1);
8943 if (arg2 == NULL) SWIG_fail;
8944 temp2 = true;
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 (arg1)->SetConfigPath((wxString const &)*arg2);
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 Py_INCREF(Py_None); resultobj = Py_None;
8954 {
8955 if (temp2)
8956 delete arg2;
8957 }
8958 return resultobj;
8959 fail:
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 wxString result;
8971 char *kwnames[] = {
8972 NULL
8973 };
8974
8975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = wxFontMapper::GetDefaultConfigPath();
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 {
8984 #if wxUSE_UNICODE
8985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8986 #else
8987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8988 #endif
8989 }
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj;
8998 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8999 wxFontEncoding arg2 ;
9000 wxString const &arg3_defvalue = wxPyEmptyString ;
9001 wxString *arg3 = (wxString *) &arg3_defvalue ;
9002 bool arg4 = (bool) true ;
9003 PyObject *result;
9004 bool temp3 = false ;
9005 PyObject * obj0 = 0 ;
9006 PyObject * obj1 = 0 ;
9007 PyObject * obj2 = 0 ;
9008 PyObject * obj3 = 0 ;
9009 char *kwnames[] = {
9010 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9011 };
9012
9013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9015 if (SWIG_arg_fail(1)) SWIG_fail;
9016 {
9017 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9018 if (SWIG_arg_fail(2)) SWIG_fail;
9019 }
9020 if (obj2) {
9021 {
9022 arg3 = wxString_in_helper(obj2);
9023 if (arg3 == NULL) SWIG_fail;
9024 temp3 = true;
9025 }
9026 }
9027 if (obj3) {
9028 {
9029 arg4 = (bool)(SWIG_As_bool(obj3));
9030 if (SWIG_arg_fail(4)) SWIG_fail;
9031 }
9032 }
9033 {
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9036
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = result;
9041 {
9042 if (temp3)
9043 delete arg3;
9044 }
9045 return resultobj;
9046 fail:
9047 {
9048 if (temp3)
9049 delete arg3;
9050 }
9051 return NULL;
9052 }
9053
9054
9055 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9056 PyObject *resultobj;
9057 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9058 wxFontEncoding arg2 ;
9059 wxString const &arg3_defvalue = wxPyEmptyString ;
9060 wxString *arg3 = (wxString *) &arg3_defvalue ;
9061 bool result;
9062 bool temp3 = false ;
9063 PyObject * obj0 = 0 ;
9064 PyObject * obj1 = 0 ;
9065 PyObject * obj2 = 0 ;
9066 char *kwnames[] = {
9067 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9072 if (SWIG_arg_fail(1)) SWIG_fail;
9073 {
9074 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9075 if (SWIG_arg_fail(2)) SWIG_fail;
9076 }
9077 if (obj2) {
9078 {
9079 arg3 = wxString_in_helper(obj2);
9080 if (arg3 == NULL) SWIG_fail;
9081 temp3 = true;
9082 }
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 {
9092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9093 }
9094 {
9095 if (temp3)
9096 delete arg3;
9097 }
9098 return resultobj;
9099 fail:
9100 {
9101 if (temp3)
9102 delete arg3;
9103 }
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9111 wxWindow *arg2 = (wxWindow *) 0 ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self",(char *) "parent", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9122 if (SWIG_arg_fail(2)) SWIG_fail;
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 (arg1)->SetDialogParent(arg2);
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 Py_INCREF(Py_None); resultobj = Py_None;
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9140 wxString *arg2 = 0 ;
9141 bool temp2 = false ;
9142 PyObject * obj0 = 0 ;
9143 PyObject * obj1 = 0 ;
9144 char *kwnames[] = {
9145 (char *) "self",(char *) "title", NULL
9146 };
9147
9148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",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 {
9152 arg2 = wxString_in_helper(obj1);
9153 if (arg2 == NULL) SWIG_fail;
9154 temp2 = true;
9155 }
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 (arg1)->SetDialogTitle((wxString const &)*arg2);
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 Py_INCREF(Py_None); resultobj = Py_None;
9164 {
9165 if (temp2)
9166 delete arg2;
9167 }
9168 return resultobj;
9169 fail:
9170 {
9171 if (temp2)
9172 delete arg2;
9173 }
9174 return NULL;
9175 }
9176
9177
9178 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9179 PyObject *obj;
9180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9181 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9182 Py_INCREF(obj);
9183 return Py_BuildValue((char *)"");
9184 }
9185 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 int arg1 ;
9188 int arg2 ;
9189 int arg3 ;
9190 int arg4 ;
9191 bool arg5 = (bool) false ;
9192 wxString const &arg6_defvalue = wxPyEmptyString ;
9193 wxString *arg6 = (wxString *) &arg6_defvalue ;
9194 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9195 wxFont *result;
9196 bool temp6 = false ;
9197 PyObject * obj0 = 0 ;
9198 PyObject * obj1 = 0 ;
9199 PyObject * obj2 = 0 ;
9200 PyObject * obj3 = 0 ;
9201 PyObject * obj4 = 0 ;
9202 PyObject * obj5 = 0 ;
9203 PyObject * obj6 = 0 ;
9204 char *kwnames[] = {
9205 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9206 };
9207
9208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9209 {
9210 arg1 = (int)(SWIG_As_int(obj0));
9211 if (SWIG_arg_fail(1)) SWIG_fail;
9212 }
9213 {
9214 arg2 = (int)(SWIG_As_int(obj1));
9215 if (SWIG_arg_fail(2)) SWIG_fail;
9216 }
9217 {
9218 arg3 = (int)(SWIG_As_int(obj2));
9219 if (SWIG_arg_fail(3)) SWIG_fail;
9220 }
9221 {
9222 arg4 = (int)(SWIG_As_int(obj3));
9223 if (SWIG_arg_fail(4)) SWIG_fail;
9224 }
9225 if (obj4) {
9226 {
9227 arg5 = (bool)(SWIG_As_bool(obj4));
9228 if (SWIG_arg_fail(5)) SWIG_fail;
9229 }
9230 }
9231 if (obj5) {
9232 {
9233 arg6 = wxString_in_helper(obj5);
9234 if (arg6 == NULL) SWIG_fail;
9235 temp6 = true;
9236 }
9237 }
9238 if (obj6) {
9239 {
9240 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9241 if (SWIG_arg_fail(7)) SWIG_fail;
9242 }
9243 }
9244 {
9245 if (!wxPyCheckForApp()) SWIG_fail;
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9253 {
9254 if (temp6)
9255 delete arg6;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp6)
9261 delete arg6;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 wxFont *arg1 = (wxFont *) 0 ;
9270 PyObject * obj0 = 0 ;
9271 char *kwnames[] = {
9272 (char *) "self", NULL
9273 };
9274
9275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9277 if (SWIG_arg_fail(1)) SWIG_fail;
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 delete arg1;
9281
9282 wxPyEndAllowThreads(__tstate);
9283 if (PyErr_Occurred()) SWIG_fail;
9284 }
9285 Py_INCREF(Py_None); resultobj = Py_None;
9286 return resultobj;
9287 fail:
9288 return NULL;
9289 }
9290
9291
9292 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj;
9294 wxNativeFontInfo *arg1 = 0 ;
9295 wxFont *result;
9296 PyObject * obj0 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "info", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9302 {
9303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9304 if (SWIG_arg_fail(1)) SWIG_fail;
9305 if (arg1 == NULL) {
9306 SWIG_null_ref("wxNativeFontInfo");
9307 }
9308 if (SWIG_arg_fail(1)) SWIG_fail;
9309 }
9310 {
9311 if (!wxPyCheckForApp()) SWIG_fail;
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9319 return resultobj;
9320 fail:
9321 return NULL;
9322 }
9323
9324
9325 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9326 PyObject *resultobj;
9327 wxString *arg1 = 0 ;
9328 wxFont *result;
9329 bool temp1 = false ;
9330 PyObject * obj0 = 0 ;
9331 char *kwnames[] = {
9332 (char *) "info", NULL
9333 };
9334
9335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9336 {
9337 arg1 = wxString_in_helper(obj0);
9338 if (arg1 == NULL) SWIG_fail;
9339 temp1 = true;
9340 }
9341 {
9342 if (!wxPyCheckForApp()) SWIG_fail;
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9345
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9350 {
9351 if (temp1)
9352 delete arg1;
9353 }
9354 return resultobj;
9355 fail:
9356 {
9357 if (temp1)
9358 delete arg1;
9359 }
9360 return NULL;
9361 }
9362
9363
9364 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj;
9366 int arg1 ;
9367 wxFontFamily arg2 ;
9368 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9369 wxString const &arg4_defvalue = wxPyEmptyString ;
9370 wxString *arg4 = (wxString *) &arg4_defvalue ;
9371 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9372 wxFont *result;
9373 bool temp4 = false ;
9374 PyObject * obj0 = 0 ;
9375 PyObject * obj1 = 0 ;
9376 PyObject * obj2 = 0 ;
9377 PyObject * obj3 = 0 ;
9378 PyObject * obj4 = 0 ;
9379 char *kwnames[] = {
9380 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9381 };
9382
9383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9384 {
9385 arg1 = (int)(SWIG_As_int(obj0));
9386 if (SWIG_arg_fail(1)) SWIG_fail;
9387 }
9388 {
9389 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9390 if (SWIG_arg_fail(2)) SWIG_fail;
9391 }
9392 if (obj2) {
9393 {
9394 arg3 = (int)(SWIG_As_int(obj2));
9395 if (SWIG_arg_fail(3)) SWIG_fail;
9396 }
9397 }
9398 if (obj3) {
9399 {
9400 arg4 = wxString_in_helper(obj3);
9401 if (arg4 == NULL) SWIG_fail;
9402 temp4 = true;
9403 }
9404 }
9405 if (obj4) {
9406 {
9407 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9408 if (SWIG_arg_fail(5)) SWIG_fail;
9409 }
9410 }
9411 {
9412 if (!wxPyCheckForApp()) SWIG_fail;
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9415
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9420 {
9421 if (temp4)
9422 delete arg4;
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 if (temp4)
9428 delete arg4;
9429 }
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxSize *arg1 = 0 ;
9437 int arg2 ;
9438 int arg3 ;
9439 int arg4 ;
9440 bool arg5 = (bool) false ;
9441 wxString const &arg6_defvalue = wxEmptyString ;
9442 wxString *arg6 = (wxString *) &arg6_defvalue ;
9443 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9444 wxFont *result;
9445 wxSize temp1 ;
9446 bool temp6 = false ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 PyObject * obj2 = 0 ;
9450 PyObject * obj3 = 0 ;
9451 PyObject * obj4 = 0 ;
9452 PyObject * obj5 = 0 ;
9453 PyObject * obj6 = 0 ;
9454 char *kwnames[] = {
9455 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9456 };
9457
9458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9459 {
9460 arg1 = &temp1;
9461 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9462 }
9463 {
9464 arg2 = (int)(SWIG_As_int(obj1));
9465 if (SWIG_arg_fail(2)) SWIG_fail;
9466 }
9467 {
9468 arg3 = (int)(SWIG_As_int(obj2));
9469 if (SWIG_arg_fail(3)) SWIG_fail;
9470 }
9471 {
9472 arg4 = (int)(SWIG_As_int(obj3));
9473 if (SWIG_arg_fail(4)) SWIG_fail;
9474 }
9475 if (obj4) {
9476 {
9477 arg5 = (bool)(SWIG_As_bool(obj4));
9478 if (SWIG_arg_fail(5)) SWIG_fail;
9479 }
9480 }
9481 if (obj5) {
9482 {
9483 arg6 = wxString_in_helper(obj5);
9484 if (arg6 == NULL) SWIG_fail;
9485 temp6 = true;
9486 }
9487 }
9488 if (obj6) {
9489 {
9490 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9491 if (SWIG_arg_fail(7)) SWIG_fail;
9492 }
9493 }
9494 {
9495 if (!wxPyCheckForApp()) SWIG_fail;
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9498
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9503 {
9504 if (temp6)
9505 delete arg6;
9506 }
9507 return resultobj;
9508 fail:
9509 {
9510 if (temp6)
9511 delete arg6;
9512 }
9513 return NULL;
9514 }
9515
9516
9517 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj;
9519 wxSize *arg1 = 0 ;
9520 wxFontFamily arg2 ;
9521 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9522 wxString const &arg4_defvalue = wxEmptyString ;
9523 wxString *arg4 = (wxString *) &arg4_defvalue ;
9524 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9525 wxFont *result;
9526 wxSize temp1 ;
9527 bool temp4 = false ;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 PyObject * obj2 = 0 ;
9531 PyObject * obj3 = 0 ;
9532 PyObject * obj4 = 0 ;
9533 char *kwnames[] = {
9534 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9535 };
9536
9537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9538 {
9539 arg1 = &temp1;
9540 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9541 }
9542 {
9543 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9544 if (SWIG_arg_fail(2)) SWIG_fail;
9545 }
9546 if (obj2) {
9547 {
9548 arg3 = (int)(SWIG_As_int(obj2));
9549 if (SWIG_arg_fail(3)) SWIG_fail;
9550 }
9551 }
9552 if (obj3) {
9553 {
9554 arg4 = wxString_in_helper(obj3);
9555 if (arg4 == NULL) SWIG_fail;
9556 temp4 = true;
9557 }
9558 }
9559 if (obj4) {
9560 {
9561 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9562 if (SWIG_arg_fail(5)) SWIG_fail;
9563 }
9564 }
9565 {
9566 if (!wxPyCheckForApp()) SWIG_fail;
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9569
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9574 {
9575 if (temp4)
9576 delete arg4;
9577 }
9578 return resultobj;
9579 fail:
9580 {
9581 if (temp4)
9582 delete arg4;
9583 }
9584 return NULL;
9585 }
9586
9587
9588 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxFont *arg1 = (wxFont *) 0 ;
9591 bool result;
9592 PyObject * obj0 = 0 ;
9593 char *kwnames[] = {
9594 (char *) "self", NULL
9595 };
9596
9597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9599 if (SWIG_arg_fail(1)) SWIG_fail;
9600 {
9601 PyThreadState* __tstate = wxPyBeginAllowThreads();
9602 result = (bool)((wxFont const *)arg1)->Ok();
9603
9604 wxPyEndAllowThreads(__tstate);
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 {
9608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9609 }
9610 return resultobj;
9611 fail:
9612 return NULL;
9613 }
9614
9615
9616 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxFont *arg1 = (wxFont *) 0 ;
9619 wxFont *arg2 = (wxFont *) 0 ;
9620 bool result;
9621 PyObject * obj0 = 0 ;
9622 PyObject * obj1 = 0 ;
9623 char *kwnames[] = {
9624 (char *) "self",(char *) "other", NULL
9625 };
9626
9627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9631 if (SWIG_arg_fail(2)) SWIG_fail;
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 {
9640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9641 }
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj;
9650 wxFont *arg1 = (wxFont *) 0 ;
9651 wxFont *arg2 = (wxFont *) 0 ;
9652 bool result;
9653 PyObject * obj0 = 0 ;
9654 PyObject * obj1 = 0 ;
9655 char *kwnames[] = {
9656 (char *) "self",(char *) "other", NULL
9657 };
9658
9659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9661 if (SWIG_arg_fail(1)) SWIG_fail;
9662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9663 if (SWIG_arg_fail(2)) SWIG_fail;
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9667
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 {
9672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9673 }
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9681 PyObject *resultobj;
9682 wxFont *arg1 = (wxFont *) 0 ;
9683 int result;
9684 PyObject * obj0 = 0 ;
9685 char *kwnames[] = {
9686 (char *) "self", NULL
9687 };
9688
9689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) 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 {
9693 PyThreadState* __tstate = wxPyBeginAllowThreads();
9694 result = (int)((wxFont const *)arg1)->GetPointSize();
9695
9696 wxPyEndAllowThreads(__tstate);
9697 if (PyErr_Occurred()) SWIG_fail;
9698 }
9699 {
9700 resultobj = SWIG_From_int((int)(result));
9701 }
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9709 PyObject *resultobj;
9710 wxFont *arg1 = (wxFont *) 0 ;
9711 wxSize result;
9712 PyObject * obj0 = 0 ;
9713 char *kwnames[] = {
9714 (char *) "self", NULL
9715 };
9716
9717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9719 if (SWIG_arg_fail(1)) SWIG_fail;
9720 {
9721 PyThreadState* __tstate = wxPyBeginAllowThreads();
9722 result = ((wxFont const *)arg1)->GetPixelSize();
9723
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 wxSize * resultptr;
9729 resultptr = new wxSize((wxSize &)(result));
9730 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9731 }
9732 return resultobj;
9733 fail:
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxFont *arg1 = (wxFont *) 0 ;
9741 bool result;
9742 PyObject * obj0 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",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 = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9753
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 {
9758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9759 }
9760 return resultobj;
9761 fail:
9762 return NULL;
9763 }
9764
9765
9766 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj;
9768 wxFont *arg1 = (wxFont *) 0 ;
9769 int result;
9770 PyObject * obj0 = 0 ;
9771 char *kwnames[] = {
9772 (char *) "self", NULL
9773 };
9774
9775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9777 if (SWIG_arg_fail(1)) SWIG_fail;
9778 {
9779 PyThreadState* __tstate = wxPyBeginAllowThreads();
9780 result = (int)((wxFont const *)arg1)->GetFamily();
9781
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 {
9786 resultobj = SWIG_From_int((int)(result));
9787 }
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj;
9796 wxFont *arg1 = (wxFont *) 0 ;
9797 int result;
9798 PyObject * obj0 = 0 ;
9799 char *kwnames[] = {
9800 (char *) "self", NULL
9801 };
9802
9803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9805 if (SWIG_arg_fail(1)) SWIG_fail;
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 result = (int)((wxFont const *)arg1)->GetStyle();
9809
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 {
9814 resultobj = SWIG_From_int((int)(result));
9815 }
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9823 PyObject *resultobj;
9824 wxFont *arg1 = (wxFont *) 0 ;
9825 int result;
9826 PyObject * obj0 = 0 ;
9827 char *kwnames[] = {
9828 (char *) "self", NULL
9829 };
9830
9831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9833 if (SWIG_arg_fail(1)) SWIG_fail;
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (int)((wxFont const *)arg1)->GetWeight();
9837
9838 wxPyEndAllowThreads(__tstate);
9839 if (PyErr_Occurred()) SWIG_fail;
9840 }
9841 {
9842 resultobj = SWIG_From_int((int)(result));
9843 }
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj;
9852 wxFont *arg1 = (wxFont *) 0 ;
9853 bool result;
9854 PyObject * obj0 = 0 ;
9855 char *kwnames[] = {
9856 (char *) "self", NULL
9857 };
9858
9859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9861 if (SWIG_arg_fail(1)) SWIG_fail;
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9865
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 {
9870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9871 }
9872 return resultobj;
9873 fail:
9874 return NULL;
9875 }
9876
9877
9878 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9879 PyObject *resultobj;
9880 wxFont *arg1 = (wxFont *) 0 ;
9881 wxString result;
9882 PyObject * obj0 = 0 ;
9883 char *kwnames[] = {
9884 (char *) "self", NULL
9885 };
9886
9887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9889 if (SWIG_arg_fail(1)) SWIG_fail;
9890 {
9891 PyThreadState* __tstate = wxPyBeginAllowThreads();
9892 result = ((wxFont const *)arg1)->GetFaceName();
9893
9894 wxPyEndAllowThreads(__tstate);
9895 if (PyErr_Occurred()) SWIG_fail;
9896 }
9897 {
9898 #if wxUSE_UNICODE
9899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9900 #else
9901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9902 #endif
9903 }
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj;
9912 wxFont *arg1 = (wxFont *) 0 ;
9913 wxFontEncoding result;
9914 PyObject * obj0 = 0 ;
9915 char *kwnames[] = {
9916 (char *) "self", NULL
9917 };
9918
9919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9921 if (SWIG_arg_fail(1)) SWIG_fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_From_int((result));
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj;
9938 wxFont *arg1 = (wxFont *) 0 ;
9939 wxNativeFontInfo *result;
9940 PyObject * obj0 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "self", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9947 if (SWIG_arg_fail(1)) SWIG_fail;
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9951
9952 wxPyEndAllowThreads(__tstate);
9953 if (PyErr_Occurred()) SWIG_fail;
9954 }
9955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9956 return resultobj;
9957 fail:
9958 return NULL;
9959 }
9960
9961
9962 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj;
9964 wxFont *arg1 = (wxFont *) 0 ;
9965 bool result;
9966 PyObject * obj0 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "self", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9973 if (SWIG_arg_fail(1)) SWIG_fail;
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9977
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 {
9982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9983 }
9984 return resultobj;
9985 fail:
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 wxFont *arg1 = (wxFont *) 0 ;
9993 wxString result;
9994 PyObject * obj0 = 0 ;
9995 char *kwnames[] = {
9996 (char *) "self", NULL
9997 };
9998
9999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10001 if (SWIG_arg_fail(1)) SWIG_fail;
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10005
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 {
10010 #if wxUSE_UNICODE
10011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10012 #else
10013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10014 #endif
10015 }
10016 return resultobj;
10017 fail:
10018 return NULL;
10019 }
10020
10021
10022 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10023 PyObject *resultobj;
10024 wxFont *arg1 = (wxFont *) 0 ;
10025 wxString result;
10026 PyObject * obj0 = 0 ;
10027 char *kwnames[] = {
10028 (char *) "self", NULL
10029 };
10030
10031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10033 if (SWIG_arg_fail(1)) SWIG_fail;
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10037
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 {
10042 #if wxUSE_UNICODE
10043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10044 #else
10045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10046 #endif
10047 }
10048 return resultobj;
10049 fail:
10050 return NULL;
10051 }
10052
10053
10054 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10055 PyObject *resultobj;
10056 wxFont *arg1 = (wxFont *) 0 ;
10057 int arg2 ;
10058 PyObject * obj0 = 0 ;
10059 PyObject * obj1 = 0 ;
10060 char *kwnames[] = {
10061 (char *) "self",(char *) "pointSize", NULL
10062 };
10063
10064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10066 if (SWIG_arg_fail(1)) SWIG_fail;
10067 {
10068 arg2 = (int)(SWIG_As_int(obj1));
10069 if (SWIG_arg_fail(2)) SWIG_fail;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 (arg1)->SetPointSize(arg2);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 Py_INCREF(Py_None); resultobj = Py_None;
10079 return resultobj;
10080 fail:
10081 return NULL;
10082 }
10083
10084
10085 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj;
10087 wxFont *arg1 = (wxFont *) 0 ;
10088 wxSize *arg2 = 0 ;
10089 wxSize temp2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "pixelSize", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = &temp2;
10101 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetPixelSize((wxSize const &)*arg2);
10106
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 Py_INCREF(Py_None); resultobj = Py_None;
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxFont *arg1 = (wxFont *) 0 ;
10120 int arg2 ;
10121 PyObject * obj0 = 0 ;
10122 PyObject * obj1 = 0 ;
10123 char *kwnames[] = {
10124 (char *) "self",(char *) "family", NULL
10125 };
10126
10127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10129 if (SWIG_arg_fail(1)) SWIG_fail;
10130 {
10131 arg2 = (int)(SWIG_As_int(obj1));
10132 if (SWIG_arg_fail(2)) SWIG_fail;
10133 }
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 (arg1)->SetFamily(arg2);
10137
10138 wxPyEndAllowThreads(__tstate);
10139 if (PyErr_Occurred()) SWIG_fail;
10140 }
10141 Py_INCREF(Py_None); resultobj = Py_None;
10142 return resultobj;
10143 fail:
10144 return NULL;
10145 }
10146
10147
10148 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10149 PyObject *resultobj;
10150 wxFont *arg1 = (wxFont *) 0 ;
10151 int arg2 ;
10152 PyObject * obj0 = 0 ;
10153 PyObject * obj1 = 0 ;
10154 char *kwnames[] = {
10155 (char *) "self",(char *) "style", NULL
10156 };
10157
10158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10160 if (SWIG_arg_fail(1)) SWIG_fail;
10161 {
10162 arg2 = (int)(SWIG_As_int(obj1));
10163 if (SWIG_arg_fail(2)) SWIG_fail;
10164 }
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 (arg1)->SetStyle(arg2);
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 Py_INCREF(Py_None); resultobj = Py_None;
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 wxFont *arg1 = (wxFont *) 0 ;
10182 int arg2 ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "self",(char *) "weight", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 {
10193 arg2 = (int)(SWIG_As_int(obj1));
10194 if (SWIG_arg_fail(2)) SWIG_fail;
10195 }
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 (arg1)->SetWeight(arg2);
10199
10200 wxPyEndAllowThreads(__tstate);
10201 if (PyErr_Occurred()) SWIG_fail;
10202 }
10203 Py_INCREF(Py_None); resultobj = Py_None;
10204 return resultobj;
10205 fail:
10206 return NULL;
10207 }
10208
10209
10210 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj;
10212 wxFont *arg1 = (wxFont *) 0 ;
10213 wxString *arg2 = 0 ;
10214 bool temp2 = false ;
10215 PyObject * obj0 = 0 ;
10216 PyObject * obj1 = 0 ;
10217 char *kwnames[] = {
10218 (char *) "self",(char *) "faceName", NULL
10219 };
10220
10221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10223 if (SWIG_arg_fail(1)) SWIG_fail;
10224 {
10225 arg2 = wxString_in_helper(obj1);
10226 if (arg2 == NULL) SWIG_fail;
10227 temp2 = true;
10228 }
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 (arg1)->SetFaceName((wxString const &)*arg2);
10232
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 Py_INCREF(Py_None); resultobj = Py_None;
10237 {
10238 if (temp2)
10239 delete arg2;
10240 }
10241 return resultobj;
10242 fail:
10243 {
10244 if (temp2)
10245 delete arg2;
10246 }
10247 return NULL;
10248 }
10249
10250
10251 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10252 PyObject *resultobj;
10253 wxFont *arg1 = (wxFont *) 0 ;
10254 bool arg2 ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "self",(char *) "underlined", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10263 if (SWIG_arg_fail(1)) SWIG_fail;
10264 {
10265 arg2 = (bool)(SWIG_As_bool(obj1));
10266 if (SWIG_arg_fail(2)) SWIG_fail;
10267 }
10268 {
10269 PyThreadState* __tstate = wxPyBeginAllowThreads();
10270 (arg1)->SetUnderlined(arg2);
10271
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 Py_INCREF(Py_None); resultobj = Py_None;
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxFont *arg1 = (wxFont *) 0 ;
10285 wxFontEncoding arg2 ;
10286 PyObject * obj0 = 0 ;
10287 PyObject * obj1 = 0 ;
10288 char *kwnames[] = {
10289 (char *) "self",(char *) "encoding", NULL
10290 };
10291
10292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10294 if (SWIG_arg_fail(1)) SWIG_fail;
10295 {
10296 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10297 if (SWIG_arg_fail(2)) SWIG_fail;
10298 }
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 (arg1)->SetEncoding((wxFontEncoding )arg2);
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 Py_INCREF(Py_None); resultobj = Py_None;
10307 return resultobj;
10308 fail:
10309 return NULL;
10310 }
10311
10312
10313 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj;
10315 wxFont *arg1 = (wxFont *) 0 ;
10316 wxNativeFontInfo *arg2 = 0 ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 char *kwnames[] = {
10320 (char *) "self",(char *) "info", NULL
10321 };
10322
10323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10325 if (SWIG_arg_fail(1)) SWIG_fail;
10326 {
10327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10328 if (SWIG_arg_fail(2)) SWIG_fail;
10329 if (arg2 == NULL) {
10330 SWIG_null_ref("wxNativeFontInfo");
10331 }
10332 if (SWIG_arg_fail(2)) SWIG_fail;
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 Py_INCREF(Py_None); resultobj = Py_None;
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj;
10350 wxFont *arg1 = (wxFont *) 0 ;
10351 wxString *arg2 = 0 ;
10352 bool temp2 = false ;
10353 PyObject * obj0 = 0 ;
10354 PyObject * obj1 = 0 ;
10355 char *kwnames[] = {
10356 (char *) "self",(char *) "info", NULL
10357 };
10358
10359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 {
10363 arg2 = wxString_in_helper(obj1);
10364 if (arg2 == NULL) SWIG_fail;
10365 temp2 = true;
10366 }
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10370
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 Py_INCREF(Py_None); resultobj = Py_None;
10375 {
10376 if (temp2)
10377 delete arg2;
10378 }
10379 return resultobj;
10380 fail:
10381 {
10382 if (temp2)
10383 delete arg2;
10384 }
10385 return NULL;
10386 }
10387
10388
10389 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj;
10391 wxFont *arg1 = (wxFont *) 0 ;
10392 wxString *arg2 = 0 ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396 char *kwnames[] = {
10397 (char *) "self",(char *) "info", NULL
10398 };
10399
10400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10402 if (SWIG_arg_fail(1)) SWIG_fail;
10403 {
10404 arg2 = wxString_in_helper(obj1);
10405 if (arg2 == NULL) SWIG_fail;
10406 temp2 = true;
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 Py_INCREF(Py_None); resultobj = Py_None;
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return resultobj;
10421 fail:
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxFont *arg1 = (wxFont *) 0 ;
10433 wxString result;
10434 PyObject * obj0 = 0 ;
10435 char *kwnames[] = {
10436 (char *) "self", NULL
10437 };
10438
10439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10441 if (SWIG_arg_fail(1)) SWIG_fail;
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 result = ((wxFont const *)arg1)->GetFamilyString();
10445
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 {
10450 #if wxUSE_UNICODE
10451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10452 #else
10453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10454 #endif
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj;
10464 wxFont *arg1 = (wxFont *) 0 ;
10465 wxString result;
10466 PyObject * obj0 = 0 ;
10467 char *kwnames[] = {
10468 (char *) "self", NULL
10469 };
10470
10471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10473 if (SWIG_arg_fail(1)) SWIG_fail;
10474 {
10475 PyThreadState* __tstate = wxPyBeginAllowThreads();
10476 result = ((wxFont const *)arg1)->GetStyleString();
10477
10478 wxPyEndAllowThreads(__tstate);
10479 if (PyErr_Occurred()) SWIG_fail;
10480 }
10481 {
10482 #if wxUSE_UNICODE
10483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10484 #else
10485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10486 #endif
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj;
10496 wxFont *arg1 = (wxFont *) 0 ;
10497 wxString result;
10498 PyObject * obj0 = 0 ;
10499 char *kwnames[] = {
10500 (char *) "self", NULL
10501 };
10502
10503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10505 if (SWIG_arg_fail(1)) SWIG_fail;
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = ((wxFont const *)arg1)->GetWeightString();
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 {
10514 #if wxUSE_UNICODE
10515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10516 #else
10517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10518 #endif
10519 }
10520 return resultobj;
10521 fail:
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxFont *arg1 = (wxFont *) 0 ;
10529 bool arg2 = (bool) true ;
10530 PyObject * obj0 = 0 ;
10531 PyObject * obj1 = 0 ;
10532 char *kwnames[] = {
10533 (char *) "self",(char *) "no", NULL
10534 };
10535
10536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10538 if (SWIG_arg_fail(1)) SWIG_fail;
10539 if (obj1) {
10540 {
10541 arg2 = (bool)(SWIG_As_bool(obj1));
10542 if (SWIG_arg_fail(2)) SWIG_fail;
10543 }
10544 }
10545 {
10546 PyThreadState* __tstate = wxPyBeginAllowThreads();
10547 (arg1)->SetNoAntiAliasing(arg2);
10548
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 Py_INCREF(Py_None); resultobj = Py_None;
10553 return resultobj;
10554 fail:
10555 return NULL;
10556 }
10557
10558
10559 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10560 PyObject *resultobj;
10561 wxFont *arg1 = (wxFont *) 0 ;
10562 bool result;
10563 PyObject * obj0 = 0 ;
10564 char *kwnames[] = {
10565 (char *) "self", NULL
10566 };
10567
10568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10570 if (SWIG_arg_fail(1)) SWIG_fail;
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10574
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 {
10579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10580 }
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj;
10589 wxFontEncoding result;
10590 char *kwnames[] = {
10591 NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10595 {
10596 if (!wxPyCheckForApp()) SWIG_fail;
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10599
10600 wxPyEndAllowThreads(__tstate);
10601 if (PyErr_Occurred()) SWIG_fail;
10602 }
10603 resultobj = SWIG_From_int((result));
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj;
10612 wxFontEncoding arg1 ;
10613 PyObject * obj0 = 0 ;
10614 char *kwnames[] = {
10615 (char *) "encoding", NULL
10616 };
10617
10618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10619 {
10620 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10621 if (SWIG_arg_fail(1)) SWIG_fail;
10622 }
10623 {
10624 if (!wxPyCheckForApp()) SWIG_fail;
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10627
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 Py_INCREF(Py_None); resultobj = Py_None;
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10639 PyObject *obj;
10640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10641 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10642 Py_INCREF(obj);
10643 return Py_BuildValue((char *)"");
10644 }
10645 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxPyFontEnumerator *result;
10648 char *kwnames[] = {
10649 NULL
10650 };
10651
10652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10653 {
10654 if (!wxPyCheckForApp()) SWIG_fail;
10655 PyThreadState* __tstate = wxPyBeginAllowThreads();
10656 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10657
10658 wxPyEndAllowThreads(__tstate);
10659 if (PyErr_Occurred()) SWIG_fail;
10660 }
10661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10662 return resultobj;
10663 fail:
10664 return NULL;
10665 }
10666
10667
10668 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10669 PyObject *resultobj;
10670 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10671 PyObject * obj0 = 0 ;
10672 char *kwnames[] = {
10673 (char *) "self", NULL
10674 };
10675
10676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10678 if (SWIG_arg_fail(1)) SWIG_fail;
10679 {
10680 PyThreadState* __tstate = wxPyBeginAllowThreads();
10681 delete arg1;
10682
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 Py_INCREF(Py_None); resultobj = Py_None;
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj;
10695 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10696 PyObject *arg2 = (PyObject *) 0 ;
10697 PyObject *arg3 = (PyObject *) 0 ;
10698 bool arg4 ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10703 char *kwnames[] = {
10704 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10705 };
10706
10707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10709 if (SWIG_arg_fail(1)) SWIG_fail;
10710 arg2 = obj1;
10711 arg3 = obj2;
10712 {
10713 arg4 = (bool)(SWIG_As_bool(obj3));
10714 if (SWIG_arg_fail(4)) SWIG_fail;
10715 }
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 Py_INCREF(Py_None); resultobj = Py_None;
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj;
10732 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10733 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10734 bool arg3 = (bool) false ;
10735 bool result;
10736 PyObject * obj0 = 0 ;
10737 PyObject * obj1 = 0 ;
10738 PyObject * obj2 = 0 ;
10739 char *kwnames[] = {
10740 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10741 };
10742
10743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10745 if (SWIG_arg_fail(1)) SWIG_fail;
10746 if (obj1) {
10747 {
10748 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10749 if (SWIG_arg_fail(2)) SWIG_fail;
10750 }
10751 }
10752 if (obj2) {
10753 {
10754 arg3 = (bool)(SWIG_As_bool(obj2));
10755 if (SWIG_arg_fail(3)) SWIG_fail;
10756 }
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10761
10762 wxPyEndAllowThreads(__tstate);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 {
10766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10767 }
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj;
10776 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10777 wxString const &arg2_defvalue = wxPyEmptyString ;
10778 wxString *arg2 = (wxString *) &arg2_defvalue ;
10779 bool result;
10780 bool temp2 = false ;
10781 PyObject * obj0 = 0 ;
10782 PyObject * obj1 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self",(char *) "facename", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 if (obj1) {
10791 {
10792 arg2 = wxString_in_helper(obj1);
10793 if (arg2 == NULL) SWIG_fail;
10794 temp2 = true;
10795 }
10796 }
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10800
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 {
10805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10806 }
10807 {
10808 if (temp2)
10809 delete arg2;
10810 }
10811 return resultobj;
10812 fail:
10813 {
10814 if (temp2)
10815 delete arg2;
10816 }
10817 return NULL;
10818 }
10819
10820
10821 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10824 PyObject *result;
10825 PyObject * obj0 = 0 ;
10826 char *kwnames[] = {
10827 (char *) "self", NULL
10828 };
10829
10830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10832 if (SWIG_arg_fail(1)) SWIG_fail;
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10836
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = result;
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10850 PyObject *result;
10851 PyObject * obj0 = 0 ;
10852 char *kwnames[] = {
10853 (char *) "self", NULL
10854 };
10855
10856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10858 if (SWIG_arg_fail(1)) SWIG_fail;
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10862
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = result;
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10874 PyObject *obj;
10875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10876 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10877 Py_INCREF(obj);
10878 return Py_BuildValue((char *)"");
10879 }
10880 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10883 int arg2 ;
10884 PyObject * obj0 = 0 ;
10885 PyObject * obj1 = 0 ;
10886 char *kwnames[] = {
10887 (char *) "self",(char *) "Language", NULL
10888 };
10889
10890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10892 if (SWIG_arg_fail(1)) SWIG_fail;
10893 {
10894 arg2 = (int)(SWIG_As_int(obj1));
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 if (arg1) (arg1)->Language = arg2;
10898
10899 Py_INCREF(Py_None); resultobj = Py_None;
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj;
10908 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10909 int result;
10910 PyObject * obj0 = 0 ;
10911 char *kwnames[] = {
10912 (char *) "self", NULL
10913 };
10914
10915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10917 if (SWIG_arg_fail(1)) SWIG_fail;
10918 result = (int) ((arg1)->Language);
10919
10920 {
10921 resultobj = SWIG_From_int((int)(result));
10922 }
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10932 wxString *arg2 = (wxString *) 0 ;
10933 bool temp2 = false ;
10934 PyObject * obj0 = 0 ;
10935 PyObject * obj1 = 0 ;
10936 char *kwnames[] = {
10937 (char *) "self",(char *) "CanonicalName", NULL
10938 };
10939
10940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10942 if (SWIG_arg_fail(1)) SWIG_fail;
10943 {
10944 arg2 = wxString_in_helper(obj1);
10945 if (arg2 == NULL) SWIG_fail;
10946 temp2 = true;
10947 }
10948 if (arg1) (arg1)->CanonicalName = *arg2;
10949
10950 Py_INCREF(Py_None); resultobj = Py_None;
10951 {
10952 if (temp2)
10953 delete arg2;
10954 }
10955 return resultobj;
10956 fail:
10957 {
10958 if (temp2)
10959 delete arg2;
10960 }
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10968 wxString *result;
10969 PyObject * obj0 = 0 ;
10970 char *kwnames[] = {
10971 (char *) "self", NULL
10972 };
10973
10974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10976 if (SWIG_arg_fail(1)) SWIG_fail;
10977 result = (wxString *)& ((arg1)->CanonicalName);
10978
10979 {
10980 #if wxUSE_UNICODE
10981 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10982 #else
10983 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10984 #endif
10985 }
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10995 wxString *arg2 = (wxString *) 0 ;
10996 bool temp2 = false ;
10997 PyObject * obj0 = 0 ;
10998 PyObject * obj1 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self",(char *) "Description", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 {
11007 arg2 = wxString_in_helper(obj1);
11008 if (arg2 == NULL) SWIG_fail;
11009 temp2 = true;
11010 }
11011 if (arg1) (arg1)->Description = *arg2;
11012
11013 Py_INCREF(Py_None); resultobj = Py_None;
11014 {
11015 if (temp2)
11016 delete arg2;
11017 }
11018 return resultobj;
11019 fail:
11020 {
11021 if (temp2)
11022 delete arg2;
11023 }
11024 return NULL;
11025 }
11026
11027
11028 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj;
11030 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11031 wxString *result;
11032 PyObject * obj0 = 0 ;
11033 char *kwnames[] = {
11034 (char *) "self", NULL
11035 };
11036
11037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11039 if (SWIG_arg_fail(1)) SWIG_fail;
11040 result = (wxString *)& ((arg1)->Description);
11041
11042 {
11043 #if wxUSE_UNICODE
11044 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11045 #else
11046 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11047 #endif
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11056 PyObject *obj;
11057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11058 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11059 Py_INCREF(obj);
11060 return Py_BuildValue((char *)"");
11061 }
11062 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj;
11064 int arg1 = (int) -1 ;
11065 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11066 wxLocale *result;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 char *kwnames[] = {
11070 (char *) "language",(char *) "flags", NULL
11071 };
11072
11073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11074 if (obj0) {
11075 {
11076 arg1 = (int)(SWIG_As_int(obj0));
11077 if (SWIG_arg_fail(1)) SWIG_fail;
11078 }
11079 }
11080 if (obj1) {
11081 {
11082 arg2 = (int)(SWIG_As_int(obj1));
11083 if (SWIG_arg_fail(2)) SWIG_fail;
11084 }
11085 }
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (wxLocale *)new_wxLocale(arg1,arg2);
11089
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11094 return resultobj;
11095 fail:
11096 return NULL;
11097 }
11098
11099
11100 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj;
11102 wxLocale *arg1 = (wxLocale *) 0 ;
11103 PyObject * obj0 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 delete arg1;
11114
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 Py_INCREF(Py_None); resultobj = Py_None;
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj;
11127 wxLocale *arg1 = (wxLocale *) 0 ;
11128 wxString *arg2 = 0 ;
11129 wxString const &arg3_defvalue = wxPyEmptyString ;
11130 wxString *arg3 = (wxString *) &arg3_defvalue ;
11131 wxString const &arg4_defvalue = wxPyEmptyString ;
11132 wxString *arg4 = (wxString *) &arg4_defvalue ;
11133 bool arg5 = (bool) true ;
11134 bool arg6 = (bool) false ;
11135 bool result;
11136 bool temp2 = false ;
11137 bool temp3 = false ;
11138 bool temp4 = false ;
11139 PyObject * obj0 = 0 ;
11140 PyObject * obj1 = 0 ;
11141 PyObject * obj2 = 0 ;
11142 PyObject * obj3 = 0 ;
11143 PyObject * obj4 = 0 ;
11144 PyObject * obj5 = 0 ;
11145 char *kwnames[] = {
11146 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11147 };
11148
11149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11151 if (SWIG_arg_fail(1)) SWIG_fail;
11152 {
11153 arg2 = wxString_in_helper(obj1);
11154 if (arg2 == NULL) SWIG_fail;
11155 temp2 = true;
11156 }
11157 if (obj2) {
11158 {
11159 arg3 = wxString_in_helper(obj2);
11160 if (arg3 == NULL) SWIG_fail;
11161 temp3 = true;
11162 }
11163 }
11164 if (obj3) {
11165 {
11166 arg4 = wxString_in_helper(obj3);
11167 if (arg4 == NULL) SWIG_fail;
11168 temp4 = true;
11169 }
11170 }
11171 if (obj4) {
11172 {
11173 arg5 = (bool)(SWIG_As_bool(obj4));
11174 if (SWIG_arg_fail(5)) SWIG_fail;
11175 }
11176 }
11177 if (obj5) {
11178 {
11179 arg6 = (bool)(SWIG_As_bool(obj5));
11180 if (SWIG_arg_fail(6)) SWIG_fail;
11181 }
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11192 }
11193 {
11194 if (temp2)
11195 delete arg2;
11196 }
11197 {
11198 if (temp3)
11199 delete arg3;
11200 }
11201 {
11202 if (temp4)
11203 delete arg4;
11204 }
11205 return resultobj;
11206 fail:
11207 {
11208 if (temp2)
11209 delete arg2;
11210 }
11211 {
11212 if (temp3)
11213 delete arg3;
11214 }
11215 {
11216 if (temp4)
11217 delete arg4;
11218 }
11219 return NULL;
11220 }
11221
11222
11223 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj;
11225 wxLocale *arg1 = (wxLocale *) 0 ;
11226 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11227 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11228 bool result;
11229 PyObject * obj0 = 0 ;
11230 PyObject * obj1 = 0 ;
11231 PyObject * obj2 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self",(char *) "language",(char *) "flags", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 if (obj1) {
11240 {
11241 arg2 = (int)(SWIG_As_int(obj1));
11242 if (SWIG_arg_fail(2)) SWIG_fail;
11243 }
11244 }
11245 if (obj2) {
11246 {
11247 arg3 = (int)(SWIG_As_int(obj2));
11248 if (SWIG_arg_fail(3)) SWIG_fail;
11249 }
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11260 }
11261 return resultobj;
11262 fail:
11263 return NULL;
11264 }
11265
11266
11267 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11268 PyObject *resultobj;
11269 int result;
11270 char *kwnames[] = {
11271 NULL
11272 };
11273
11274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (int)wxLocale::GetSystemLanguage();
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 {
11283 resultobj = SWIG_From_int((int)(result));
11284 }
11285 return resultobj;
11286 fail:
11287 return NULL;
11288 }
11289
11290
11291 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11292 PyObject *resultobj;
11293 wxFontEncoding result;
11294 char *kwnames[] = {
11295 NULL
11296 };
11297
11298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11302
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 resultobj = SWIG_From_int((result));
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj;
11315 wxString result;
11316 char *kwnames[] = {
11317 NULL
11318 };
11319
11320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11321 {
11322 PyThreadState* __tstate = wxPyBeginAllowThreads();
11323 result = wxLocale::GetSystemEncodingName();
11324
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 {
11329 #if wxUSE_UNICODE
11330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11331 #else
11332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11333 #endif
11334 }
11335 return resultobj;
11336 fail:
11337 return NULL;
11338 }
11339
11340
11341 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj;
11343 wxLocale *arg1 = (wxLocale *) 0 ;
11344 bool result;
11345 PyObject * obj0 = 0 ;
11346 char *kwnames[] = {
11347 (char *) "self", NULL
11348 };
11349
11350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11352 if (SWIG_arg_fail(1)) SWIG_fail;
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 result = (bool)((wxLocale const *)arg1)->IsOk();
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 {
11361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11362 }
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj;
11371 wxLocale *arg1 = (wxLocale *) 0 ;
11372 wxString result;
11373 PyObject * obj0 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 PyThreadState* __tstate = wxPyBeginAllowThreads();
11383 result = ((wxLocale const *)arg1)->GetLocale();
11384
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 {
11389 #if wxUSE_UNICODE
11390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11391 #else
11392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11393 #endif
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11402 PyObject *resultobj;
11403 wxLocale *arg1 = (wxLocale *) 0 ;
11404 int result;
11405 PyObject * obj0 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "self", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11412 if (SWIG_arg_fail(1)) SWIG_fail;
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 result = (int)((wxLocale const *)arg1)->GetLanguage();
11416
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 {
11421 resultobj = SWIG_From_int((int)(result));
11422 }
11423 return resultobj;
11424 fail:
11425 return NULL;
11426 }
11427
11428
11429 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj;
11431 wxLocale *arg1 = (wxLocale *) 0 ;
11432 wxString result;
11433 PyObject * obj0 = 0 ;
11434 char *kwnames[] = {
11435 (char *) "self", NULL
11436 };
11437
11438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11440 if (SWIG_arg_fail(1)) SWIG_fail;
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = ((wxLocale const *)arg1)->GetSysName();
11444
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 {
11449 #if wxUSE_UNICODE
11450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11451 #else
11452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11453 #endif
11454 }
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11462 PyObject *resultobj;
11463 wxLocale *arg1 = (wxLocale *) 0 ;
11464 wxString result;
11465 PyObject * obj0 = 0 ;
11466 char *kwnames[] = {
11467 (char *) "self", NULL
11468 };
11469
11470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11472 if (SWIG_arg_fail(1)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = ((wxLocale const *)arg1)->GetCanonicalName();
11476
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 #if wxUSE_UNICODE
11482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11483 #else
11484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11485 #endif
11486 }
11487 return resultobj;
11488 fail:
11489 return NULL;
11490 }
11491
11492
11493 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11494 PyObject *resultobj;
11495 wxString *arg1 = 0 ;
11496 bool temp1 = false ;
11497 PyObject * obj0 = 0 ;
11498 char *kwnames[] = {
11499 (char *) "prefix", NULL
11500 };
11501
11502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11503 {
11504 arg1 = wxString_in_helper(obj0);
11505 if (arg1 == NULL) SWIG_fail;
11506 temp1 = true;
11507 }
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11511
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 Py_INCREF(Py_None); resultobj = Py_None;
11516 {
11517 if (temp1)
11518 delete arg1;
11519 }
11520 return resultobj;
11521 fail:
11522 {
11523 if (temp1)
11524 delete arg1;
11525 }
11526 return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj;
11532 wxLocale *arg1 = (wxLocale *) 0 ;
11533 wxString *arg2 = 0 ;
11534 bool result;
11535 bool temp2 = false ;
11536 PyObject * obj0 = 0 ;
11537 PyObject * obj1 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "self",(char *) "szDomain", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11544 if (SWIG_arg_fail(1)) SWIG_fail;
11545 {
11546 arg2 = wxString_in_helper(obj1);
11547 if (arg2 == NULL) SWIG_fail;
11548 temp2 = true;
11549 }
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11553
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11559 }
11560 {
11561 if (temp2)
11562 delete arg2;
11563 }
11564 return resultobj;
11565 fail:
11566 {
11567 if (temp2)
11568 delete arg2;
11569 }
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxLocale *arg1 = (wxLocale *) 0 ;
11577 wxString *arg2 = 0 ;
11578 bool result;
11579 bool temp2 = false ;
11580 PyObject * obj0 = 0 ;
11581 PyObject * obj1 = 0 ;
11582 char *kwnames[] = {
11583 (char *) "self",(char *) "szDomain", NULL
11584 };
11585
11586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11588 if (SWIG_arg_fail(1)) SWIG_fail;
11589 {
11590 arg2 = wxString_in_helper(obj1);
11591 if (arg2 == NULL) SWIG_fail;
11592 temp2 = true;
11593 }
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11597
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 {
11602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11603 }
11604 {
11605 if (temp2)
11606 delete arg2;
11607 }
11608 return resultobj;
11609 fail:
11610 {
11611 if (temp2)
11612 delete arg2;
11613 }
11614 return NULL;
11615 }
11616
11617
11618 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11619 PyObject *resultobj;
11620 int arg1 ;
11621 wxLanguageInfo *result;
11622 PyObject * obj0 = 0 ;
11623 char *kwnames[] = {
11624 (char *) "lang", NULL
11625 };
11626
11627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11628 {
11629 arg1 = (int)(SWIG_As_int(obj0));
11630 if (SWIG_arg_fail(1)) SWIG_fail;
11631 }
11632 {
11633 PyThreadState* __tstate = wxPyBeginAllowThreads();
11634 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11635
11636 wxPyEndAllowThreads(__tstate);
11637 if (PyErr_Occurred()) SWIG_fail;
11638 }
11639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11640 return resultobj;
11641 fail:
11642 return NULL;
11643 }
11644
11645
11646 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11647 PyObject *resultobj;
11648 int arg1 ;
11649 wxString result;
11650 PyObject * obj0 = 0 ;
11651 char *kwnames[] = {
11652 (char *) "lang", NULL
11653 };
11654
11655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11656 {
11657 arg1 = (int)(SWIG_As_int(obj0));
11658 if (SWIG_arg_fail(1)) SWIG_fail;
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = wxLocale::GetLanguageName(arg1);
11663
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 {
11668 #if wxUSE_UNICODE
11669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11670 #else
11671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11672 #endif
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj;
11682 wxString *arg1 = 0 ;
11683 wxLanguageInfo *result;
11684 bool temp1 = false ;
11685 PyObject * obj0 = 0 ;
11686 char *kwnames[] = {
11687 (char *) "locale", NULL
11688 };
11689
11690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11691 {
11692 arg1 = wxString_in_helper(obj0);
11693 if (arg1 == NULL) SWIG_fail;
11694 temp1 = true;
11695 }
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11699
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11704 {
11705 if (temp1)
11706 delete arg1;
11707 }
11708 return resultobj;
11709 fail:
11710 {
11711 if (temp1)
11712 delete arg1;
11713 }
11714 return NULL;
11715 }
11716
11717
11718 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11719 PyObject *resultobj;
11720 wxLanguageInfo *arg1 = 0 ;
11721 PyObject * obj0 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "info", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11727 {
11728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11729 if (SWIG_arg_fail(1)) SWIG_fail;
11730 if (arg1 == NULL) {
11731 SWIG_null_ref("wxLanguageInfo");
11732 }
11733 if (SWIG_arg_fail(1)) SWIG_fail;
11734 }
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11738
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 Py_INCREF(Py_None); resultobj = Py_None;
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj;
11751 wxLocale *arg1 = (wxLocale *) 0 ;
11752 wxString *arg2 = 0 ;
11753 wxString const &arg3_defvalue = wxPyEmptyString ;
11754 wxString *arg3 = (wxString *) &arg3_defvalue ;
11755 wxString result;
11756 bool temp2 = false ;
11757 bool temp3 = false ;
11758 PyObject * obj0 = 0 ;
11759 PyObject * obj1 = 0 ;
11760 PyObject * obj2 = 0 ;
11761 char *kwnames[] = {
11762 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11763 };
11764
11765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11767 if (SWIG_arg_fail(1)) SWIG_fail;
11768 {
11769 arg2 = wxString_in_helper(obj1);
11770 if (arg2 == NULL) SWIG_fail;
11771 temp2 = true;
11772 }
11773 if (obj2) {
11774 {
11775 arg3 = wxString_in_helper(obj2);
11776 if (arg3 == NULL) SWIG_fail;
11777 temp3 = true;
11778 }
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11783
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 #if wxUSE_UNICODE
11789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11790 #else
11791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11792 #endif
11793 }
11794 {
11795 if (temp2)
11796 delete arg2;
11797 }
11798 {
11799 if (temp3)
11800 delete arg3;
11801 }
11802 return resultobj;
11803 fail:
11804 {
11805 if (temp2)
11806 delete arg2;
11807 }
11808 {
11809 if (temp3)
11810 delete arg3;
11811 }
11812 return NULL;
11813 }
11814
11815
11816 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj;
11818 wxLocale *arg1 = (wxLocale *) 0 ;
11819 wxString *result;
11820 PyObject * obj0 = 0 ;
11821 char *kwnames[] = {
11822 (char *) "self", NULL
11823 };
11824
11825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11827 if (SWIG_arg_fail(1)) SWIG_fail;
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 {
11831 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11832 result = (wxString *) &_result_ref;
11833 }
11834
11835 wxPyEndAllowThreads(__tstate);
11836 if (PyErr_Occurred()) SWIG_fail;
11837 }
11838 {
11839 #if wxUSE_UNICODE
11840 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11841 #else
11842 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11843 #endif
11844 }
11845 return resultobj;
11846 fail:
11847 return NULL;
11848 }
11849
11850
11851 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11852 PyObject *obj;
11853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11854 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11855 Py_INCREF(obj);
11856 return Py_BuildValue((char *)"");
11857 }
11858 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11859 PyObject *resultobj;
11860 wxLocale *result;
11861 char *kwnames[] = {
11862 NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = (wxLocale *)wxGetLocale();
11869
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11881 PyObject *resultobj;
11882 wxString *arg1 = 0 ;
11883 wxString result;
11884 bool temp1 = false ;
11885 PyObject * obj0 = 0 ;
11886
11887 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11888 {
11889 arg1 = wxString_in_helper(obj0);
11890 if (arg1 == NULL) SWIG_fail;
11891 temp1 = true;
11892 }
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = wxGetTranslation((wxString const &)*arg1);
11896
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 #if wxUSE_UNICODE
11902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11903 #else
11904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11905 #endif
11906 }
11907 {
11908 if (temp1)
11909 delete arg1;
11910 }
11911 return resultobj;
11912 fail:
11913 {
11914 if (temp1)
11915 delete arg1;
11916 }
11917 return NULL;
11918 }
11919
11920
11921 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11922 PyObject *resultobj;
11923 wxString *arg1 = 0 ;
11924 wxString *arg2 = 0 ;
11925 size_t arg3 ;
11926 wxString result;
11927 bool temp1 = false ;
11928 bool temp2 = false ;
11929 PyObject * obj0 = 0 ;
11930 PyObject * obj1 = 0 ;
11931 PyObject * obj2 = 0 ;
11932
11933 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11934 {
11935 arg1 = wxString_in_helper(obj0);
11936 if (arg1 == NULL) SWIG_fail;
11937 temp1 = true;
11938 }
11939 {
11940 arg2 = wxString_in_helper(obj1);
11941 if (arg2 == NULL) SWIG_fail;
11942 temp2 = true;
11943 }
11944 {
11945 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11946 if (SWIG_arg_fail(3)) SWIG_fail;
11947 }
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11951
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 {
11956 #if wxUSE_UNICODE
11957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11958 #else
11959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11960 #endif
11961 }
11962 {
11963 if (temp1)
11964 delete arg1;
11965 }
11966 {
11967 if (temp2)
11968 delete arg2;
11969 }
11970 return resultobj;
11971 fail:
11972 {
11973 if (temp1)
11974 delete arg1;
11975 }
11976 {
11977 if (temp2)
11978 delete arg2;
11979 }
11980 return NULL;
11981 }
11982
11983
11984 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11985 int argc;
11986 PyObject *argv[4];
11987 int ii;
11988
11989 argc = PyObject_Length(args);
11990 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11991 argv[ii] = PyTuple_GetItem(args,ii);
11992 }
11993 if (argc == 1) {
11994 int _v;
11995 {
11996 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11997 }
11998 if (_v) {
11999 return _wrap_GetTranslation__SWIG_0(self,args);
12000 }
12001 }
12002 if (argc == 3) {
12003 int _v;
12004 {
12005 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12006 }
12007 if (_v) {
12008 {
12009 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12010 }
12011 if (_v) {
12012 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12013 if (_v) {
12014 return _wrap_GetTranslation__SWIG_1(self,args);
12015 }
12016 }
12017 }
12018 }
12019
12020 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj;
12027 wxEncodingConverter *result;
12028 char *kwnames[] = {
12029 NULL
12030 };
12031
12032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (wxEncodingConverter *)new wxEncodingConverter();
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj;
12049 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12050 PyObject * obj0 = 0 ;
12051 char *kwnames[] = {
12052 (char *) "self", NULL
12053 };
12054
12055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12057 if (SWIG_arg_fail(1)) SWIG_fail;
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 delete arg1;
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 Py_INCREF(Py_None); resultobj = Py_None;
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj;
12074 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12075 wxFontEncoding arg2 ;
12076 wxFontEncoding arg3 ;
12077 int arg4 = (int) wxCONVERT_STRICT ;
12078 bool result;
12079 PyObject * obj0 = 0 ;
12080 PyObject * obj1 = 0 ;
12081 PyObject * obj2 = 0 ;
12082 PyObject * obj3 = 0 ;
12083 char *kwnames[] = {
12084 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12085 };
12086
12087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 {
12091 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12092 if (SWIG_arg_fail(2)) SWIG_fail;
12093 }
12094 {
12095 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12096 if (SWIG_arg_fail(3)) SWIG_fail;
12097 }
12098 if (obj3) {
12099 {
12100 arg4 = (int)(SWIG_As_int(obj3));
12101 if (SWIG_arg_fail(4)) SWIG_fail;
12102 }
12103 }
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 {
12112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12113 }
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj;
12122 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12123 wxString *arg2 = 0 ;
12124 wxString result;
12125 bool temp2 = false ;
12126 PyObject * obj0 = 0 ;
12127 PyObject * obj1 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "self",(char *) "input", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12134 if (SWIG_arg_fail(1)) SWIG_fail;
12135 {
12136 arg2 = wxString_in_helper(obj1);
12137 if (arg2 == NULL) SWIG_fail;
12138 temp2 = true;
12139 }
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = (arg1)->Convert((wxString const &)*arg2);
12143
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 {
12148 #if wxUSE_UNICODE
12149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12150 #else
12151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12152 #endif
12153 }
12154 {
12155 if (temp2)
12156 delete arg2;
12157 }
12158 return resultobj;
12159 fail:
12160 {
12161 if (temp2)
12162 delete arg2;
12163 }
12164 return NULL;
12165 }
12166
12167
12168 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj;
12170 wxFontEncoding arg1 ;
12171 int arg2 = (int) wxPLATFORM_CURRENT ;
12172 wxFontEncodingArray result;
12173 PyObject * obj0 = 0 ;
12174 PyObject * obj1 = 0 ;
12175 char *kwnames[] = {
12176 (char *) "enc",(char *) "platform", NULL
12177 };
12178
12179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12180 {
12181 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12182 if (SWIG_arg_fail(1)) SWIG_fail;
12183 }
12184 if (obj1) {
12185 {
12186 arg2 = (int)(SWIG_As_int(obj1));
12187 if (SWIG_arg_fail(2)) SWIG_fail;
12188 }
12189 }
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12193
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 {
12198 resultobj = PyList_New(0);
12199 for (size_t i=0; i < (&result)->GetCount(); i++) {
12200 PyObject* number = PyInt_FromLong((&result)->Item(i));
12201 PyList_Append(resultobj, number);
12202 Py_DECREF(number);
12203 }
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj;
12213 wxFontEncoding arg1 ;
12214 wxFontEncodingArray result;
12215 PyObject * obj0 = 0 ;
12216 char *kwnames[] = {
12217 (char *) "enc", NULL
12218 };
12219
12220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12221 {
12222 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12223 if (SWIG_arg_fail(1)) SWIG_fail;
12224 }
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12228
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 {
12233 resultobj = PyList_New(0);
12234 for (size_t i=0; i < (&result)->GetCount(); i++) {
12235 PyObject* number = PyInt_FromLong((&result)->Item(i));
12236 PyList_Append(resultobj, number);
12237 Py_DECREF(number);
12238 }
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxFontEncoding arg1 ;
12249 wxFontEncoding arg2 ;
12250 bool result;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "encIn",(char *) "encOut", NULL
12255 };
12256
12257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12258 {
12259 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12260 if (SWIG_arg_fail(1)) SWIG_fail;
12261 }
12262 {
12263 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12264 if (SWIG_arg_fail(2)) SWIG_fail;
12265 }
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12283 PyObject *obj;
12284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12285 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12286 Py_INCREF(obj);
12287 return Py_BuildValue((char *)"");
12288 }
12289 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj;
12291 wxDC *arg1 = (wxDC *) 0 ;
12292 PyObject * obj0 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "self", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12299 if (SWIG_arg_fail(1)) SWIG_fail;
12300 {
12301 PyThreadState* __tstate = wxPyBeginAllowThreads();
12302 delete arg1;
12303
12304 wxPyEndAllowThreads(__tstate);
12305 if (PyErr_Occurred()) SWIG_fail;
12306 }
12307 Py_INCREF(Py_None); resultobj = Py_None;
12308 return resultobj;
12309 fail:
12310 return NULL;
12311 }
12312
12313
12314 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj;
12316 wxDC *arg1 = (wxDC *) 0 ;
12317 PyObject * obj0 = 0 ;
12318 char *kwnames[] = {
12319 (char *) "self", NULL
12320 };
12321
12322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12324 if (SWIG_arg_fail(1)) SWIG_fail;
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 (arg1)->BeginDrawing();
12328
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 Py_INCREF(Py_None); resultobj = Py_None;
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxDC *arg1 = (wxDC *) 0 ;
12342 PyObject * obj0 = 0 ;
12343 char *kwnames[] = {
12344 (char *) "self", NULL
12345 };
12346
12347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12349 if (SWIG_arg_fail(1)) SWIG_fail;
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 (arg1)->EndDrawing();
12353
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 Py_INCREF(Py_None); resultobj = Py_None;
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12365 PyObject *resultobj;
12366 wxDC *arg1 = (wxDC *) 0 ;
12367 int arg2 ;
12368 int arg3 ;
12369 wxColour *arg4 = 0 ;
12370 int arg5 = (int) wxFLOOD_SURFACE ;
12371 bool result;
12372 wxColour temp4 ;
12373 PyObject * obj0 = 0 ;
12374 PyObject * obj1 = 0 ;
12375 PyObject * obj2 = 0 ;
12376 PyObject * obj3 = 0 ;
12377 PyObject * obj4 = 0 ;
12378 char *kwnames[] = {
12379 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12380 };
12381
12382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12384 if (SWIG_arg_fail(1)) SWIG_fail;
12385 {
12386 arg2 = (int)(SWIG_As_int(obj1));
12387 if (SWIG_arg_fail(2)) SWIG_fail;
12388 }
12389 {
12390 arg3 = (int)(SWIG_As_int(obj2));
12391 if (SWIG_arg_fail(3)) SWIG_fail;
12392 }
12393 {
12394 arg4 = &temp4;
12395 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12396 }
12397 if (obj4) {
12398 {
12399 arg5 = (int)(SWIG_As_int(obj4));
12400 if (SWIG_arg_fail(5)) SWIG_fail;
12401 }
12402 }
12403 {
12404 PyThreadState* __tstate = wxPyBeginAllowThreads();
12405 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12406
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 {
12411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12412 }
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj;
12421 wxDC *arg1 = (wxDC *) 0 ;
12422 wxPoint *arg2 = 0 ;
12423 wxColour *arg3 = 0 ;
12424 int arg4 = (int) wxFLOOD_SURFACE ;
12425 bool result;
12426 wxPoint temp2 ;
12427 wxColour temp3 ;
12428 PyObject * obj0 = 0 ;
12429 PyObject * obj1 = 0 ;
12430 PyObject * obj2 = 0 ;
12431 PyObject * obj3 = 0 ;
12432 char *kwnames[] = {
12433 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12434 };
12435
12436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12438 if (SWIG_arg_fail(1)) SWIG_fail;
12439 {
12440 arg2 = &temp2;
12441 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12442 }
12443 {
12444 arg3 = &temp3;
12445 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12446 }
12447 if (obj3) {
12448 {
12449 arg4 = (int)(SWIG_As_int(obj3));
12450 if (SWIG_arg_fail(4)) SWIG_fail;
12451 }
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12462 }
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj;
12471 wxDC *arg1 = (wxDC *) 0 ;
12472 int arg2 ;
12473 int arg3 ;
12474 wxColour result;
12475 PyObject * obj0 = 0 ;
12476 PyObject * obj1 = 0 ;
12477 PyObject * obj2 = 0 ;
12478 char *kwnames[] = {
12479 (char *) "self",(char *) "x",(char *) "y", NULL
12480 };
12481
12482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12484 if (SWIG_arg_fail(1)) SWIG_fail;
12485 {
12486 arg2 = (int)(SWIG_As_int(obj1));
12487 if (SWIG_arg_fail(2)) SWIG_fail;
12488 }
12489 {
12490 arg3 = (int)(SWIG_As_int(obj2));
12491 if (SWIG_arg_fail(3)) SWIG_fail;
12492 }
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 result = wxDC_GetPixel(arg1,arg2,arg3);
12496
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 {
12501 wxColour * resultptr;
12502 resultptr = new wxColour((wxColour &)(result));
12503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12504 }
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj;
12513 wxDC *arg1 = (wxDC *) 0 ;
12514 wxPoint *arg2 = 0 ;
12515 wxColour result;
12516 wxPoint temp2 ;
12517 PyObject * obj0 = 0 ;
12518 PyObject * obj1 = 0 ;
12519 char *kwnames[] = {
12520 (char *) "self",(char *) "pt", NULL
12521 };
12522
12523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12525 if (SWIG_arg_fail(1)) SWIG_fail;
12526 {
12527 arg2 = &temp2;
12528 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12529 }
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 {
12538 wxColour * resultptr;
12539 resultptr = new wxColour((wxColour &)(result));
12540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12541 }
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj;
12550 wxDC *arg1 = (wxDC *) 0 ;
12551 int arg2 ;
12552 int arg3 ;
12553 int arg4 ;
12554 int arg5 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 PyObject * obj3 = 0 ;
12559 PyObject * obj4 = 0 ;
12560 char *kwnames[] = {
12561 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12562 };
12563
12564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12566 if (SWIG_arg_fail(1)) SWIG_fail;
12567 {
12568 arg2 = (int)(SWIG_As_int(obj1));
12569 if (SWIG_arg_fail(2)) SWIG_fail;
12570 }
12571 {
12572 arg3 = (int)(SWIG_As_int(obj2));
12573 if (SWIG_arg_fail(3)) SWIG_fail;
12574 }
12575 {
12576 arg4 = (int)(SWIG_As_int(obj3));
12577 if (SWIG_arg_fail(4)) SWIG_fail;
12578 }
12579 {
12580 arg5 = (int)(SWIG_As_int(obj4));
12581 if (SWIG_arg_fail(5)) SWIG_fail;
12582 }
12583 {
12584 PyThreadState* __tstate = wxPyBeginAllowThreads();
12585 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12586
12587 wxPyEndAllowThreads(__tstate);
12588 if (PyErr_Occurred()) SWIG_fail;
12589 }
12590 Py_INCREF(Py_None); resultobj = Py_None;
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12598 PyObject *resultobj;
12599 wxDC *arg1 = (wxDC *) 0 ;
12600 wxPoint *arg2 = 0 ;
12601 wxPoint *arg3 = 0 ;
12602 wxPoint temp2 ;
12603 wxPoint temp3 ;
12604 PyObject * obj0 = 0 ;
12605 PyObject * obj1 = 0 ;
12606 PyObject * obj2 = 0 ;
12607 char *kwnames[] = {
12608 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12609 };
12610
12611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12613 if (SWIG_arg_fail(1)) SWIG_fail;
12614 {
12615 arg2 = &temp2;
12616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12617 }
12618 {
12619 arg3 = &temp3;
12620 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12621 }
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12625
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 Py_INCREF(Py_None); resultobj = Py_None;
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj;
12638 wxDC *arg1 = (wxDC *) 0 ;
12639 int arg2 ;
12640 int arg3 ;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 PyObject * obj2 = 0 ;
12644 char *kwnames[] = {
12645 (char *) "self",(char *) "x",(char *) "y", NULL
12646 };
12647
12648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12650 if (SWIG_arg_fail(1)) SWIG_fail;
12651 {
12652 arg2 = (int)(SWIG_As_int(obj1));
12653 if (SWIG_arg_fail(2)) SWIG_fail;
12654 }
12655 {
12656 arg3 = (int)(SWIG_As_int(obj2));
12657 if (SWIG_arg_fail(3)) SWIG_fail;
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 (arg1)->CrossHair(arg2,arg3);
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 Py_INCREF(Py_None); resultobj = Py_None;
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxDC *arg1 = (wxDC *) 0 ;
12676 wxPoint *arg2 = 0 ;
12677 wxPoint temp2 ;
12678 PyObject * obj0 = 0 ;
12679 PyObject * obj1 = 0 ;
12680 char *kwnames[] = {
12681 (char *) "self",(char *) "pt", NULL
12682 };
12683
12684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12686 if (SWIG_arg_fail(1)) SWIG_fail;
12687 {
12688 arg2 = &temp2;
12689 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12690 }
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 (arg1)->CrossHair((wxPoint const &)*arg2);
12694
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 Py_INCREF(Py_None); resultobj = Py_None;
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12706 PyObject *resultobj;
12707 wxDC *arg1 = (wxDC *) 0 ;
12708 int arg2 ;
12709 int arg3 ;
12710 int arg4 ;
12711 int arg5 ;
12712 int arg6 ;
12713 int arg7 ;
12714 PyObject * obj0 = 0 ;
12715 PyObject * obj1 = 0 ;
12716 PyObject * obj2 = 0 ;
12717 PyObject * obj3 = 0 ;
12718 PyObject * obj4 = 0 ;
12719 PyObject * obj5 = 0 ;
12720 PyObject * obj6 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 {
12729 arg2 = (int)(SWIG_As_int(obj1));
12730 if (SWIG_arg_fail(2)) SWIG_fail;
12731 }
12732 {
12733 arg3 = (int)(SWIG_As_int(obj2));
12734 if (SWIG_arg_fail(3)) SWIG_fail;
12735 }
12736 {
12737 arg4 = (int)(SWIG_As_int(obj3));
12738 if (SWIG_arg_fail(4)) SWIG_fail;
12739 }
12740 {
12741 arg5 = (int)(SWIG_As_int(obj4));
12742 if (SWIG_arg_fail(5)) SWIG_fail;
12743 }
12744 {
12745 arg6 = (int)(SWIG_As_int(obj5));
12746 if (SWIG_arg_fail(6)) SWIG_fail;
12747 }
12748 {
12749 arg7 = (int)(SWIG_As_int(obj6));
12750 if (SWIG_arg_fail(7)) SWIG_fail;
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 Py_INCREF(Py_None); resultobj = Py_None;
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12767 PyObject *resultobj;
12768 wxDC *arg1 = (wxDC *) 0 ;
12769 wxPoint *arg2 = 0 ;
12770 wxPoint *arg3 = 0 ;
12771 wxPoint *arg4 = 0 ;
12772 wxPoint temp2 ;
12773 wxPoint temp3 ;
12774 wxPoint temp4 ;
12775 PyObject * obj0 = 0 ;
12776 PyObject * obj1 = 0 ;
12777 PyObject * obj2 = 0 ;
12778 PyObject * obj3 = 0 ;
12779 char *kwnames[] = {
12780 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12781 };
12782
12783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12785 if (SWIG_arg_fail(1)) SWIG_fail;
12786 {
12787 arg2 = &temp2;
12788 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12789 }
12790 {
12791 arg3 = &temp3;
12792 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12793 }
12794 {
12795 arg4 = &temp4;
12796 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12797 }
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12801
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 Py_INCREF(Py_None); resultobj = Py_None;
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj;
12814 wxDC *arg1 = (wxDC *) 0 ;
12815 int arg2 ;
12816 int arg3 ;
12817 int arg4 ;
12818 int arg5 ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 PyObject * obj2 = 0 ;
12822 PyObject * obj3 = 0 ;
12823 PyObject * obj4 = 0 ;
12824 char *kwnames[] = {
12825 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12826 };
12827
12828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12830 if (SWIG_arg_fail(1)) SWIG_fail;
12831 {
12832 arg2 = (int)(SWIG_As_int(obj1));
12833 if (SWIG_arg_fail(2)) SWIG_fail;
12834 }
12835 {
12836 arg3 = (int)(SWIG_As_int(obj2));
12837 if (SWIG_arg_fail(3)) SWIG_fail;
12838 }
12839 {
12840 arg4 = (int)(SWIG_As_int(obj3));
12841 if (SWIG_arg_fail(4)) SWIG_fail;
12842 }
12843 {
12844 arg5 = (int)(SWIG_As_int(obj4));
12845 if (SWIG_arg_fail(5)) SWIG_fail;
12846 }
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12850
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 Py_INCREF(Py_None); resultobj = Py_None;
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxDC *arg1 = (wxDC *) 0 ;
12864 wxRect *arg2 = 0 ;
12865 wxRect temp2 ;
12866 PyObject * obj0 = 0 ;
12867 PyObject * obj1 = 0 ;
12868 char *kwnames[] = {
12869 (char *) "self",(char *) "rect", NULL
12870 };
12871
12872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12874 if (SWIG_arg_fail(1)) SWIG_fail;
12875 {
12876 arg2 = &temp2;
12877 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12878 }
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12882
12883 wxPyEndAllowThreads(__tstate);
12884 if (PyErr_Occurred()) SWIG_fail;
12885 }
12886 Py_INCREF(Py_None); resultobj = Py_None;
12887 return resultobj;
12888 fail:
12889 return NULL;
12890 }
12891
12892
12893 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12894 PyObject *resultobj;
12895 wxDC *arg1 = (wxDC *) 0 ;
12896 int arg2 ;
12897 int arg3 ;
12898 int arg4 ;
12899 int arg5 ;
12900 double arg6 ;
12901 double arg7 ;
12902 PyObject * obj0 = 0 ;
12903 PyObject * obj1 = 0 ;
12904 PyObject * obj2 = 0 ;
12905 PyObject * obj3 = 0 ;
12906 PyObject * obj4 = 0 ;
12907 PyObject * obj5 = 0 ;
12908 PyObject * obj6 = 0 ;
12909 char *kwnames[] = {
12910 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12911 };
12912
12913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12915 if (SWIG_arg_fail(1)) SWIG_fail;
12916 {
12917 arg2 = (int)(SWIG_As_int(obj1));
12918 if (SWIG_arg_fail(2)) SWIG_fail;
12919 }
12920 {
12921 arg3 = (int)(SWIG_As_int(obj2));
12922 if (SWIG_arg_fail(3)) SWIG_fail;
12923 }
12924 {
12925 arg4 = (int)(SWIG_As_int(obj3));
12926 if (SWIG_arg_fail(4)) SWIG_fail;
12927 }
12928 {
12929 arg5 = (int)(SWIG_As_int(obj4));
12930 if (SWIG_arg_fail(5)) SWIG_fail;
12931 }
12932 {
12933 arg6 = (double)(SWIG_As_double(obj5));
12934 if (SWIG_arg_fail(6)) SWIG_fail;
12935 }
12936 {
12937 arg7 = (double)(SWIG_As_double(obj6));
12938 if (SWIG_arg_fail(7)) SWIG_fail;
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 Py_INCREF(Py_None); resultobj = Py_None;
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12955 PyObject *resultobj;
12956 wxDC *arg1 = (wxDC *) 0 ;
12957 wxPoint *arg2 = 0 ;
12958 wxSize *arg3 = 0 ;
12959 double arg4 ;
12960 double arg5 ;
12961 wxPoint temp2 ;
12962 wxSize temp3 ;
12963 PyObject * obj0 = 0 ;
12964 PyObject * obj1 = 0 ;
12965 PyObject * obj2 = 0 ;
12966 PyObject * obj3 = 0 ;
12967 PyObject * obj4 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 arg2 = &temp2;
12977 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12978 }
12979 {
12980 arg3 = &temp3;
12981 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12982 }
12983 {
12984 arg4 = (double)(SWIG_As_double(obj3));
12985 if (SWIG_arg_fail(4)) SWIG_fail;
12986 }
12987 {
12988 arg5 = (double)(SWIG_As_double(obj4));
12989 if (SWIG_arg_fail(5)) SWIG_fail;
12990 }
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 Py_INCREF(Py_None); resultobj = Py_None;
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxDC *arg1 = (wxDC *) 0 ;
13008 int arg2 ;
13009 int arg3 ;
13010 PyObject * obj0 = 0 ;
13011 PyObject * obj1 = 0 ;
13012 PyObject * obj2 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self",(char *) "x",(char *) "y", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 {
13021 arg2 = (int)(SWIG_As_int(obj1));
13022 if (SWIG_arg_fail(2)) SWIG_fail;
13023 }
13024 {
13025 arg3 = (int)(SWIG_As_int(obj2));
13026 if (SWIG_arg_fail(3)) SWIG_fail;
13027 }
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 (arg1)->DrawPoint(arg2,arg3);
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 Py_INCREF(Py_None); resultobj = Py_None;
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj;
13044 wxDC *arg1 = (wxDC *) 0 ;
13045 wxPoint *arg2 = 0 ;
13046 wxPoint temp2 ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self",(char *) "pt", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 arg2 = &temp2;
13058 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13059 }
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 (arg1)->DrawPoint((wxPoint const &)*arg2);
13063
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 Py_INCREF(Py_None); resultobj = Py_None;
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj;
13076 wxDC *arg1 = (wxDC *) 0 ;
13077 int arg2 ;
13078 int arg3 ;
13079 int arg4 ;
13080 int arg5 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 PyObject * obj3 = 0 ;
13085 PyObject * obj4 = 0 ;
13086 char *kwnames[] = {
13087 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13088 };
13089
13090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(1)) SWIG_fail;
13093 {
13094 arg2 = (int)(SWIG_As_int(obj1));
13095 if (SWIG_arg_fail(2)) SWIG_fail;
13096 }
13097 {
13098 arg3 = (int)(SWIG_As_int(obj2));
13099 if (SWIG_arg_fail(3)) SWIG_fail;
13100 }
13101 {
13102 arg4 = (int)(SWIG_As_int(obj3));
13103 if (SWIG_arg_fail(4)) SWIG_fail;
13104 }
13105 {
13106 arg5 = (int)(SWIG_As_int(obj4));
13107 if (SWIG_arg_fail(5)) SWIG_fail;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13112
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 Py_INCREF(Py_None); resultobj = Py_None;
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxDC *arg1 = (wxDC *) 0 ;
13126 wxRect *arg2 = 0 ;
13127 wxRect temp2 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "rect", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 arg2 = &temp2;
13139 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 (arg1)->DrawRectangle((wxRect const &)*arg2);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 Py_INCREF(Py_None); resultobj = Py_None;
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxDC *arg1 = (wxDC *) 0 ;
13158 wxPoint *arg2 = 0 ;
13159 wxSize *arg3 = 0 ;
13160 wxPoint temp2 ;
13161 wxSize temp3 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "pt",(char *) "sz", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 arg2 = &temp2;
13174 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13175 }
13176 {
13177 arg3 = &temp3;
13178 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13179 }
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13183
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 Py_INCREF(Py_None); resultobj = Py_None;
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj;
13196 wxDC *arg1 = (wxDC *) 0 ;
13197 int arg2 ;
13198 int arg3 ;
13199 int arg4 ;
13200 int arg5 ;
13201 double arg6 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 PyObject * obj3 = 0 ;
13206 PyObject * obj4 = 0 ;
13207 PyObject * obj5 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 arg2 = (int)(SWIG_As_int(obj1));
13217 if (SWIG_arg_fail(2)) SWIG_fail;
13218 }
13219 {
13220 arg3 = (int)(SWIG_As_int(obj2));
13221 if (SWIG_arg_fail(3)) SWIG_fail;
13222 }
13223 {
13224 arg4 = (int)(SWIG_As_int(obj3));
13225 if (SWIG_arg_fail(4)) SWIG_fail;
13226 }
13227 {
13228 arg5 = (int)(SWIG_As_int(obj4));
13229 if (SWIG_arg_fail(5)) SWIG_fail;
13230 }
13231 {
13232 arg6 = (double)(SWIG_As_double(obj5));
13233 if (SWIG_arg_fail(6)) SWIG_fail;
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 Py_INCREF(Py_None); resultobj = Py_None;
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxDC *arg1 = (wxDC *) 0 ;
13252 wxRect *arg2 = 0 ;
13253 double arg3 ;
13254 wxRect temp2 ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "r",(char *) "radius", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 {
13266 arg2 = &temp2;
13267 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13268 }
13269 {
13270 arg3 = (double)(SWIG_As_double(obj2));
13271 if (SWIG_arg_fail(3)) SWIG_fail;
13272 }
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13276
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 Py_INCREF(Py_None); resultobj = Py_None;
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13288 PyObject *resultobj;
13289 wxDC *arg1 = (wxDC *) 0 ;
13290 wxPoint *arg2 = 0 ;
13291 wxSize *arg3 = 0 ;
13292 double arg4 ;
13293 wxPoint temp2 ;
13294 wxSize temp3 ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13298 PyObject * obj3 = 0 ;
13299 char *kwnames[] = {
13300 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13301 };
13302
13303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13305 if (SWIG_arg_fail(1)) SWIG_fail;
13306 {
13307 arg2 = &temp2;
13308 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13309 }
13310 {
13311 arg3 = &temp3;
13312 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13313 }
13314 {
13315 arg4 = (double)(SWIG_As_double(obj3));
13316 if (SWIG_arg_fail(4)) SWIG_fail;
13317 }
13318 {
13319 PyThreadState* __tstate = wxPyBeginAllowThreads();
13320 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13321
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 Py_INCREF(Py_None); resultobj = Py_None;
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj;
13334 wxDC *arg1 = (wxDC *) 0 ;
13335 int arg2 ;
13336 int arg3 ;
13337 int arg4 ;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 PyObject * obj2 = 0 ;
13341 PyObject * obj3 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 {
13350 arg2 = (int)(SWIG_As_int(obj1));
13351 if (SWIG_arg_fail(2)) SWIG_fail;
13352 }
13353 {
13354 arg3 = (int)(SWIG_As_int(obj2));
13355 if (SWIG_arg_fail(3)) SWIG_fail;
13356 }
13357 {
13358 arg4 = (int)(SWIG_As_int(obj3));
13359 if (SWIG_arg_fail(4)) SWIG_fail;
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 (arg1)->DrawCircle(arg2,arg3,arg4);
13364
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 Py_INCREF(Py_None); resultobj = Py_None;
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxDC *arg1 = (wxDC *) 0 ;
13378 wxPoint *arg2 = 0 ;
13379 int arg3 ;
13380 wxPoint temp2 ;
13381 PyObject * obj0 = 0 ;
13382 PyObject * obj1 = 0 ;
13383 PyObject * obj2 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self",(char *) "pt",(char *) "radius", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13390 if (SWIG_arg_fail(1)) SWIG_fail;
13391 {
13392 arg2 = &temp2;
13393 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13394 }
13395 {
13396 arg3 = (int)(SWIG_As_int(obj2));
13397 if (SWIG_arg_fail(3)) SWIG_fail;
13398 }
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13402
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 Py_INCREF(Py_None); resultobj = Py_None;
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj;
13415 wxDC *arg1 = (wxDC *) 0 ;
13416 int arg2 ;
13417 int arg3 ;
13418 int arg4 ;
13419 int arg5 ;
13420 PyObject * obj0 = 0 ;
13421 PyObject * obj1 = 0 ;
13422 PyObject * obj2 = 0 ;
13423 PyObject * obj3 = 0 ;
13424 PyObject * obj4 = 0 ;
13425 char *kwnames[] = {
13426 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13427 };
13428
13429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13431 if (SWIG_arg_fail(1)) SWIG_fail;
13432 {
13433 arg2 = (int)(SWIG_As_int(obj1));
13434 if (SWIG_arg_fail(2)) SWIG_fail;
13435 }
13436 {
13437 arg3 = (int)(SWIG_As_int(obj2));
13438 if (SWIG_arg_fail(3)) SWIG_fail;
13439 }
13440 {
13441 arg4 = (int)(SWIG_As_int(obj3));
13442 if (SWIG_arg_fail(4)) SWIG_fail;
13443 }
13444 {
13445 arg5 = (int)(SWIG_As_int(obj4));
13446 if (SWIG_arg_fail(5)) SWIG_fail;
13447 }
13448 {
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13451
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 Py_INCREF(Py_None); resultobj = Py_None;
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj;
13464 wxDC *arg1 = (wxDC *) 0 ;
13465 wxRect *arg2 = 0 ;
13466 wxRect temp2 ;
13467 PyObject * obj0 = 0 ;
13468 PyObject * obj1 = 0 ;
13469 char *kwnames[] = {
13470 (char *) "self",(char *) "rect", NULL
13471 };
13472
13473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13475 if (SWIG_arg_fail(1)) SWIG_fail;
13476 {
13477 arg2 = &temp2;
13478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13479 }
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 (arg1)->DrawEllipse((wxRect const &)*arg2);
13483
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 Py_INCREF(Py_None); resultobj = Py_None;
13488 return resultobj;
13489 fail:
13490 return NULL;
13491 }
13492
13493
13494 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj;
13496 wxDC *arg1 = (wxDC *) 0 ;
13497 wxPoint *arg2 = 0 ;
13498 wxSize *arg3 = 0 ;
13499 wxPoint temp2 ;
13500 wxSize temp3 ;
13501 PyObject * obj0 = 0 ;
13502 PyObject * obj1 = 0 ;
13503 PyObject * obj2 = 0 ;
13504 char *kwnames[] = {
13505 (char *) "self",(char *) "pt",(char *) "sz", NULL
13506 };
13507
13508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13510 if (SWIG_arg_fail(1)) SWIG_fail;
13511 {
13512 arg2 = &temp2;
13513 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13514 }
13515 {
13516 arg3 = &temp3;
13517 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13518 }
13519 {
13520 PyThreadState* __tstate = wxPyBeginAllowThreads();
13521 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13522
13523 wxPyEndAllowThreads(__tstate);
13524 if (PyErr_Occurred()) SWIG_fail;
13525 }
13526 Py_INCREF(Py_None); resultobj = Py_None;
13527 return resultobj;
13528 fail:
13529 return NULL;
13530 }
13531
13532
13533 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13534 PyObject *resultobj;
13535 wxDC *arg1 = (wxDC *) 0 ;
13536 wxIcon *arg2 = 0 ;
13537 int arg3 ;
13538 int arg4 ;
13539 PyObject * obj0 = 0 ;
13540 PyObject * obj1 = 0 ;
13541 PyObject * obj2 = 0 ;
13542 PyObject * obj3 = 0 ;
13543 char *kwnames[] = {
13544 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13545 };
13546
13547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13549 if (SWIG_arg_fail(1)) SWIG_fail;
13550 {
13551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13552 if (SWIG_arg_fail(2)) SWIG_fail;
13553 if (arg2 == NULL) {
13554 SWIG_null_ref("wxIcon");
13555 }
13556 if (SWIG_arg_fail(2)) SWIG_fail;
13557 }
13558 {
13559 arg3 = (int)(SWIG_As_int(obj2));
13560 if (SWIG_arg_fail(3)) SWIG_fail;
13561 }
13562 {
13563 arg4 = (int)(SWIG_As_int(obj3));
13564 if (SWIG_arg_fail(4)) SWIG_fail;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13569
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 Py_INCREF(Py_None); resultobj = Py_None;
13574 return resultobj;
13575 fail:
13576 return NULL;
13577 }
13578
13579
13580 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13581 PyObject *resultobj;
13582 wxDC *arg1 = (wxDC *) 0 ;
13583 wxIcon *arg2 = 0 ;
13584 wxPoint *arg3 = 0 ;
13585 wxPoint temp3 ;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 PyObject * obj2 = 0 ;
13589 char *kwnames[] = {
13590 (char *) "self",(char *) "icon",(char *) "pt", NULL
13591 };
13592
13593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13595 if (SWIG_arg_fail(1)) SWIG_fail;
13596 {
13597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13598 if (SWIG_arg_fail(2)) SWIG_fail;
13599 if (arg2 == NULL) {
13600 SWIG_null_ref("wxIcon");
13601 }
13602 if (SWIG_arg_fail(2)) SWIG_fail;
13603 }
13604 {
13605 arg3 = &temp3;
13606 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 Py_INCREF(Py_None); resultobj = Py_None;
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj;
13624 wxDC *arg1 = (wxDC *) 0 ;
13625 wxBitmap *arg2 = 0 ;
13626 int arg3 ;
13627 int arg4 ;
13628 bool arg5 = (bool) false ;
13629 PyObject * obj0 = 0 ;
13630 PyObject * obj1 = 0 ;
13631 PyObject * obj2 = 0 ;
13632 PyObject * obj3 = 0 ;
13633 PyObject * obj4 = 0 ;
13634 char *kwnames[] = {
13635 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13636 };
13637
13638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13640 if (SWIG_arg_fail(1)) SWIG_fail;
13641 {
13642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13643 if (SWIG_arg_fail(2)) SWIG_fail;
13644 if (arg2 == NULL) {
13645 SWIG_null_ref("wxBitmap");
13646 }
13647 if (SWIG_arg_fail(2)) SWIG_fail;
13648 }
13649 {
13650 arg3 = (int)(SWIG_As_int(obj2));
13651 if (SWIG_arg_fail(3)) SWIG_fail;
13652 }
13653 {
13654 arg4 = (int)(SWIG_As_int(obj3));
13655 if (SWIG_arg_fail(4)) SWIG_fail;
13656 }
13657 if (obj4) {
13658 {
13659 arg5 = (bool)(SWIG_As_bool(obj4));
13660 if (SWIG_arg_fail(5)) SWIG_fail;
13661 }
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 Py_INCREF(Py_None); resultobj = Py_None;
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj;
13679 wxDC *arg1 = (wxDC *) 0 ;
13680 wxBitmap *arg2 = 0 ;
13681 wxPoint *arg3 = 0 ;
13682 bool arg4 = (bool) false ;
13683 wxPoint temp3 ;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 PyObject * obj2 = 0 ;
13687 PyObject * obj3 = 0 ;
13688 char *kwnames[] = {
13689 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13690 };
13691
13692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13694 if (SWIG_arg_fail(1)) SWIG_fail;
13695 {
13696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13697 if (SWIG_arg_fail(2)) SWIG_fail;
13698 if (arg2 == NULL) {
13699 SWIG_null_ref("wxBitmap");
13700 }
13701 if (SWIG_arg_fail(2)) SWIG_fail;
13702 }
13703 {
13704 arg3 = &temp3;
13705 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13706 }
13707 if (obj3) {
13708 {
13709 arg4 = (bool)(SWIG_As_bool(obj3));
13710 if (SWIG_arg_fail(4)) SWIG_fail;
13711 }
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 Py_INCREF(Py_None); resultobj = Py_None;
13721 return resultobj;
13722 fail:
13723 return NULL;
13724 }
13725
13726
13727 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxDC *arg1 = (wxDC *) 0 ;
13730 wxString *arg2 = 0 ;
13731 int arg3 ;
13732 int arg4 ;
13733 bool temp2 = false ;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 PyObject * obj2 = 0 ;
13737 PyObject * obj3 = 0 ;
13738 char *kwnames[] = {
13739 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13740 };
13741
13742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13744 if (SWIG_arg_fail(1)) SWIG_fail;
13745 {
13746 arg2 = wxString_in_helper(obj1);
13747 if (arg2 == NULL) SWIG_fail;
13748 temp2 = true;
13749 }
13750 {
13751 arg3 = (int)(SWIG_As_int(obj2));
13752 if (SWIG_arg_fail(3)) SWIG_fail;
13753 }
13754 {
13755 arg4 = (int)(SWIG_As_int(obj3));
13756 if (SWIG_arg_fail(4)) SWIG_fail;
13757 }
13758 {
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13761
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 Py_INCREF(Py_None); resultobj = Py_None;
13766 {
13767 if (temp2)
13768 delete arg2;
13769 }
13770 return resultobj;
13771 fail:
13772 {
13773 if (temp2)
13774 delete arg2;
13775 }
13776 return NULL;
13777 }
13778
13779
13780 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj;
13782 wxDC *arg1 = (wxDC *) 0 ;
13783 wxString *arg2 = 0 ;
13784 wxPoint *arg3 = 0 ;
13785 bool temp2 = false ;
13786 wxPoint temp3 ;
13787 PyObject * obj0 = 0 ;
13788 PyObject * obj1 = 0 ;
13789 PyObject * obj2 = 0 ;
13790 char *kwnames[] = {
13791 (char *) "self",(char *) "text",(char *) "pt", NULL
13792 };
13793
13794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13796 if (SWIG_arg_fail(1)) SWIG_fail;
13797 {
13798 arg2 = wxString_in_helper(obj1);
13799 if (arg2 == NULL) SWIG_fail;
13800 temp2 = true;
13801 }
13802 {
13803 arg3 = &temp3;
13804 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13805 }
13806 {
13807 PyThreadState* __tstate = wxPyBeginAllowThreads();
13808 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13809
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 Py_INCREF(Py_None); resultobj = Py_None;
13814 {
13815 if (temp2)
13816 delete arg2;
13817 }
13818 return resultobj;
13819 fail:
13820 {
13821 if (temp2)
13822 delete arg2;
13823 }
13824 return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj;
13830 wxDC *arg1 = (wxDC *) 0 ;
13831 wxString *arg2 = 0 ;
13832 int arg3 ;
13833 int arg4 ;
13834 double arg5 ;
13835 bool temp2 = false ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 PyObject * obj3 = 0 ;
13840 PyObject * obj4 = 0 ;
13841 char *kwnames[] = {
13842 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13843 };
13844
13845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13847 if (SWIG_arg_fail(1)) SWIG_fail;
13848 {
13849 arg2 = wxString_in_helper(obj1);
13850 if (arg2 == NULL) SWIG_fail;
13851 temp2 = true;
13852 }
13853 {
13854 arg3 = (int)(SWIG_As_int(obj2));
13855 if (SWIG_arg_fail(3)) SWIG_fail;
13856 }
13857 {
13858 arg4 = (int)(SWIG_As_int(obj3));
13859 if (SWIG_arg_fail(4)) SWIG_fail;
13860 }
13861 {
13862 arg5 = (double)(SWIG_As_double(obj4));
13863 if (SWIG_arg_fail(5)) SWIG_fail;
13864 }
13865 {
13866 PyThreadState* __tstate = wxPyBeginAllowThreads();
13867 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13868
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 Py_INCREF(Py_None); resultobj = Py_None;
13873 {
13874 if (temp2)
13875 delete arg2;
13876 }
13877 return resultobj;
13878 fail:
13879 {
13880 if (temp2)
13881 delete arg2;
13882 }
13883 return NULL;
13884 }
13885
13886
13887 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13888 PyObject *resultobj;
13889 wxDC *arg1 = (wxDC *) 0 ;
13890 wxString *arg2 = 0 ;
13891 wxPoint *arg3 = 0 ;
13892 double arg4 ;
13893 bool temp2 = false ;
13894 wxPoint temp3 ;
13895 PyObject * obj0 = 0 ;
13896 PyObject * obj1 = 0 ;
13897 PyObject * obj2 = 0 ;
13898 PyObject * obj3 = 0 ;
13899 char *kwnames[] = {
13900 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13901 };
13902
13903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13905 if (SWIG_arg_fail(1)) SWIG_fail;
13906 {
13907 arg2 = wxString_in_helper(obj1);
13908 if (arg2 == NULL) SWIG_fail;
13909 temp2 = true;
13910 }
13911 {
13912 arg3 = &temp3;
13913 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13914 }
13915 {
13916 arg4 = (double)(SWIG_As_double(obj3));
13917 if (SWIG_arg_fail(4)) SWIG_fail;
13918 }
13919 {
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13922
13923 wxPyEndAllowThreads(__tstate);
13924 if (PyErr_Occurred()) SWIG_fail;
13925 }
13926 Py_INCREF(Py_None); resultobj = Py_None;
13927 {
13928 if (temp2)
13929 delete arg2;
13930 }
13931 return resultobj;
13932 fail:
13933 {
13934 if (temp2)
13935 delete arg2;
13936 }
13937 return NULL;
13938 }
13939
13940
13941 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13942 PyObject *resultobj;
13943 wxDC *arg1 = (wxDC *) 0 ;
13944 int arg2 ;
13945 int arg3 ;
13946 int arg4 ;
13947 int arg5 ;
13948 wxDC *arg6 = (wxDC *) 0 ;
13949 int arg7 ;
13950 int arg8 ;
13951 int arg9 = (int) wxCOPY ;
13952 bool arg10 = (bool) false ;
13953 int arg11 = (int) -1 ;
13954 int arg12 = (int) -1 ;
13955 bool result;
13956 PyObject * obj0 = 0 ;
13957 PyObject * obj1 = 0 ;
13958 PyObject * obj2 = 0 ;
13959 PyObject * obj3 = 0 ;
13960 PyObject * obj4 = 0 ;
13961 PyObject * obj5 = 0 ;
13962 PyObject * obj6 = 0 ;
13963 PyObject * obj7 = 0 ;
13964 PyObject * obj8 = 0 ;
13965 PyObject * obj9 = 0 ;
13966 PyObject * obj10 = 0 ;
13967 PyObject * obj11 = 0 ;
13968 char *kwnames[] = {
13969 (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
13970 };
13971
13972 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;
13973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13974 if (SWIG_arg_fail(1)) SWIG_fail;
13975 {
13976 arg2 = (int)(SWIG_As_int(obj1));
13977 if (SWIG_arg_fail(2)) SWIG_fail;
13978 }
13979 {
13980 arg3 = (int)(SWIG_As_int(obj2));
13981 if (SWIG_arg_fail(3)) SWIG_fail;
13982 }
13983 {
13984 arg4 = (int)(SWIG_As_int(obj3));
13985 if (SWIG_arg_fail(4)) SWIG_fail;
13986 }
13987 {
13988 arg5 = (int)(SWIG_As_int(obj4));
13989 if (SWIG_arg_fail(5)) SWIG_fail;
13990 }
13991 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13992 if (SWIG_arg_fail(6)) SWIG_fail;
13993 {
13994 arg7 = (int)(SWIG_As_int(obj6));
13995 if (SWIG_arg_fail(7)) SWIG_fail;
13996 }
13997 {
13998 arg8 = (int)(SWIG_As_int(obj7));
13999 if (SWIG_arg_fail(8)) SWIG_fail;
14000 }
14001 if (obj8) {
14002 {
14003 arg9 = (int)(SWIG_As_int(obj8));
14004 if (SWIG_arg_fail(9)) SWIG_fail;
14005 }
14006 }
14007 if (obj9) {
14008 {
14009 arg10 = (bool)(SWIG_As_bool(obj9));
14010 if (SWIG_arg_fail(10)) SWIG_fail;
14011 }
14012 }
14013 if (obj10) {
14014 {
14015 arg11 = (int)(SWIG_As_int(obj10));
14016 if (SWIG_arg_fail(11)) SWIG_fail;
14017 }
14018 }
14019 if (obj11) {
14020 {
14021 arg12 = (int)(SWIG_As_int(obj11));
14022 if (SWIG_arg_fail(12)) SWIG_fail;
14023 }
14024 }
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14028
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 {
14033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14034 }
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj;
14043 wxDC *arg1 = (wxDC *) 0 ;
14044 wxPoint *arg2 = 0 ;
14045 wxSize *arg3 = 0 ;
14046 wxDC *arg4 = (wxDC *) 0 ;
14047 wxPoint *arg5 = 0 ;
14048 int arg6 = (int) wxCOPY ;
14049 bool arg7 = (bool) false ;
14050 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14051 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14052 bool result;
14053 wxPoint temp2 ;
14054 wxSize temp3 ;
14055 wxPoint temp5 ;
14056 wxPoint temp8 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 PyObject * obj3 = 0 ;
14061 PyObject * obj4 = 0 ;
14062 PyObject * obj5 = 0 ;
14063 PyObject * obj6 = 0 ;
14064 PyObject * obj7 = 0 ;
14065 char *kwnames[] = {
14066 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14067 };
14068
14069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14071 if (SWIG_arg_fail(1)) SWIG_fail;
14072 {
14073 arg2 = &temp2;
14074 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14075 }
14076 {
14077 arg3 = &temp3;
14078 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14079 }
14080 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14081 if (SWIG_arg_fail(4)) SWIG_fail;
14082 {
14083 arg5 = &temp5;
14084 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14085 }
14086 if (obj5) {
14087 {
14088 arg6 = (int)(SWIG_As_int(obj5));
14089 if (SWIG_arg_fail(6)) SWIG_fail;
14090 }
14091 }
14092 if (obj6) {
14093 {
14094 arg7 = (bool)(SWIG_As_bool(obj6));
14095 if (SWIG_arg_fail(7)) SWIG_fail;
14096 }
14097 }
14098 if (obj7) {
14099 {
14100 arg8 = &temp8;
14101 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14102 }
14103 }
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14107
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 {
14112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14113 }
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxDC *arg1 = (wxDC *) 0 ;
14123 int arg2 ;
14124 int arg3 ;
14125 int arg4 ;
14126 int arg5 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 PyObject * obj2 = 0 ;
14130 PyObject * obj3 = 0 ;
14131 PyObject * obj4 = 0 ;
14132 char *kwnames[] = {
14133 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14134 };
14135
14136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14138 if (SWIG_arg_fail(1)) SWIG_fail;
14139 {
14140 arg2 = (int)(SWIG_As_int(obj1));
14141 if (SWIG_arg_fail(2)) SWIG_fail;
14142 }
14143 {
14144 arg3 = (int)(SWIG_As_int(obj2));
14145 if (SWIG_arg_fail(3)) SWIG_fail;
14146 }
14147 {
14148 arg4 = (int)(SWIG_As_int(obj3));
14149 if (SWIG_arg_fail(4)) SWIG_fail;
14150 }
14151 {
14152 arg5 = (int)(SWIG_As_int(obj4));
14153 if (SWIG_arg_fail(5)) SWIG_fail;
14154 }
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14158
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 Py_INCREF(Py_None); resultobj = Py_None;
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj;
14171 wxDC *arg1 = (wxDC *) 0 ;
14172 wxPoint *arg2 = 0 ;
14173 wxSize *arg3 = 0 ;
14174 wxPoint temp2 ;
14175 wxSize temp3 ;
14176 PyObject * obj0 = 0 ;
14177 PyObject * obj1 = 0 ;
14178 PyObject * obj2 = 0 ;
14179 char *kwnames[] = {
14180 (char *) "self",(char *) "pt",(char *) "sz", NULL
14181 };
14182
14183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14185 if (SWIG_arg_fail(1)) SWIG_fail;
14186 {
14187 arg2 = &temp2;
14188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14189 }
14190 {
14191 arg3 = &temp3;
14192 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14193 }
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14197
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 Py_INCREF(Py_None); resultobj = Py_None;
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxDC *arg1 = (wxDC *) 0 ;
14211 wxRegion *arg2 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 char *kwnames[] = {
14215 (char *) "self",(char *) "region", NULL
14216 };
14217
14218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14220 if (SWIG_arg_fail(1)) SWIG_fail;
14221 {
14222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14223 if (SWIG_arg_fail(2)) SWIG_fail;
14224 if (arg2 == NULL) {
14225 SWIG_null_ref("wxRegion");
14226 }
14227 if (SWIG_arg_fail(2)) SWIG_fail;
14228 }
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14232
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 Py_INCREF(Py_None); resultobj = Py_None;
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxDC *arg1 = (wxDC *) 0 ;
14246 wxRect *arg2 = 0 ;
14247 wxRect temp2 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "rect", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 {
14258 arg2 = &temp2;
14259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14260 }
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14264
14265 wxPyEndAllowThreads(__tstate);
14266 if (PyErr_Occurred()) SWIG_fail;
14267 }
14268 Py_INCREF(Py_None); resultobj = Py_None;
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14276 PyObject *resultobj;
14277 wxDC *arg1 = (wxDC *) 0 ;
14278 int arg2 ;
14279 wxPoint *arg3 = (wxPoint *) 0 ;
14280 int arg4 = (int) 0 ;
14281 int arg5 = (int) 0 ;
14282 PyObject * obj0 = 0 ;
14283 PyObject * obj1 = 0 ;
14284 PyObject * obj2 = 0 ;
14285 PyObject * obj3 = 0 ;
14286 char *kwnames[] = {
14287 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14288 };
14289
14290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14292 if (SWIG_arg_fail(1)) SWIG_fail;
14293 {
14294 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14295 if (arg3 == NULL) SWIG_fail;
14296 }
14297 if (obj2) {
14298 {
14299 arg4 = (int)(SWIG_As_int(obj2));
14300 if (SWIG_arg_fail(4)) SWIG_fail;
14301 }
14302 }
14303 if (obj3) {
14304 {
14305 arg5 = (int)(SWIG_As_int(obj3));
14306 if (SWIG_arg_fail(5)) SWIG_fail;
14307 }
14308 }
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14312
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 Py_INCREF(Py_None); resultobj = Py_None;
14317 {
14318 if (arg3) delete [] arg3;
14319 }
14320 return resultobj;
14321 fail:
14322 {
14323 if (arg3) delete [] arg3;
14324 }
14325 return NULL;
14326 }
14327
14328
14329 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxDC *arg1 = (wxDC *) 0 ;
14332 int arg2 ;
14333 wxPoint *arg3 = (wxPoint *) 0 ;
14334 int arg4 = (int) 0 ;
14335 int arg5 = (int) 0 ;
14336 int arg6 = (int) wxODDEVEN_RULE ;
14337 PyObject * obj0 = 0 ;
14338 PyObject * obj1 = 0 ;
14339 PyObject * obj2 = 0 ;
14340 PyObject * obj3 = 0 ;
14341 PyObject * obj4 = 0 ;
14342 char *kwnames[] = {
14343 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14344 };
14345
14346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14348 if (SWIG_arg_fail(1)) SWIG_fail;
14349 {
14350 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14351 if (arg3 == NULL) SWIG_fail;
14352 }
14353 if (obj2) {
14354 {
14355 arg4 = (int)(SWIG_As_int(obj2));
14356 if (SWIG_arg_fail(4)) SWIG_fail;
14357 }
14358 }
14359 if (obj3) {
14360 {
14361 arg5 = (int)(SWIG_As_int(obj3));
14362 if (SWIG_arg_fail(5)) SWIG_fail;
14363 }
14364 }
14365 if (obj4) {
14366 {
14367 arg6 = (int)(SWIG_As_int(obj4));
14368 if (SWIG_arg_fail(6)) SWIG_fail;
14369 }
14370 }
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14374
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 Py_INCREF(Py_None); resultobj = Py_None;
14379 {
14380 if (arg3) delete [] arg3;
14381 }
14382 return resultobj;
14383 fail:
14384 {
14385 if (arg3) delete [] arg3;
14386 }
14387 return NULL;
14388 }
14389
14390
14391 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14392 PyObject *resultobj;
14393 wxDC *arg1 = (wxDC *) 0 ;
14394 wxString *arg2 = 0 ;
14395 wxRect *arg3 = 0 ;
14396 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14397 int arg5 = (int) -1 ;
14398 bool temp2 = false ;
14399 wxRect temp3 ;
14400 PyObject * obj0 = 0 ;
14401 PyObject * obj1 = 0 ;
14402 PyObject * obj2 = 0 ;
14403 PyObject * obj3 = 0 ;
14404 PyObject * obj4 = 0 ;
14405 char *kwnames[] = {
14406 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14407 };
14408
14409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14411 if (SWIG_arg_fail(1)) SWIG_fail;
14412 {
14413 arg2 = wxString_in_helper(obj1);
14414 if (arg2 == NULL) SWIG_fail;
14415 temp2 = true;
14416 }
14417 {
14418 arg3 = &temp3;
14419 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14420 }
14421 if (obj3) {
14422 {
14423 arg4 = (int)(SWIG_As_int(obj3));
14424 if (SWIG_arg_fail(4)) SWIG_fail;
14425 }
14426 }
14427 if (obj4) {
14428 {
14429 arg5 = (int)(SWIG_As_int(obj4));
14430 if (SWIG_arg_fail(5)) SWIG_fail;
14431 }
14432 }
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14436
14437 wxPyEndAllowThreads(__tstate);
14438 if (PyErr_Occurred()) SWIG_fail;
14439 }
14440 Py_INCREF(Py_None); resultobj = Py_None;
14441 {
14442 if (temp2)
14443 delete arg2;
14444 }
14445 return resultobj;
14446 fail:
14447 {
14448 if (temp2)
14449 delete arg2;
14450 }
14451 return NULL;
14452 }
14453
14454
14455 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14456 PyObject *resultobj;
14457 wxDC *arg1 = (wxDC *) 0 ;
14458 wxString *arg2 = 0 ;
14459 wxBitmap *arg3 = 0 ;
14460 wxRect *arg4 = 0 ;
14461 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14462 int arg6 = (int) -1 ;
14463 wxRect result;
14464 bool temp2 = false ;
14465 wxRect temp4 ;
14466 PyObject * obj0 = 0 ;
14467 PyObject * obj1 = 0 ;
14468 PyObject * obj2 = 0 ;
14469 PyObject * obj3 = 0 ;
14470 PyObject * obj4 = 0 ;
14471 PyObject * obj5 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14478 if (SWIG_arg_fail(1)) SWIG_fail;
14479 {
14480 arg2 = wxString_in_helper(obj1);
14481 if (arg2 == NULL) SWIG_fail;
14482 temp2 = true;
14483 }
14484 {
14485 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(3)) SWIG_fail;
14487 if (arg3 == NULL) {
14488 SWIG_null_ref("wxBitmap");
14489 }
14490 if (SWIG_arg_fail(3)) SWIG_fail;
14491 }
14492 {
14493 arg4 = &temp4;
14494 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14495 }
14496 if (obj4) {
14497 {
14498 arg5 = (int)(SWIG_As_int(obj4));
14499 if (SWIG_arg_fail(5)) SWIG_fail;
14500 }
14501 }
14502 if (obj5) {
14503 {
14504 arg6 = (int)(SWIG_As_int(obj5));
14505 if (SWIG_arg_fail(6)) SWIG_fail;
14506 }
14507 }
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14511
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 {
14516 wxRect * resultptr;
14517 resultptr = new wxRect((wxRect &)(result));
14518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14519 }
14520 {
14521 if (temp2)
14522 delete arg2;
14523 }
14524 return resultobj;
14525 fail:
14526 {
14527 if (temp2)
14528 delete arg2;
14529 }
14530 return NULL;
14531 }
14532
14533
14534 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj;
14536 wxDC *arg1 = (wxDC *) 0 ;
14537 int arg2 ;
14538 wxPoint *arg3 = (wxPoint *) 0 ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 char *kwnames[] = {
14542 (char *) "self",(char *) "points", NULL
14543 };
14544
14545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14547 if (SWIG_arg_fail(1)) SWIG_fail;
14548 {
14549 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14550 if (arg3 == NULL) SWIG_fail;
14551 }
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 (arg1)->DrawSpline(arg2,arg3);
14555
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 Py_INCREF(Py_None); resultobj = Py_None;
14560 {
14561 if (arg3) delete [] arg3;
14562 }
14563 return resultobj;
14564 fail:
14565 {
14566 if (arg3) delete [] arg3;
14567 }
14568 return NULL;
14569 }
14570
14571
14572 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj;
14574 wxDC *arg1 = (wxDC *) 0 ;
14575 PyObject * obj0 = 0 ;
14576 char *kwnames[] = {
14577 (char *) "self", NULL
14578 };
14579
14580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14582 if (SWIG_arg_fail(1)) SWIG_fail;
14583 {
14584 PyThreadState* __tstate = wxPyBeginAllowThreads();
14585 (arg1)->Clear();
14586
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 Py_INCREF(Py_None); resultobj = Py_None;
14591 return resultobj;
14592 fail:
14593 return NULL;
14594 }
14595
14596
14597 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14598 PyObject *resultobj;
14599 wxDC *arg1 = (wxDC *) 0 ;
14600 wxString *arg2 = 0 ;
14601 bool result;
14602 bool temp2 = false ;
14603 PyObject * obj0 = 0 ;
14604 PyObject * obj1 = 0 ;
14605 char *kwnames[] = {
14606 (char *) "self",(char *) "message", NULL
14607 };
14608
14609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14611 if (SWIG_arg_fail(1)) SWIG_fail;
14612 {
14613 arg2 = wxString_in_helper(obj1);
14614 if (arg2 == NULL) SWIG_fail;
14615 temp2 = true;
14616 }
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14626 }
14627 {
14628 if (temp2)
14629 delete arg2;
14630 }
14631 return resultobj;
14632 fail:
14633 {
14634 if (temp2)
14635 delete arg2;
14636 }
14637 return NULL;
14638 }
14639
14640
14641 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14642 PyObject *resultobj;
14643 wxDC *arg1 = (wxDC *) 0 ;
14644 PyObject * obj0 = 0 ;
14645 char *kwnames[] = {
14646 (char *) "self", NULL
14647 };
14648
14649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14651 if (SWIG_arg_fail(1)) SWIG_fail;
14652 {
14653 PyThreadState* __tstate = wxPyBeginAllowThreads();
14654 (arg1)->EndDoc();
14655
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 Py_INCREF(Py_None); resultobj = Py_None;
14660 return resultobj;
14661 fail:
14662 return NULL;
14663 }
14664
14665
14666 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14667 PyObject *resultobj;
14668 wxDC *arg1 = (wxDC *) 0 ;
14669 PyObject * obj0 = 0 ;
14670 char *kwnames[] = {
14671 (char *) "self", NULL
14672 };
14673
14674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14676 if (SWIG_arg_fail(1)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->StartPage();
14680
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 Py_INCREF(Py_None); resultobj = Py_None;
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj;
14693 wxDC *arg1 = (wxDC *) 0 ;
14694 PyObject * obj0 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 (arg1)->EndPage();
14705
14706 wxPyEndAllowThreads(__tstate);
14707 if (PyErr_Occurred()) SWIG_fail;
14708 }
14709 Py_INCREF(Py_None); resultobj = Py_None;
14710 return resultobj;
14711 fail:
14712 return NULL;
14713 }
14714
14715
14716 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14717 PyObject *resultobj;
14718 wxDC *arg1 = (wxDC *) 0 ;
14719 wxFont *arg2 = 0 ;
14720 PyObject * obj0 = 0 ;
14721 PyObject * obj1 = 0 ;
14722 char *kwnames[] = {
14723 (char *) "self",(char *) "font", NULL
14724 };
14725
14726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14728 if (SWIG_arg_fail(1)) SWIG_fail;
14729 {
14730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14731 if (SWIG_arg_fail(2)) SWIG_fail;
14732 if (arg2 == NULL) {
14733 SWIG_null_ref("wxFont");
14734 }
14735 if (SWIG_arg_fail(2)) SWIG_fail;
14736 }
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 (arg1)->SetFont((wxFont const &)*arg2);
14740
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 Py_INCREF(Py_None); resultobj = Py_None;
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj;
14753 wxDC *arg1 = (wxDC *) 0 ;
14754 wxPen *arg2 = 0 ;
14755 PyObject * obj0 = 0 ;
14756 PyObject * obj1 = 0 ;
14757 char *kwnames[] = {
14758 (char *) "self",(char *) "pen", NULL
14759 };
14760
14761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14763 if (SWIG_arg_fail(1)) SWIG_fail;
14764 {
14765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14766 if (SWIG_arg_fail(2)) SWIG_fail;
14767 if (arg2 == NULL) {
14768 SWIG_null_ref("wxPen");
14769 }
14770 if (SWIG_arg_fail(2)) SWIG_fail;
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 (arg1)->SetPen((wxPen const &)*arg2);
14775
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 Py_INCREF(Py_None); resultobj = Py_None;
14780 return resultobj;
14781 fail:
14782 return NULL;
14783 }
14784
14785
14786 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14787 PyObject *resultobj;
14788 wxDC *arg1 = (wxDC *) 0 ;
14789 wxBrush *arg2 = 0 ;
14790 PyObject * obj0 = 0 ;
14791 PyObject * obj1 = 0 ;
14792 char *kwnames[] = {
14793 (char *) "self",(char *) "brush", NULL
14794 };
14795
14796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14798 if (SWIG_arg_fail(1)) SWIG_fail;
14799 {
14800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14801 if (SWIG_arg_fail(2)) SWIG_fail;
14802 if (arg2 == NULL) {
14803 SWIG_null_ref("wxBrush");
14804 }
14805 if (SWIG_arg_fail(2)) SWIG_fail;
14806 }
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 (arg1)->SetBrush((wxBrush const &)*arg2);
14810
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 Py_INCREF(Py_None); resultobj = Py_None;
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj;
14823 wxDC *arg1 = (wxDC *) 0 ;
14824 wxBrush *arg2 = 0 ;
14825 PyObject * obj0 = 0 ;
14826 PyObject * obj1 = 0 ;
14827 char *kwnames[] = {
14828 (char *) "self",(char *) "brush", NULL
14829 };
14830
14831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14833 if (SWIG_arg_fail(1)) SWIG_fail;
14834 {
14835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14836 if (SWIG_arg_fail(2)) SWIG_fail;
14837 if (arg2 == NULL) {
14838 SWIG_null_ref("wxBrush");
14839 }
14840 if (SWIG_arg_fail(2)) SWIG_fail;
14841 }
14842 {
14843 PyThreadState* __tstate = wxPyBeginAllowThreads();
14844 (arg1)->SetBackground((wxBrush const &)*arg2);
14845
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 Py_INCREF(Py_None); resultobj = Py_None;
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14857 PyObject *resultobj;
14858 wxDC *arg1 = (wxDC *) 0 ;
14859 int arg2 ;
14860 PyObject * obj0 = 0 ;
14861 PyObject * obj1 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self",(char *) "mode", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 arg2 = (int)(SWIG_As_int(obj1));
14871 if (SWIG_arg_fail(2)) SWIG_fail;
14872 }
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 (arg1)->SetBackgroundMode(arg2);
14876
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 Py_INCREF(Py_None); resultobj = Py_None;
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14888 PyObject *resultobj;
14889 wxDC *arg1 = (wxDC *) 0 ;
14890 wxPalette *arg2 = 0 ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 char *kwnames[] = {
14894 (char *) "self",(char *) "palette", NULL
14895 };
14896
14897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14899 if (SWIG_arg_fail(1)) SWIG_fail;
14900 {
14901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14902 if (SWIG_arg_fail(2)) SWIG_fail;
14903 if (arg2 == NULL) {
14904 SWIG_null_ref("wxPalette");
14905 }
14906 if (SWIG_arg_fail(2)) SWIG_fail;
14907 }
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 (arg1)->SetPalette((wxPalette const &)*arg2);
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 Py_INCREF(Py_None); resultobj = Py_None;
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14923 PyObject *resultobj;
14924 wxDC *arg1 = (wxDC *) 0 ;
14925 PyObject * obj0 = 0 ;
14926 char *kwnames[] = {
14927 (char *) "self", NULL
14928 };
14929
14930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14932 if (SWIG_arg_fail(1)) SWIG_fail;
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 (arg1)->DestroyClippingRegion();
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 Py_INCREF(Py_None); resultobj = Py_None;
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxDC *arg1 = (wxDC *) 0 ;
14950 int *arg2 = (int *) 0 ;
14951 int *arg3 = (int *) 0 ;
14952 int *arg4 = (int *) 0 ;
14953 int *arg5 = (int *) 0 ;
14954 int temp2 ;
14955 int res2 = 0 ;
14956 int temp3 ;
14957 int res3 = 0 ;
14958 int temp4 ;
14959 int res4 = 0 ;
14960 int temp5 ;
14961 int res5 = 0 ;
14962 PyObject * obj0 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self", NULL
14965 };
14966
14967 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14968 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14969 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14970 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14977
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 Py_INCREF(Py_None); resultobj = Py_None;
14982 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14983 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14984 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14985 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14986 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14987 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14988 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14989 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj;
14998 wxDC *arg1 = (wxDC *) 0 ;
14999 wxRect result;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = wxDC_GetClippingRect(arg1);
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 {
15016 wxRect * resultptr;
15017 resultptr = new wxRect((wxRect &)(result));
15018 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15019 }
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15027 PyObject *resultobj;
15028 wxDC *arg1 = (wxDC *) 0 ;
15029 int result;
15030 PyObject * obj0 = 0 ;
15031 char *kwnames[] = {
15032 (char *) "self", NULL
15033 };
15034
15035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",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 = (int)((wxDC const *)arg1)->GetCharHeight();
15041
15042 wxPyEndAllowThreads(__tstate);
15043 if (PyErr_Occurred()) SWIG_fail;
15044 }
15045 {
15046 resultobj = SWIG_From_int((int)(result));
15047 }
15048 return resultobj;
15049 fail:
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxDC *arg1 = (wxDC *) 0 ;
15057 int result;
15058 PyObject * obj0 = 0 ;
15059 char *kwnames[] = {
15060 (char *) "self", NULL
15061 };
15062
15063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15065 if (SWIG_arg_fail(1)) SWIG_fail;
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (int)((wxDC const *)arg1)->GetCharWidth();
15069
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 {
15074 resultobj = SWIG_From_int((int)(result));
15075 }
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15083 PyObject *resultobj;
15084 wxDC *arg1 = (wxDC *) 0 ;
15085 wxString *arg2 = 0 ;
15086 int *arg3 = (int *) 0 ;
15087 int *arg4 = (int *) 0 ;
15088 bool temp2 = false ;
15089 int temp3 ;
15090 int res3 = 0 ;
15091 int temp4 ;
15092 int res4 = 0 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self",(char *) "string", NULL
15097 };
15098
15099 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15100 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15103 if (SWIG_arg_fail(1)) SWIG_fail;
15104 {
15105 arg2 = wxString_in_helper(obj1);
15106 if (arg2 == NULL) SWIG_fail;
15107 temp2 = true;
15108 }
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15112
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 Py_INCREF(Py_None); resultobj = Py_None;
15117 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15118 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15119 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15120 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15121 {
15122 if (temp2)
15123 delete arg2;
15124 }
15125 return resultobj;
15126 fail:
15127 {
15128 if (temp2)
15129 delete arg2;
15130 }
15131 return NULL;
15132 }
15133
15134
15135 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj;
15137 wxDC *arg1 = (wxDC *) 0 ;
15138 wxString *arg2 = 0 ;
15139 int *arg3 = (int *) 0 ;
15140 int *arg4 = (int *) 0 ;
15141 int *arg5 = (int *) 0 ;
15142 int *arg6 = (int *) 0 ;
15143 wxFont *arg7 = (wxFont *) NULL ;
15144 bool temp2 = false ;
15145 int temp3 ;
15146 int res3 = 0 ;
15147 int temp4 ;
15148 int res4 = 0 ;
15149 int temp5 ;
15150 int res5 = 0 ;
15151 int temp6 ;
15152 int res6 = 0 ;
15153 PyObject * obj0 = 0 ;
15154 PyObject * obj1 = 0 ;
15155 PyObject * obj2 = 0 ;
15156 char *kwnames[] = {
15157 (char *) "self",(char *) "string",(char *) "font", NULL
15158 };
15159
15160 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15161 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15162 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15163 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15166 if (SWIG_arg_fail(1)) SWIG_fail;
15167 {
15168 arg2 = wxString_in_helper(obj1);
15169 if (arg2 == NULL) SWIG_fail;
15170 temp2 = true;
15171 }
15172 if (obj2) {
15173 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(7)) SWIG_fail;
15175 }
15176 {
15177 PyThreadState* __tstate = wxPyBeginAllowThreads();
15178 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15179
15180 wxPyEndAllowThreads(__tstate);
15181 if (PyErr_Occurred()) SWIG_fail;
15182 }
15183 Py_INCREF(Py_None); resultobj = Py_None;
15184 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15185 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15186 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15187 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15188 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15189 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15190 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15191 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15192 {
15193 if (temp2)
15194 delete arg2;
15195 }
15196 return resultobj;
15197 fail:
15198 {
15199 if (temp2)
15200 delete arg2;
15201 }
15202 return NULL;
15203 }
15204
15205
15206 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15207 PyObject *resultobj;
15208 wxDC *arg1 = (wxDC *) 0 ;
15209 wxString *arg2 = 0 ;
15210 int *arg3 = (int *) 0 ;
15211 int *arg4 = (int *) 0 ;
15212 int *arg5 = (int *) 0 ;
15213 wxFont *arg6 = (wxFont *) NULL ;
15214 bool temp2 = false ;
15215 int temp3 ;
15216 int res3 = 0 ;
15217 int temp4 ;
15218 int res4 = 0 ;
15219 int temp5 ;
15220 int res5 = 0 ;
15221 PyObject * obj0 = 0 ;
15222 PyObject * obj1 = 0 ;
15223 PyObject * obj2 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self",(char *) "text",(char *) "font", NULL
15226 };
15227
15228 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15229 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15230 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15233 if (SWIG_arg_fail(1)) SWIG_fail;
15234 {
15235 arg2 = wxString_in_helper(obj1);
15236 if (arg2 == NULL) SWIG_fail;
15237 temp2 = true;
15238 }
15239 if (obj2) {
15240 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15241 if (SWIG_arg_fail(6)) SWIG_fail;
15242 }
15243 {
15244 PyThreadState* __tstate = wxPyBeginAllowThreads();
15245 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15246
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 Py_INCREF(Py_None); resultobj = Py_None;
15251 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15252 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15253 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15254 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15255 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15256 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15257 {
15258 if (temp2)
15259 delete arg2;
15260 }
15261 return resultobj;
15262 fail:
15263 {
15264 if (temp2)
15265 delete arg2;
15266 }
15267 return NULL;
15268 }
15269
15270
15271 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15272 PyObject *resultobj;
15273 wxDC *arg1 = (wxDC *) 0 ;
15274 wxString *arg2 = 0 ;
15275 wxArrayInt result;
15276 bool temp2 = false ;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self",(char *) "text", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15285 if (SWIG_arg_fail(1)) SWIG_fail;
15286 {
15287 arg2 = wxString_in_helper(obj1);
15288 if (arg2 == NULL) SWIG_fail;
15289 temp2 = true;
15290 }
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15294
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 {
15299 resultobj = PyList_New(0);
15300 size_t idx;
15301 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15302 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15303 PyList_Append(resultobj, val);
15304 Py_DECREF(val);
15305 }
15306 }
15307 {
15308 if (temp2)
15309 delete arg2;
15310 }
15311 return resultobj;
15312 fail:
15313 {
15314 if (temp2)
15315 delete arg2;
15316 }
15317 return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj;
15323 wxDC *arg1 = (wxDC *) 0 ;
15324 wxSize result;
15325 PyObject * obj0 = 0 ;
15326 char *kwnames[] = {
15327 (char *) "self", NULL
15328 };
15329
15330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15332 if (SWIG_arg_fail(1)) SWIG_fail;
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (arg1)->GetSize();
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 {
15341 wxSize * resultptr;
15342 resultptr = new wxSize((wxSize &)(result));
15343 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15344 }
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15352 PyObject *resultobj;
15353 wxDC *arg1 = (wxDC *) 0 ;
15354 int *arg2 = (int *) 0 ;
15355 int *arg3 = (int *) 0 ;
15356 int temp2 ;
15357 int res2 = 0 ;
15358 int temp3 ;
15359 int res3 = 0 ;
15360 PyObject * obj0 = 0 ;
15361 char *kwnames[] = {
15362 (char *) "self", NULL
15363 };
15364
15365 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15366 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 (arg1)->GetSize(arg2,arg3);
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 Py_INCREF(Py_None); resultobj = Py_None;
15378 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15379 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15380 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15381 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15389 PyObject *resultobj;
15390 wxDC *arg1 = (wxDC *) 0 ;
15391 wxSize result;
15392 PyObject * obj0 = 0 ;
15393 char *kwnames[] = {
15394 (char *) "self", NULL
15395 };
15396
15397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",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 result = ((wxDC const *)arg1)->GetSizeMM();
15403
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 {
15408 wxSize * resultptr;
15409 resultptr = new wxSize((wxSize &)(result));
15410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15411 }
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15419 PyObject *resultobj;
15420 wxDC *arg1 = (wxDC *) 0 ;
15421 int *arg2 = (int *) 0 ;
15422 int *arg3 = (int *) 0 ;
15423 int temp2 ;
15424 int res2 = 0 ;
15425 int temp3 ;
15426 int res3 = 0 ;
15427 PyObject * obj0 = 0 ;
15428 char *kwnames[] = {
15429 (char *) "self", NULL
15430 };
15431
15432 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15433 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15436 if (SWIG_arg_fail(1)) SWIG_fail;
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15440
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 Py_INCREF(Py_None); resultobj = Py_None;
15445 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15446 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15447 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15448 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15456 PyObject *resultobj;
15457 wxDC *arg1 = (wxDC *) 0 ;
15458 int arg2 ;
15459 int result;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 char *kwnames[] = {
15463 (char *) "self",(char *) "x", NULL
15464 };
15465
15466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15468 if (SWIG_arg_fail(1)) SWIG_fail;
15469 {
15470 arg2 = (int)(SWIG_As_int(obj1));
15471 if (SWIG_arg_fail(2)) SWIG_fail;
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15476
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 {
15481 resultobj = SWIG_From_int((int)(result));
15482 }
15483 return resultobj;
15484 fail:
15485 return NULL;
15486 }
15487
15488
15489 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15490 PyObject *resultobj;
15491 wxDC *arg1 = (wxDC *) 0 ;
15492 int arg2 ;
15493 int result;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char *kwnames[] = {
15497 (char *) "self",(char *) "y", NULL
15498 };
15499
15500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15502 if (SWIG_arg_fail(1)) SWIG_fail;
15503 {
15504 arg2 = (int)(SWIG_As_int(obj1));
15505 if (SWIG_arg_fail(2)) SWIG_fail;
15506 }
15507 {
15508 PyThreadState* __tstate = wxPyBeginAllowThreads();
15509 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15510
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 {
15515 resultobj = SWIG_From_int((int)(result));
15516 }
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15524 PyObject *resultobj;
15525 wxDC *arg1 = (wxDC *) 0 ;
15526 int arg2 ;
15527 int result;
15528 PyObject * obj0 = 0 ;
15529 PyObject * obj1 = 0 ;
15530 char *kwnames[] = {
15531 (char *) "self",(char *) "x", NULL
15532 };
15533
15534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15536 if (SWIG_arg_fail(1)) SWIG_fail;
15537 {
15538 arg2 = (int)(SWIG_As_int(obj1));
15539 if (SWIG_arg_fail(2)) SWIG_fail;
15540 }
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15544
15545 wxPyEndAllowThreads(__tstate);
15546 if (PyErr_Occurred()) SWIG_fail;
15547 }
15548 {
15549 resultobj = SWIG_From_int((int)(result));
15550 }
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj;
15559 wxDC *arg1 = (wxDC *) 0 ;
15560 int arg2 ;
15561 int result;
15562 PyObject * obj0 = 0 ;
15563 PyObject * obj1 = 0 ;
15564 char *kwnames[] = {
15565 (char *) "self",(char *) "y", NULL
15566 };
15567
15568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15570 if (SWIG_arg_fail(1)) SWIG_fail;
15571 {
15572 arg2 = (int)(SWIG_As_int(obj1));
15573 if (SWIG_arg_fail(2)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15578
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 {
15583 resultobj = SWIG_From_int((int)(result));
15584 }
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj;
15593 wxDC *arg1 = (wxDC *) 0 ;
15594 int arg2 ;
15595 int result;
15596 PyObject * obj0 = 0 ;
15597 PyObject * obj1 = 0 ;
15598 char *kwnames[] = {
15599 (char *) "self",(char *) "x", NULL
15600 };
15601
15602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15604 if (SWIG_arg_fail(1)) SWIG_fail;
15605 {
15606 arg2 = (int)(SWIG_As_int(obj1));
15607 if (SWIG_arg_fail(2)) SWIG_fail;
15608 }
15609 {
15610 PyThreadState* __tstate = wxPyBeginAllowThreads();
15611 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15612
15613 wxPyEndAllowThreads(__tstate);
15614 if (PyErr_Occurred()) SWIG_fail;
15615 }
15616 {
15617 resultobj = SWIG_From_int((int)(result));
15618 }
15619 return resultobj;
15620 fail:
15621 return NULL;
15622 }
15623
15624
15625 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15626 PyObject *resultobj;
15627 wxDC *arg1 = (wxDC *) 0 ;
15628 int arg2 ;
15629 int result;
15630 PyObject * obj0 = 0 ;
15631 PyObject * obj1 = 0 ;
15632 char *kwnames[] = {
15633 (char *) "self",(char *) "y", NULL
15634 };
15635
15636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15638 if (SWIG_arg_fail(1)) SWIG_fail;
15639 {
15640 arg2 = (int)(SWIG_As_int(obj1));
15641 if (SWIG_arg_fail(2)) SWIG_fail;
15642 }
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15646
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 {
15651 resultobj = SWIG_From_int((int)(result));
15652 }
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15660 PyObject *resultobj;
15661 wxDC *arg1 = (wxDC *) 0 ;
15662 int arg2 ;
15663 int result;
15664 PyObject * obj0 = 0 ;
15665 PyObject * obj1 = 0 ;
15666 char *kwnames[] = {
15667 (char *) "self",(char *) "x", NULL
15668 };
15669
15670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15672 if (SWIG_arg_fail(1)) SWIG_fail;
15673 {
15674 arg2 = (int)(SWIG_As_int(obj1));
15675 if (SWIG_arg_fail(2)) SWIG_fail;
15676 }
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15680
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 {
15685 resultobj = SWIG_From_int((int)(result));
15686 }
15687 return resultobj;
15688 fail:
15689 return NULL;
15690 }
15691
15692
15693 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15694 PyObject *resultobj;
15695 wxDC *arg1 = (wxDC *) 0 ;
15696 int arg2 ;
15697 int result;
15698 PyObject * obj0 = 0 ;
15699 PyObject * obj1 = 0 ;
15700 char *kwnames[] = {
15701 (char *) "self",(char *) "y", NULL
15702 };
15703
15704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15706 if (SWIG_arg_fail(1)) SWIG_fail;
15707 {
15708 arg2 = (int)(SWIG_As_int(obj1));
15709 if (SWIG_arg_fail(2)) SWIG_fail;
15710 }
15711 {
15712 PyThreadState* __tstate = wxPyBeginAllowThreads();
15713 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15714
15715 wxPyEndAllowThreads(__tstate);
15716 if (PyErr_Occurred()) SWIG_fail;
15717 }
15718 {
15719 resultobj = SWIG_From_int((int)(result));
15720 }
15721 return resultobj;
15722 fail:
15723 return NULL;
15724 }
15725
15726
15727 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15728 PyObject *resultobj;
15729 wxDC *arg1 = (wxDC *) 0 ;
15730 bool result;
15731 PyObject * obj0 = 0 ;
15732 char *kwnames[] = {
15733 (char *) "self", NULL
15734 };
15735
15736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15738 if (SWIG_arg_fail(1)) SWIG_fail;
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15742
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 {
15747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15748 }
15749 return resultobj;
15750 fail:
15751 return NULL;
15752 }
15753
15754
15755 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15756 PyObject *resultobj;
15757 wxDC *arg1 = (wxDC *) 0 ;
15758 bool result;
15759 PyObject * obj0 = 0 ;
15760 char *kwnames[] = {
15761 (char *) "self", NULL
15762 };
15763
15764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15766 if (SWIG_arg_fail(1)) SWIG_fail;
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15770
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 {
15775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15776 }
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15784 PyObject *resultobj;
15785 wxDC *arg1 = (wxDC *) 0 ;
15786 int result;
15787 PyObject * obj0 = 0 ;
15788 char *kwnames[] = {
15789 (char *) "self", NULL
15790 };
15791
15792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15794 if (SWIG_arg_fail(1)) SWIG_fail;
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 result = (int)((wxDC const *)arg1)->GetDepth();
15798
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 {
15803 resultobj = SWIG_From_int((int)(result));
15804 }
15805 return resultobj;
15806 fail:
15807 return NULL;
15808 }
15809
15810
15811 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15812 PyObject *resultobj;
15813 wxDC *arg1 = (wxDC *) 0 ;
15814 wxSize result;
15815 PyObject * obj0 = 0 ;
15816 char *kwnames[] = {
15817 (char *) "self", NULL
15818 };
15819
15820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15822 if (SWIG_arg_fail(1)) SWIG_fail;
15823 {
15824 PyThreadState* __tstate = wxPyBeginAllowThreads();
15825 result = ((wxDC const *)arg1)->GetPPI();
15826
15827 wxPyEndAllowThreads(__tstate);
15828 if (PyErr_Occurred()) SWIG_fail;
15829 }
15830 {
15831 wxSize * resultptr;
15832 resultptr = new wxSize((wxSize &)(result));
15833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15834 }
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15842 PyObject *resultobj;
15843 wxDC *arg1 = (wxDC *) 0 ;
15844 bool result;
15845 PyObject * obj0 = 0 ;
15846 char *kwnames[] = {
15847 (char *) "self", NULL
15848 };
15849
15850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",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 = (bool)((wxDC const *)arg1)->Ok();
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 {
15861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15862 }
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj;
15871 wxDC *arg1 = (wxDC *) 0 ;
15872 int result;
15873 PyObject * obj0 = 0 ;
15874 char *kwnames[] = {
15875 (char *) "self", NULL
15876 };
15877
15878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15880 if (SWIG_arg_fail(1)) SWIG_fail;
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15884
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 {
15889 resultobj = SWIG_From_int((int)(result));
15890 }
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15898 PyObject *resultobj;
15899 wxDC *arg1 = (wxDC *) 0 ;
15900 wxBrush *result;
15901 PyObject * obj0 = 0 ;
15902 char *kwnames[] = {
15903 (char *) "self", NULL
15904 };
15905
15906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15908 if (SWIG_arg_fail(1)) SWIG_fail;
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 {
15912 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15913 result = (wxBrush *) &_result_ref;
15914 }
15915
15916 wxPyEndAllowThreads(__tstate);
15917 if (PyErr_Occurred()) SWIG_fail;
15918 }
15919 {
15920 wxBrush* resultptr = new wxBrush(*result);
15921 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15922 }
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj;
15931 wxDC *arg1 = (wxDC *) 0 ;
15932 wxBrush *result;
15933 PyObject * obj0 = 0 ;
15934 char *kwnames[] = {
15935 (char *) "self", NULL
15936 };
15937
15938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15940 if (SWIG_arg_fail(1)) SWIG_fail;
15941 {
15942 PyThreadState* __tstate = wxPyBeginAllowThreads();
15943 {
15944 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15945 result = (wxBrush *) &_result_ref;
15946 }
15947
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 {
15952 wxBrush* resultptr = new wxBrush(*result);
15953 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15954 }
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj;
15963 wxDC *arg1 = (wxDC *) 0 ;
15964 wxFont *result;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 {
15976 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15977 result = (wxFont *) &_result_ref;
15978 }
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 {
15984 wxFont* resultptr = new wxFont(*result);
15985 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15986 }
15987 return resultobj;
15988 fail:
15989 return NULL;
15990 }
15991
15992
15993 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15994 PyObject *resultobj;
15995 wxDC *arg1 = (wxDC *) 0 ;
15996 wxPen *result;
15997 PyObject * obj0 = 0 ;
15998 char *kwnames[] = {
15999 (char *) "self", NULL
16000 };
16001
16002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16004 if (SWIG_arg_fail(1)) SWIG_fail;
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 {
16008 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16009 result = (wxPen *) &_result_ref;
16010 }
16011
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 {
16016 wxPen* resultptr = new wxPen(*result);
16017 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16018 }
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16026 PyObject *resultobj;
16027 wxDC *arg1 = (wxDC *) 0 ;
16028 wxColour *result;
16029 PyObject * obj0 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 {
16040 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16041 result = (wxColour *) &_result_ref;
16042 }
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj;
16056 wxDC *arg1 = (wxDC *) 0 ;
16057 wxColour *result;
16058 PyObject * obj0 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 {
16067 PyThreadState* __tstate = wxPyBeginAllowThreads();
16068 {
16069 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16070 result = (wxColour *) &_result_ref;
16071 }
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj;
16085 wxDC *arg1 = (wxDC *) 0 ;
16086 wxColour *arg2 = 0 ;
16087 wxColour temp2 ;
16088 PyObject * obj0 = 0 ;
16089 PyObject * obj1 = 0 ;
16090 char *kwnames[] = {
16091 (char *) "self",(char *) "colour", NULL
16092 };
16093
16094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16096 if (SWIG_arg_fail(1)) SWIG_fail;
16097 {
16098 arg2 = &temp2;
16099 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16100 }
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 (arg1)->SetTextForeground((wxColour const &)*arg2);
16104
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 Py_INCREF(Py_None); resultobj = Py_None;
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxDC *arg1 = (wxDC *) 0 ;
16118 wxColour *arg2 = 0 ;
16119 wxColour temp2 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self",(char *) "colour", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 arg2 = &temp2;
16131 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 (arg1)->SetTextBackground((wxColour const &)*arg2);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 Py_INCREF(Py_None); resultobj = Py_None;
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16148 PyObject *resultobj;
16149 wxDC *arg1 = (wxDC *) 0 ;
16150 int result;
16151 PyObject * obj0 = 0 ;
16152 char *kwnames[] = {
16153 (char *) "self", NULL
16154 };
16155
16156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16161 result = (int)((wxDC const *)arg1)->GetMapMode();
16162
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 {
16167 resultobj = SWIG_From_int((int)(result));
16168 }
16169 return resultobj;
16170 fail:
16171 return NULL;
16172 }
16173
16174
16175 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16176 PyObject *resultobj;
16177 wxDC *arg1 = (wxDC *) 0 ;
16178 int arg2 ;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 char *kwnames[] = {
16182 (char *) "self",(char *) "mode", NULL
16183 };
16184
16185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16187 if (SWIG_arg_fail(1)) SWIG_fail;
16188 {
16189 arg2 = (int)(SWIG_As_int(obj1));
16190 if (SWIG_arg_fail(2)) SWIG_fail;
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 (arg1)->SetMapMode(arg2);
16195
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 Py_INCREF(Py_None); resultobj = Py_None;
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16207 PyObject *resultobj;
16208 wxDC *arg1 = (wxDC *) 0 ;
16209 double *arg2 = (double *) 0 ;
16210 double *arg3 = (double *) 0 ;
16211 double temp2 ;
16212 int res2 = 0 ;
16213 double temp3 ;
16214 int res3 = 0 ;
16215 PyObject * obj0 = 0 ;
16216 char *kwnames[] = {
16217 (char *) "self", NULL
16218 };
16219
16220 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16221 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16224 if (SWIG_arg_fail(1)) SWIG_fail;
16225 {
16226 PyThreadState* __tstate = wxPyBeginAllowThreads();
16227 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16228
16229 wxPyEndAllowThreads(__tstate);
16230 if (PyErr_Occurred()) SWIG_fail;
16231 }
16232 Py_INCREF(Py_None); resultobj = Py_None;
16233 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16234 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16235 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16236 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxDC *arg1 = (wxDC *) 0 ;
16246 double arg2 ;
16247 double arg3 ;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 PyObject * obj2 = 0 ;
16251 char *kwnames[] = {
16252 (char *) "self",(char *) "x",(char *) "y", NULL
16253 };
16254
16255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16257 if (SWIG_arg_fail(1)) SWIG_fail;
16258 {
16259 arg2 = (double)(SWIG_As_double(obj1));
16260 if (SWIG_arg_fail(2)) SWIG_fail;
16261 }
16262 {
16263 arg3 = (double)(SWIG_As_double(obj2));
16264 if (SWIG_arg_fail(3)) SWIG_fail;
16265 }
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 (arg1)->SetUserScale(arg2,arg3);
16269
16270 wxPyEndAllowThreads(__tstate);
16271 if (PyErr_Occurred()) SWIG_fail;
16272 }
16273 Py_INCREF(Py_None); resultobj = Py_None;
16274 return resultobj;
16275 fail:
16276 return NULL;
16277 }
16278
16279
16280 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16281 PyObject *resultobj;
16282 wxDC *arg1 = (wxDC *) 0 ;
16283 double *arg2 = (double *) 0 ;
16284 double *arg3 = (double *) 0 ;
16285 double temp2 ;
16286 int res2 = 0 ;
16287 double temp3 ;
16288 int res3 = 0 ;
16289 PyObject * obj0 = 0 ;
16290 char *kwnames[] = {
16291 (char *) "self", NULL
16292 };
16293
16294 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16295 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16298 if (SWIG_arg_fail(1)) SWIG_fail;
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 (arg1)->GetLogicalScale(arg2,arg3);
16302
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 Py_INCREF(Py_None); resultobj = Py_None;
16307 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16308 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16309 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16310 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxDC *arg1 = (wxDC *) 0 ;
16320 double arg2 ;
16321 double arg3 ;
16322 PyObject * obj0 = 0 ;
16323 PyObject * obj1 = 0 ;
16324 PyObject * obj2 = 0 ;
16325 char *kwnames[] = {
16326 (char *) "self",(char *) "x",(char *) "y", NULL
16327 };
16328
16329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16331 if (SWIG_arg_fail(1)) SWIG_fail;
16332 {
16333 arg2 = (double)(SWIG_As_double(obj1));
16334 if (SWIG_arg_fail(2)) SWIG_fail;
16335 }
16336 {
16337 arg3 = (double)(SWIG_As_double(obj2));
16338 if (SWIG_arg_fail(3)) SWIG_fail;
16339 }
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 (arg1)->SetLogicalScale(arg2,arg3);
16343
16344 wxPyEndAllowThreads(__tstate);
16345 if (PyErr_Occurred()) SWIG_fail;
16346 }
16347 Py_INCREF(Py_None); resultobj = Py_None;
16348 return resultobj;
16349 fail:
16350 return NULL;
16351 }
16352
16353
16354 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16355 PyObject *resultobj;
16356 wxDC *arg1 = (wxDC *) 0 ;
16357 wxPoint result;
16358 PyObject * obj0 = 0 ;
16359 char *kwnames[] = {
16360 (char *) "self", NULL
16361 };
16362
16363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16365 if (SWIG_arg_fail(1)) SWIG_fail;
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16369
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 {
16374 wxPoint * resultptr;
16375 resultptr = new wxPoint((wxPoint &)(result));
16376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16377 }
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj;
16386 wxDC *arg1 = (wxDC *) 0 ;
16387 int *arg2 = (int *) 0 ;
16388 int *arg3 = (int *) 0 ;
16389 int temp2 ;
16390 int res2 = 0 ;
16391 int temp3 ;
16392 int res3 = 0 ;
16393 PyObject * obj0 = 0 ;
16394 char *kwnames[] = {
16395 (char *) "self", NULL
16396 };
16397
16398 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16399 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16402 if (SWIG_arg_fail(1)) SWIG_fail;
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16406
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 Py_INCREF(Py_None); resultobj = Py_None;
16411 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16412 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16413 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16414 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxDC *arg1 = (wxDC *) 0 ;
16424 int arg2 ;
16425 int arg3 ;
16426 PyObject * obj0 = 0 ;
16427 PyObject * obj1 = 0 ;
16428 PyObject * obj2 = 0 ;
16429 char *kwnames[] = {
16430 (char *) "self",(char *) "x",(char *) "y", NULL
16431 };
16432
16433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16435 if (SWIG_arg_fail(1)) SWIG_fail;
16436 {
16437 arg2 = (int)(SWIG_As_int(obj1));
16438 if (SWIG_arg_fail(2)) SWIG_fail;
16439 }
16440 {
16441 arg3 = (int)(SWIG_As_int(obj2));
16442 if (SWIG_arg_fail(3)) SWIG_fail;
16443 }
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 (arg1)->SetLogicalOrigin(arg2,arg3);
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 Py_INCREF(Py_None); resultobj = Py_None;
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj;
16460 wxDC *arg1 = (wxDC *) 0 ;
16461 wxPoint *arg2 = 0 ;
16462 wxPoint temp2 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 char *kwnames[] = {
16466 (char *) "self",(char *) "point", NULL
16467 };
16468
16469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16471 if (SWIG_arg_fail(1)) SWIG_fail;
16472 {
16473 arg2 = &temp2;
16474 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16475 }
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16479
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 Py_INCREF(Py_None); resultobj = Py_None;
16484 return resultobj;
16485 fail:
16486 return NULL;
16487 }
16488
16489
16490 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16491 PyObject *resultobj;
16492 wxDC *arg1 = (wxDC *) 0 ;
16493 wxPoint result;
16494 PyObject * obj0 = 0 ;
16495 char *kwnames[] = {
16496 (char *) "self", NULL
16497 };
16498
16499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16504 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16505
16506 wxPyEndAllowThreads(__tstate);
16507 if (PyErr_Occurred()) SWIG_fail;
16508 }
16509 {
16510 wxPoint * resultptr;
16511 resultptr = new wxPoint((wxPoint &)(result));
16512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16513 }
16514 return resultobj;
16515 fail:
16516 return NULL;
16517 }
16518
16519
16520 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxDC *arg1 = (wxDC *) 0 ;
16523 int *arg2 = (int *) 0 ;
16524 int *arg3 = (int *) 0 ;
16525 int temp2 ;
16526 int res2 = 0 ;
16527 int temp3 ;
16528 int res3 = 0 ;
16529 PyObject * obj0 = 0 ;
16530 char *kwnames[] = {
16531 (char *) "self", NULL
16532 };
16533
16534 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16535 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16538 if (SWIG_arg_fail(1)) SWIG_fail;
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 Py_INCREF(Py_None); resultobj = Py_None;
16547 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16548 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16549 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16550 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj;
16559 wxDC *arg1 = (wxDC *) 0 ;
16560 int arg2 ;
16561 int arg3 ;
16562 PyObject * obj0 = 0 ;
16563 PyObject * obj1 = 0 ;
16564 PyObject * obj2 = 0 ;
16565 char *kwnames[] = {
16566 (char *) "self",(char *) "x",(char *) "y", NULL
16567 };
16568
16569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16571 if (SWIG_arg_fail(1)) SWIG_fail;
16572 {
16573 arg2 = (int)(SWIG_As_int(obj1));
16574 if (SWIG_arg_fail(2)) SWIG_fail;
16575 }
16576 {
16577 arg3 = (int)(SWIG_As_int(obj2));
16578 if (SWIG_arg_fail(3)) SWIG_fail;
16579 }
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 (arg1)->SetDeviceOrigin(arg2,arg3);
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 Py_INCREF(Py_None); resultobj = Py_None;
16588 return resultobj;
16589 fail:
16590 return NULL;
16591 }
16592
16593
16594 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16595 PyObject *resultobj;
16596 wxDC *arg1 = (wxDC *) 0 ;
16597 wxPoint *arg2 = 0 ;
16598 wxPoint temp2 ;
16599 PyObject * obj0 = 0 ;
16600 PyObject * obj1 = 0 ;
16601 char *kwnames[] = {
16602 (char *) "self",(char *) "point", NULL
16603 };
16604
16605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16607 if (SWIG_arg_fail(1)) SWIG_fail;
16608 {
16609 arg2 = &temp2;
16610 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16611 }
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16615
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 Py_INCREF(Py_None); resultobj = Py_None;
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj;
16628 wxDC *arg1 = (wxDC *) 0 ;
16629 bool arg2 ;
16630 bool arg3 ;
16631 PyObject * obj0 = 0 ;
16632 PyObject * obj1 = 0 ;
16633 PyObject * obj2 = 0 ;
16634 char *kwnames[] = {
16635 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16636 };
16637
16638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16640 if (SWIG_arg_fail(1)) SWIG_fail;
16641 {
16642 arg2 = (bool)(SWIG_As_bool(obj1));
16643 if (SWIG_arg_fail(2)) SWIG_fail;
16644 }
16645 {
16646 arg3 = (bool)(SWIG_As_bool(obj2));
16647 if (SWIG_arg_fail(3)) SWIG_fail;
16648 }
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 (arg1)->SetAxisOrientation(arg2,arg3);
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 Py_INCREF(Py_None); resultobj = Py_None;
16657 return resultobj;
16658 fail:
16659 return NULL;
16660 }
16661
16662
16663 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16664 PyObject *resultobj;
16665 wxDC *arg1 = (wxDC *) 0 ;
16666 int result;
16667 PyObject * obj0 = 0 ;
16668 char *kwnames[] = {
16669 (char *) "self", NULL
16670 };
16671
16672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16674 if (SWIG_arg_fail(1)) SWIG_fail;
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16678
16679 wxPyEndAllowThreads(__tstate);
16680 if (PyErr_Occurred()) SWIG_fail;
16681 }
16682 {
16683 resultobj = SWIG_From_int((int)(result));
16684 }
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj;
16693 wxDC *arg1 = (wxDC *) 0 ;
16694 int arg2 ;
16695 PyObject * obj0 = 0 ;
16696 PyObject * obj1 = 0 ;
16697 char *kwnames[] = {
16698 (char *) "self",(char *) "function", NULL
16699 };
16700
16701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16703 if (SWIG_arg_fail(1)) SWIG_fail;
16704 {
16705 arg2 = (int)(SWIG_As_int(obj1));
16706 if (SWIG_arg_fail(2)) SWIG_fail;
16707 }
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 (arg1)->SetLogicalFunction(arg2);
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 Py_INCREF(Py_None); resultobj = Py_None;
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj;
16724 wxDC *arg1 = (wxDC *) 0 ;
16725 PyObject * obj0 = 0 ;
16726 char *kwnames[] = {
16727 (char *) "self", NULL
16728 };
16729
16730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16732 if (SWIG_arg_fail(1)) SWIG_fail;
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 (arg1)->ComputeScaleAndOrigin();
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 Py_INCREF(Py_None); resultobj = Py_None;
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj;
16749 wxDC *arg1 = (wxDC *) 0 ;
16750 int arg2 ;
16751 int arg3 ;
16752 PyObject * obj0 = 0 ;
16753 PyObject * obj1 = 0 ;
16754 PyObject * obj2 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self",(char *) "x",(char *) "y", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 arg2 = (int)(SWIG_As_int(obj1));
16764 if (SWIG_arg_fail(2)) SWIG_fail;
16765 }
16766 {
16767 arg3 = (int)(SWIG_As_int(obj2));
16768 if (SWIG_arg_fail(3)) SWIG_fail;
16769 }
16770 {
16771 PyThreadState* __tstate = wxPyBeginAllowThreads();
16772 (arg1)->CalcBoundingBox(arg2,arg3);
16773
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 Py_INCREF(Py_None); resultobj = Py_None;
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxDC *arg1 = (wxDC *) 0 ;
16787 wxPoint *arg2 = 0 ;
16788 wxPoint temp2 ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 char *kwnames[] = {
16792 (char *) "self",(char *) "point", NULL
16793 };
16794
16795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16797 if (SWIG_arg_fail(1)) SWIG_fail;
16798 {
16799 arg2 = &temp2;
16800 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16801 }
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 Py_INCREF(Py_None); resultobj = Py_None;
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16817 PyObject *resultobj;
16818 wxDC *arg1 = (wxDC *) 0 ;
16819 PyObject * obj0 = 0 ;
16820 char *kwnames[] = {
16821 (char *) "self", NULL
16822 };
16823
16824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16826 if (SWIG_arg_fail(1)) SWIG_fail;
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 (arg1)->ResetBoundingBox();
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 Py_INCREF(Py_None); resultobj = Py_None;
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16842 PyObject *resultobj;
16843 wxDC *arg1 = (wxDC *) 0 ;
16844 int result;
16845 PyObject * obj0 = 0 ;
16846 char *kwnames[] = {
16847 (char *) "self", NULL
16848 };
16849
16850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16852 if (SWIG_arg_fail(1)) SWIG_fail;
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (int)((wxDC const *)arg1)->MinX();
16856
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 {
16861 resultobj = SWIG_From_int((int)(result));
16862 }
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj;
16871 wxDC *arg1 = (wxDC *) 0 ;
16872 int result;
16873 PyObject * obj0 = 0 ;
16874 char *kwnames[] = {
16875 (char *) "self", NULL
16876 };
16877
16878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16880 if (SWIG_arg_fail(1)) SWIG_fail;
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = (int)((wxDC const *)arg1)->MaxX();
16884
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 {
16889 resultobj = SWIG_From_int((int)(result));
16890 }
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16898 PyObject *resultobj;
16899 wxDC *arg1 = (wxDC *) 0 ;
16900 int result;
16901 PyObject * obj0 = 0 ;
16902 char *kwnames[] = {
16903 (char *) "self", NULL
16904 };
16905
16906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16908 if (SWIG_arg_fail(1)) SWIG_fail;
16909 {
16910 PyThreadState* __tstate = wxPyBeginAllowThreads();
16911 result = (int)((wxDC const *)arg1)->MinY();
16912
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 {
16917 resultobj = SWIG_From_int((int)(result));
16918 }
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16926 PyObject *resultobj;
16927 wxDC *arg1 = (wxDC *) 0 ;
16928 int result;
16929 PyObject * obj0 = 0 ;
16930 char *kwnames[] = {
16931 (char *) "self", NULL
16932 };
16933
16934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16936 if (SWIG_arg_fail(1)) SWIG_fail;
16937 {
16938 PyThreadState* __tstate = wxPyBeginAllowThreads();
16939 result = (int)((wxDC const *)arg1)->MaxY();
16940
16941 wxPyEndAllowThreads(__tstate);
16942 if (PyErr_Occurred()) SWIG_fail;
16943 }
16944 {
16945 resultobj = SWIG_From_int((int)(result));
16946 }
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj;
16955 wxDC *arg1 = (wxDC *) 0 ;
16956 int *arg2 = (int *) 0 ;
16957 int *arg3 = (int *) 0 ;
16958 int *arg4 = (int *) 0 ;
16959 int *arg5 = (int *) 0 ;
16960 int temp2 ;
16961 int res2 = 0 ;
16962 int temp3 ;
16963 int res3 = 0 ;
16964 int temp4 ;
16965 int res4 = 0 ;
16966 int temp5 ;
16967 int res5 = 0 ;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "self", NULL
16971 };
16972
16973 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16974 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16975 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16976 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16979 if (SWIG_arg_fail(1)) SWIG_fail;
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16983
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 Py_INCREF(Py_None); resultobj = Py_None;
16988 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16989 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16990 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16991 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16992 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16993 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16994 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16995 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj;
17004 wxDC *arg1 = (wxDC *) 0 ;
17005 PyObject *arg2 = (PyObject *) 0 ;
17006 PyObject *arg3 = (PyObject *) 0 ;
17007 PyObject *arg4 = (PyObject *) 0 ;
17008 PyObject *result;
17009 PyObject * obj0 = 0 ;
17010 PyObject * obj1 = 0 ;
17011 PyObject * obj2 = 0 ;
17012 PyObject * obj3 = 0 ;
17013 char *kwnames[] = {
17014 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17015 };
17016
17017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17019 if (SWIG_arg_fail(1)) SWIG_fail;
17020 arg2 = obj1;
17021 arg3 = obj2;
17022 arg4 = obj3;
17023 {
17024 PyThreadState* __tstate = wxPyBeginAllowThreads();
17025 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17026
17027 wxPyEndAllowThreads(__tstate);
17028 if (PyErr_Occurred()) SWIG_fail;
17029 }
17030 resultobj = result;
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj;
17039 wxDC *arg1 = (wxDC *) 0 ;
17040 PyObject *arg2 = (PyObject *) 0 ;
17041 PyObject *arg3 = (PyObject *) 0 ;
17042 PyObject *arg4 = (PyObject *) 0 ;
17043 PyObject *result;
17044 PyObject * obj0 = 0 ;
17045 PyObject * obj1 = 0 ;
17046 PyObject * obj2 = 0 ;
17047 PyObject * obj3 = 0 ;
17048 char *kwnames[] = {
17049 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17050 };
17051
17052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17054 if (SWIG_arg_fail(1)) SWIG_fail;
17055 arg2 = obj1;
17056 arg3 = obj2;
17057 arg4 = obj3;
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 resultobj = result;
17066 return resultobj;
17067 fail:
17068 return NULL;
17069 }
17070
17071
17072 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj;
17074 wxDC *arg1 = (wxDC *) 0 ;
17075 PyObject *arg2 = (PyObject *) 0 ;
17076 PyObject *arg3 = (PyObject *) 0 ;
17077 PyObject *arg4 = (PyObject *) 0 ;
17078 PyObject *result;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 PyObject * obj2 = 0 ;
17082 PyObject * obj3 = 0 ;
17083 char *kwnames[] = {
17084 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17085 };
17086
17087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17089 if (SWIG_arg_fail(1)) SWIG_fail;
17090 arg2 = obj1;
17091 arg3 = obj2;
17092 arg4 = obj3;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 resultobj = result;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxDC *arg1 = (wxDC *) 0 ;
17110 PyObject *arg2 = (PyObject *) 0 ;
17111 PyObject *arg3 = (PyObject *) 0 ;
17112 PyObject *arg4 = (PyObject *) 0 ;
17113 PyObject *result;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 PyObject * obj2 = 0 ;
17117 PyObject * obj3 = 0 ;
17118 char *kwnames[] = {
17119 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17120 };
17121
17122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17124 if (SWIG_arg_fail(1)) SWIG_fail;
17125 arg2 = obj1;
17126 arg3 = obj2;
17127 arg4 = obj3;
17128 {
17129 PyThreadState* __tstate = wxPyBeginAllowThreads();
17130 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 resultobj = result;
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj;
17144 wxDC *arg1 = (wxDC *) 0 ;
17145 PyObject *arg2 = (PyObject *) 0 ;
17146 PyObject *arg3 = (PyObject *) 0 ;
17147 PyObject *arg4 = (PyObject *) 0 ;
17148 PyObject *result;
17149 PyObject * obj0 = 0 ;
17150 PyObject * obj1 = 0 ;
17151 PyObject * obj2 = 0 ;
17152 PyObject * obj3 = 0 ;
17153 char *kwnames[] = {
17154 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17155 };
17156
17157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17159 if (SWIG_arg_fail(1)) SWIG_fail;
17160 arg2 = obj1;
17161 arg3 = obj2;
17162 arg4 = obj3;
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17166
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 resultobj = result;
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj;
17179 wxDC *arg1 = (wxDC *) 0 ;
17180 PyObject *arg2 = (PyObject *) 0 ;
17181 PyObject *arg3 = (PyObject *) 0 ;
17182 PyObject *arg4 = (PyObject *) 0 ;
17183 PyObject *arg5 = (PyObject *) 0 ;
17184 PyObject *result;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 PyObject * obj2 = 0 ;
17188 PyObject * obj3 = 0 ;
17189 PyObject * obj4 = 0 ;
17190 char *kwnames[] = {
17191 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17192 };
17193
17194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17196 if (SWIG_arg_fail(1)) SWIG_fail;
17197 arg2 = obj1;
17198 arg3 = obj2;
17199 arg4 = obj3;
17200 arg5 = obj4;
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17204
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 resultobj = result;
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17216 PyObject *obj;
17217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17218 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17219 Py_INCREF(obj);
17220 return Py_BuildValue((char *)"");
17221 }
17222 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj;
17224 wxMemoryDC *result;
17225 char *kwnames[] = {
17226 NULL
17227 };
17228
17229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17230 {
17231 if (!wxPyCheckForApp()) SWIG_fail;
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (wxMemoryDC *)new wxMemoryDC();
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17239 return resultobj;
17240 fail:
17241 return NULL;
17242 }
17243
17244
17245 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17246 PyObject *resultobj;
17247 wxDC *arg1 = (wxDC *) 0 ;
17248 wxMemoryDC *result;
17249 PyObject * obj0 = 0 ;
17250 char *kwnames[] = {
17251 (char *) "oldDC", NULL
17252 };
17253
17254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17256 if (SWIG_arg_fail(1)) SWIG_fail;
17257 {
17258 if (!wxPyCheckForApp()) SWIG_fail;
17259 PyThreadState* __tstate = wxPyBeginAllowThreads();
17260 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17261
17262 wxPyEndAllowThreads(__tstate);
17263 if (PyErr_Occurred()) SWIG_fail;
17264 }
17265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17273 PyObject *resultobj;
17274 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17275 wxBitmap *arg2 = 0 ;
17276 PyObject * obj0 = 0 ;
17277 PyObject * obj1 = 0 ;
17278 char *kwnames[] = {
17279 (char *) "self",(char *) "bitmap", NULL
17280 };
17281
17282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17284 if (SWIG_arg_fail(1)) SWIG_fail;
17285 {
17286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17287 if (SWIG_arg_fail(2)) SWIG_fail;
17288 if (arg2 == NULL) {
17289 SWIG_null_ref("wxBitmap");
17290 }
17291 if (SWIG_arg_fail(2)) SWIG_fail;
17292 }
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 (arg1)->SelectObject((wxBitmap const &)*arg2);
17296
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 Py_INCREF(Py_None); resultobj = Py_None;
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17308 PyObject *obj;
17309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17310 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17311 Py_INCREF(obj);
17312 return Py_BuildValue((char *)"");
17313 }
17314 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17315 PyObject *resultobj;
17316 wxDC *arg1 = (wxDC *) 0 ;
17317 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17318 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17319 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17320 wxBufferedDC *result;
17321 PyObject * obj0 = 0 ;
17322 PyObject * obj1 = 0 ;
17323 PyObject * obj2 = 0 ;
17324
17325 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17327 if (SWIG_arg_fail(1)) SWIG_fail;
17328 if (obj1) {
17329 {
17330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17331 if (SWIG_arg_fail(2)) SWIG_fail;
17332 if (arg2 == NULL) {
17333 SWIG_null_ref("wxBitmap");
17334 }
17335 if (SWIG_arg_fail(2)) SWIG_fail;
17336 }
17337 }
17338 if (obj2) {
17339 {
17340 arg3 = (int)(SWIG_As_int(obj2));
17341 if (SWIG_arg_fail(3)) SWIG_fail;
17342 }
17343 }
17344 {
17345 if (!wxPyCheckForApp()) SWIG_fail;
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17348
17349 wxPyEndAllowThreads(__tstate);
17350 if (PyErr_Occurred()) SWIG_fail;
17351 }
17352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17360 PyObject *resultobj;
17361 wxDC *arg1 = (wxDC *) 0 ;
17362 wxSize *arg2 = 0 ;
17363 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17364 wxBufferedDC *result;
17365 wxSize temp2 ;
17366 PyObject * obj0 = 0 ;
17367 PyObject * obj1 = 0 ;
17368 PyObject * obj2 = 0 ;
17369
17370 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 {
17374 arg2 = &temp2;
17375 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17376 }
17377 if (obj2) {
17378 {
17379 arg3 = (int)(SWIG_As_int(obj2));
17380 if (SWIG_arg_fail(3)) SWIG_fail;
17381 }
17382 }
17383 {
17384 if (!wxPyCheckForApp()) SWIG_fail;
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17387
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17399 int argc;
17400 PyObject *argv[4];
17401 int ii;
17402
17403 argc = PyObject_Length(args);
17404 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17405 argv[ii] = PyTuple_GetItem(args,ii);
17406 }
17407 if ((argc >= 1) && (argc <= 3)) {
17408 int _v;
17409 {
17410 void *ptr;
17411 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17412 _v = 0;
17413 PyErr_Clear();
17414 } else {
17415 _v = 1;
17416 }
17417 }
17418 if (_v) {
17419 if (argc <= 1) {
17420 return _wrap_new_BufferedDC__SWIG_0(self,args);
17421 }
17422 {
17423 void *ptr = 0;
17424 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17425 _v = 0;
17426 PyErr_Clear();
17427 } else {
17428 _v = (ptr != 0);
17429 }
17430 }
17431 if (_v) {
17432 if (argc <= 2) {
17433 return _wrap_new_BufferedDC__SWIG_0(self,args);
17434 }
17435 _v = SWIG_Check_int(argv[2]);
17436 if (_v) {
17437 return _wrap_new_BufferedDC__SWIG_0(self,args);
17438 }
17439 }
17440 }
17441 }
17442 if ((argc >= 2) && (argc <= 3)) {
17443 int _v;
17444 {
17445 void *ptr;
17446 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17447 _v = 0;
17448 PyErr_Clear();
17449 } else {
17450 _v = 1;
17451 }
17452 }
17453 if (_v) {
17454 {
17455 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17456 }
17457 if (_v) {
17458 if (argc <= 2) {
17459 return _wrap_new_BufferedDC__SWIG_1(self,args);
17460 }
17461 _v = SWIG_Check_int(argv[2]);
17462 if (_v) {
17463 return _wrap_new_BufferedDC__SWIG_1(self,args);
17464 }
17465 }
17466 }
17467 }
17468
17469 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17470 return NULL;
17471 }
17472
17473
17474 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17475 PyObject *resultobj;
17476 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17477 PyObject * obj0 = 0 ;
17478 char *kwnames[] = {
17479 (char *) "self", NULL
17480 };
17481
17482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17484 if (SWIG_arg_fail(1)) SWIG_fail;
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 delete arg1;
17488
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 Py_INCREF(Py_None); resultobj = Py_None;
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17502 PyObject * obj0 = 0 ;
17503 char *kwnames[] = {
17504 (char *) "self", NULL
17505 };
17506
17507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17509 if (SWIG_arg_fail(1)) SWIG_fail;
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 (arg1)->UnMask();
17513
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 Py_INCREF(Py_None); resultobj = Py_None;
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17525 PyObject *obj;
17526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17527 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17528 Py_INCREF(obj);
17529 return Py_BuildValue((char *)"");
17530 }
17531 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj;
17533 wxWindow *arg1 = (wxWindow *) 0 ;
17534 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17535 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17536 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17537 wxBufferedPaintDC *result;
17538 PyObject * obj0 = 0 ;
17539 PyObject * obj1 = 0 ;
17540 PyObject * obj2 = 0 ;
17541 char *kwnames[] = {
17542 (char *) "window",(char *) "buffer",(char *) "style", NULL
17543 };
17544
17545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17547 if (SWIG_arg_fail(1)) SWIG_fail;
17548 if (obj1) {
17549 {
17550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(2)) SWIG_fail;
17552 if (arg2 == NULL) {
17553 SWIG_null_ref("wxBitmap");
17554 }
17555 if (SWIG_arg_fail(2)) SWIG_fail;
17556 }
17557 }
17558 if (obj2) {
17559 {
17560 arg3 = (int)(SWIG_As_int(obj2));
17561 if (SWIG_arg_fail(3)) SWIG_fail;
17562 }
17563 }
17564 {
17565 if (!wxPyCheckForApp()) SWIG_fail;
17566 PyThreadState* __tstate = wxPyBeginAllowThreads();
17567 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17568
17569 wxPyEndAllowThreads(__tstate);
17570 if (PyErr_Occurred()) SWIG_fail;
17571 }
17572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17573 return resultobj;
17574 fail:
17575 return NULL;
17576 }
17577
17578
17579 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17580 PyObject *obj;
17581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17582 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17583 Py_INCREF(obj);
17584 return Py_BuildValue((char *)"");
17585 }
17586 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj;
17588 wxScreenDC *result;
17589 char *kwnames[] = {
17590 NULL
17591 };
17592
17593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17594 {
17595 if (!wxPyCheckForApp()) SWIG_fail;
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (wxScreenDC *)new wxScreenDC();
17598
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17610 PyObject *resultobj;
17611 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17612 wxWindow *arg2 = (wxWindow *) 0 ;
17613 bool result;
17614 PyObject * obj0 = 0 ;
17615 PyObject * obj1 = 0 ;
17616 char *kwnames[] = {
17617 (char *) "self",(char *) "window", NULL
17618 };
17619
17620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17622 if (SWIG_arg_fail(1)) SWIG_fail;
17623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17624 if (SWIG_arg_fail(2)) SWIG_fail;
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17628
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 {
17633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17634 }
17635 return resultobj;
17636 fail:
17637 return NULL;
17638 }
17639
17640
17641 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17642 PyObject *resultobj;
17643 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17644 wxRect *arg2 = (wxRect *) NULL ;
17645 bool result;
17646 PyObject * obj0 = 0 ;
17647 PyObject * obj1 = 0 ;
17648 char *kwnames[] = {
17649 (char *) "self",(char *) "rect", NULL
17650 };
17651
17652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(1)) SWIG_fail;
17655 if (obj1) {
17656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17657 if (SWIG_arg_fail(2)) SWIG_fail;
17658 }
17659 {
17660 PyThreadState* __tstate = wxPyBeginAllowThreads();
17661 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17662
17663 wxPyEndAllowThreads(__tstate);
17664 if (PyErr_Occurred()) SWIG_fail;
17665 }
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17678 bool result;
17679 PyObject * obj0 = 0 ;
17680 char *kwnames[] = {
17681 (char *) "self", NULL
17682 };
17683
17684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17686 if (SWIG_arg_fail(1)) SWIG_fail;
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = (bool)(arg1)->EndDrawingOnTop();
17690
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17704 PyObject *obj;
17705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17706 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17707 Py_INCREF(obj);
17708 return Py_BuildValue((char *)"");
17709 }
17710 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17711 PyObject *resultobj;
17712 wxWindow *arg1 = (wxWindow *) 0 ;
17713 wxClientDC *result;
17714 PyObject * obj0 = 0 ;
17715 char *kwnames[] = {
17716 (char *) "win", NULL
17717 };
17718
17719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17721 if (SWIG_arg_fail(1)) SWIG_fail;
17722 {
17723 if (!wxPyCheckForApp()) SWIG_fail;
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (wxClientDC *)new wxClientDC(arg1);
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17738 PyObject *obj;
17739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17740 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17741 Py_INCREF(obj);
17742 return Py_BuildValue((char *)"");
17743 }
17744 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj;
17746 wxWindow *arg1 = (wxWindow *) 0 ;
17747 wxPaintDC *result;
17748 PyObject * obj0 = 0 ;
17749 char *kwnames[] = {
17750 (char *) "win", NULL
17751 };
17752
17753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17755 if (SWIG_arg_fail(1)) SWIG_fail;
17756 {
17757 if (!wxPyCheckForApp()) SWIG_fail;
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 result = (wxPaintDC *)new wxPaintDC(arg1);
17760
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17765 return resultobj;
17766 fail:
17767 return NULL;
17768 }
17769
17770
17771 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17772 PyObject *obj;
17773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17774 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17775 Py_INCREF(obj);
17776 return Py_BuildValue((char *)"");
17777 }
17778 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj;
17780 wxWindow *arg1 = (wxWindow *) 0 ;
17781 wxWindowDC *result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "win", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 if (!wxPyCheckForApp()) SWIG_fail;
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (wxWindowDC *)new wxWindowDC(arg1);
17794
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17806 PyObject *obj;
17807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17808 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17809 Py_INCREF(obj);
17810 return Py_BuildValue((char *)"");
17811 }
17812 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxDC *arg1 = 0 ;
17815 bool arg2 ;
17816 wxMirrorDC *result;
17817 PyObject * obj0 = 0 ;
17818 PyObject * obj1 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "dc",(char *) "mirror", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17824 {
17825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17826 if (SWIG_arg_fail(1)) SWIG_fail;
17827 if (arg1 == NULL) {
17828 SWIG_null_ref("wxDC");
17829 }
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 }
17832 {
17833 arg2 = (bool)(SWIG_As_bool(obj1));
17834 if (SWIG_arg_fail(2)) SWIG_fail;
17835 }
17836 {
17837 if (!wxPyCheckForApp()) SWIG_fail;
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17840
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17845 return resultobj;
17846 fail:
17847 return NULL;
17848 }
17849
17850
17851 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17852 PyObject *obj;
17853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17854 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17855 Py_INCREF(obj);
17856 return Py_BuildValue((char *)"");
17857 }
17858 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17859 PyObject *resultobj;
17860 wxPrintData *arg1 = 0 ;
17861 wxPostScriptDC *result;
17862 PyObject * obj0 = 0 ;
17863 char *kwnames[] = {
17864 (char *) "printData", NULL
17865 };
17866
17867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17868 {
17869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17870 if (SWIG_arg_fail(1)) SWIG_fail;
17871 if (arg1 == NULL) {
17872 SWIG_null_ref("wxPrintData");
17873 }
17874 if (SWIG_arg_fail(1)) SWIG_fail;
17875 }
17876 {
17877 if (!wxPyCheckForApp()) SWIG_fail;
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17880
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17885 return resultobj;
17886 fail:
17887 return NULL;
17888 }
17889
17890
17891 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17892 PyObject *resultobj;
17893 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17894 wxPrintData *result;
17895 PyObject * obj0 = 0 ;
17896 char *kwnames[] = {
17897 (char *) "self", NULL
17898 };
17899
17900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17902 if (SWIG_arg_fail(1)) SWIG_fail;
17903 {
17904 PyThreadState* __tstate = wxPyBeginAllowThreads();
17905 {
17906 wxPrintData &_result_ref = (arg1)->GetPrintData();
17907 result = (wxPrintData *) &_result_ref;
17908 }
17909
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17923 wxPrintData *arg2 = 0 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 char *kwnames[] = {
17927 (char *) "self",(char *) "data", NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17935 if (SWIG_arg_fail(2)) SWIG_fail;
17936 if (arg2 == NULL) {
17937 SWIG_null_ref("wxPrintData");
17938 }
17939 if (SWIG_arg_fail(2)) SWIG_fail;
17940 }
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 Py_INCREF(Py_None); resultobj = Py_None;
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj;
17957 int arg1 ;
17958 PyObject * obj0 = 0 ;
17959 char *kwnames[] = {
17960 (char *) "ppi", NULL
17961 };
17962
17963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17964 {
17965 arg1 = (int)(SWIG_As_int(obj0));
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 }
17968 {
17969 PyThreadState* __tstate = wxPyBeginAllowThreads();
17970 wxPostScriptDC::SetResolution(arg1);
17971
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 Py_INCREF(Py_None); resultobj = Py_None;
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj;
17984 int result;
17985 char *kwnames[] = {
17986 NULL
17987 };
17988
17989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (int)wxPostScriptDC::GetResolution();
17993
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 {
17998 resultobj = SWIG_From_int((int)(result));
17999 }
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18007 PyObject *obj;
18008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18009 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18010 Py_INCREF(obj);
18011 return Py_BuildValue((char *)"");
18012 }
18013 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18014 PyObject *resultobj;
18015 wxString const &arg1_defvalue = wxPyEmptyString ;
18016 wxString *arg1 = (wxString *) &arg1_defvalue ;
18017 wxMetaFile *result;
18018 bool temp1 = false ;
18019 PyObject * obj0 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "filename", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18025 if (obj0) {
18026 {
18027 arg1 = wxString_in_helper(obj0);
18028 if (arg1 == NULL) SWIG_fail;
18029 temp1 = true;
18030 }
18031 }
18032 {
18033 if (!wxPyCheckForApp()) SWIG_fail;
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18036
18037 wxPyEndAllowThreads(__tstate);
18038 if (PyErr_Occurred()) SWIG_fail;
18039 }
18040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18041 {
18042 if (temp1)
18043 delete arg1;
18044 }
18045 return resultobj;
18046 fail:
18047 {
18048 if (temp1)
18049 delete arg1;
18050 }
18051 return NULL;
18052 }
18053
18054
18055 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18056 PyObject *obj;
18057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18058 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18059 Py_INCREF(obj);
18060 return Py_BuildValue((char *)"");
18061 }
18062 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxString const &arg1_defvalue = wxPyEmptyString ;
18065 wxString *arg1 = (wxString *) &arg1_defvalue ;
18066 int arg2 = (int) 0 ;
18067 int arg3 = (int) 0 ;
18068 wxString const &arg4_defvalue = wxPyEmptyString ;
18069 wxString *arg4 = (wxString *) &arg4_defvalue ;
18070 wxMetaFileDC *result;
18071 bool temp1 = false ;
18072 bool temp4 = false ;
18073 PyObject * obj0 = 0 ;
18074 PyObject * obj1 = 0 ;
18075 PyObject * obj2 = 0 ;
18076 PyObject * obj3 = 0 ;
18077 char *kwnames[] = {
18078 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18079 };
18080
18081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18082 if (obj0) {
18083 {
18084 arg1 = wxString_in_helper(obj0);
18085 if (arg1 == NULL) SWIG_fail;
18086 temp1 = true;
18087 }
18088 }
18089 if (obj1) {
18090 {
18091 arg2 = (int)(SWIG_As_int(obj1));
18092 if (SWIG_arg_fail(2)) SWIG_fail;
18093 }
18094 }
18095 if (obj2) {
18096 {
18097 arg3 = (int)(SWIG_As_int(obj2));
18098 if (SWIG_arg_fail(3)) SWIG_fail;
18099 }
18100 }
18101 if (obj3) {
18102 {
18103 arg4 = wxString_in_helper(obj3);
18104 if (arg4 == NULL) SWIG_fail;
18105 temp4 = true;
18106 }
18107 }
18108 {
18109 if (!wxPyCheckForApp()) SWIG_fail;
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18112
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18117 {
18118 if (temp1)
18119 delete arg1;
18120 }
18121 {
18122 if (temp4)
18123 delete arg4;
18124 }
18125 return resultobj;
18126 fail:
18127 {
18128 if (temp1)
18129 delete arg1;
18130 }
18131 {
18132 if (temp4)
18133 delete arg4;
18134 }
18135 return NULL;
18136 }
18137
18138
18139 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18140 PyObject *obj;
18141 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18142 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18143 Py_INCREF(obj);
18144 return Py_BuildValue((char *)"");
18145 }
18146 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj;
18148 wxPrintData *arg1 = 0 ;
18149 wxPrinterDC *result;
18150 PyObject * obj0 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "printData", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18156 {
18157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18158 if (SWIG_arg_fail(1)) SWIG_fail;
18159 if (arg1 == NULL) {
18160 SWIG_null_ref("wxPrintData");
18161 }
18162 if (SWIG_arg_fail(1)) SWIG_fail;
18163 }
18164 {
18165 if (!wxPyCheckForApp()) SWIG_fail;
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18168
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18173 return resultobj;
18174 fail:
18175 return NULL;
18176 }
18177
18178
18179 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18180 PyObject *obj;
18181 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18182 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18183 Py_INCREF(obj);
18184 return Py_BuildValue((char *)"");
18185 }
18186 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 int arg1 ;
18189 int arg2 ;
18190 int arg3 = (int) true ;
18191 int arg4 = (int) 1 ;
18192 wxImageList *result;
18193 PyObject * obj0 = 0 ;
18194 PyObject * obj1 = 0 ;
18195 PyObject * obj2 = 0 ;
18196 PyObject * obj3 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18202 {
18203 arg1 = (int)(SWIG_As_int(obj0));
18204 if (SWIG_arg_fail(1)) SWIG_fail;
18205 }
18206 {
18207 arg2 = (int)(SWIG_As_int(obj1));
18208 if (SWIG_arg_fail(2)) SWIG_fail;
18209 }
18210 if (obj2) {
18211 {
18212 arg3 = (int)(SWIG_As_int(obj2));
18213 if (SWIG_arg_fail(3)) SWIG_fail;
18214 }
18215 }
18216 if (obj3) {
18217 {
18218 arg4 = (int)(SWIG_As_int(obj3));
18219 if (SWIG_arg_fail(4)) SWIG_fail;
18220 }
18221 }
18222 {
18223 if (!wxPyCheckForApp()) SWIG_fail;
18224 PyThreadState* __tstate = wxPyBeginAllowThreads();
18225 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18226
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 {
18231 resultobj = wxPyMake_wxObject(result, 1);
18232 }
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj;
18241 wxImageList *arg1 = (wxImageList *) 0 ;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 delete arg1;
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 Py_INCREF(Py_None); resultobj = Py_None;
18258 return resultobj;
18259 fail:
18260 return NULL;
18261 }
18262
18263
18264 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18265 PyObject *resultobj;
18266 wxImageList *arg1 = (wxImageList *) 0 ;
18267 wxBitmap *arg2 = 0 ;
18268 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18269 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18270 int result;
18271 PyObject * obj0 = 0 ;
18272 PyObject * obj1 = 0 ;
18273 PyObject * obj2 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 {
18282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18283 if (SWIG_arg_fail(2)) SWIG_fail;
18284 if (arg2 == NULL) {
18285 SWIG_null_ref("wxBitmap");
18286 }
18287 if (SWIG_arg_fail(2)) SWIG_fail;
18288 }
18289 if (obj2) {
18290 {
18291 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18292 if (SWIG_arg_fail(3)) SWIG_fail;
18293 if (arg3 == NULL) {
18294 SWIG_null_ref("wxBitmap");
18295 }
18296 if (SWIG_arg_fail(3)) SWIG_fail;
18297 }
18298 }
18299 {
18300 PyThreadState* __tstate = wxPyBeginAllowThreads();
18301 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18302
18303 wxPyEndAllowThreads(__tstate);
18304 if (PyErr_Occurred()) SWIG_fail;
18305 }
18306 {
18307 resultobj = SWIG_From_int((int)(result));
18308 }
18309 return resultobj;
18310 fail:
18311 return NULL;
18312 }
18313
18314
18315 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxImageList *arg1 = (wxImageList *) 0 ;
18318 wxBitmap *arg2 = 0 ;
18319 wxColour *arg3 = 0 ;
18320 int result;
18321 wxColour temp3 ;
18322 PyObject * obj0 = 0 ;
18323 PyObject * obj1 = 0 ;
18324 PyObject * obj2 = 0 ;
18325 char *kwnames[] = {
18326 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18327 };
18328
18329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18331 if (SWIG_arg_fail(1)) SWIG_fail;
18332 {
18333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18334 if (SWIG_arg_fail(2)) SWIG_fail;
18335 if (arg2 == NULL) {
18336 SWIG_null_ref("wxBitmap");
18337 }
18338 if (SWIG_arg_fail(2)) SWIG_fail;
18339 }
18340 {
18341 arg3 = &temp3;
18342 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18343 }
18344 {
18345 PyThreadState* __tstate = wxPyBeginAllowThreads();
18346 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18347
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 {
18352 resultobj = SWIG_From_int((int)(result));
18353 }
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj;
18362 wxImageList *arg1 = (wxImageList *) 0 ;
18363 wxIcon *arg2 = 0 ;
18364 int result;
18365 PyObject * obj0 = 0 ;
18366 PyObject * obj1 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self",(char *) "icon", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18376 if (SWIG_arg_fail(2)) SWIG_fail;
18377 if (arg2 == NULL) {
18378 SWIG_null_ref("wxIcon");
18379 }
18380 if (SWIG_arg_fail(2)) SWIG_fail;
18381 }
18382 {
18383 PyThreadState* __tstate = wxPyBeginAllowThreads();
18384 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18385
18386 wxPyEndAllowThreads(__tstate);
18387 if (PyErr_Occurred()) SWIG_fail;
18388 }
18389 {
18390 resultobj = SWIG_From_int((int)(result));
18391 }
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18399 PyObject *resultobj;
18400 wxImageList *arg1 = (wxImageList *) 0 ;
18401 int arg2 ;
18402 SwigValueWrapper<wxBitmap > result;
18403 PyObject * obj0 = 0 ;
18404 PyObject * obj1 = 0 ;
18405 char *kwnames[] = {
18406 (char *) "self",(char *) "index", NULL
18407 };
18408
18409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18411 if (SWIG_arg_fail(1)) SWIG_fail;
18412 {
18413 arg2 = (int)(SWIG_As_int(obj1));
18414 if (SWIG_arg_fail(2)) SWIG_fail;
18415 }
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18419
18420 wxPyEndAllowThreads(__tstate);
18421 if (PyErr_Occurred()) SWIG_fail;
18422 }
18423 {
18424 wxBitmap * resultptr;
18425 resultptr = new wxBitmap((wxBitmap &)(result));
18426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18427 }
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj;
18436 wxImageList *arg1 = (wxImageList *) 0 ;
18437 int arg2 ;
18438 wxIcon result;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "self",(char *) "index", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18447 if (SWIG_arg_fail(1)) SWIG_fail;
18448 {
18449 arg2 = (int)(SWIG_As_int(obj1));
18450 if (SWIG_arg_fail(2)) SWIG_fail;
18451 }
18452 {
18453 PyThreadState* __tstate = wxPyBeginAllowThreads();
18454 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18455
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 {
18460 wxIcon * resultptr;
18461 resultptr = new wxIcon((wxIcon &)(result));
18462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18463 }
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18471 PyObject *resultobj;
18472 wxImageList *arg1 = (wxImageList *) 0 ;
18473 int arg2 ;
18474 wxBitmap *arg3 = 0 ;
18475 bool result;
18476 PyObject * obj0 = 0 ;
18477 PyObject * obj1 = 0 ;
18478 PyObject * obj2 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 arg2 = (int)(SWIG_As_int(obj1));
18488 if (SWIG_arg_fail(2)) SWIG_fail;
18489 }
18490 {
18491 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18492 if (SWIG_arg_fail(3)) SWIG_fail;
18493 if (arg3 == NULL) {
18494 SWIG_null_ref("wxBitmap");
18495 }
18496 if (SWIG_arg_fail(3)) SWIG_fail;
18497 }
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18501
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 {
18506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18507 }
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj;
18516 wxImageList *arg1 = (wxImageList *) 0 ;
18517 int arg2 ;
18518 wxDC *arg3 = 0 ;
18519 int arg4 ;
18520 int arg5 ;
18521 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18522 bool arg7 = (bool) (bool)false ;
18523 bool result;
18524 PyObject * obj0 = 0 ;
18525 PyObject * obj1 = 0 ;
18526 PyObject * obj2 = 0 ;
18527 PyObject * obj3 = 0 ;
18528 PyObject * obj4 = 0 ;
18529 PyObject * obj5 = 0 ;
18530 PyObject * obj6 = 0 ;
18531 char *kwnames[] = {
18532 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18533 };
18534
18535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18537 if (SWIG_arg_fail(1)) SWIG_fail;
18538 {
18539 arg2 = (int)(SWIG_As_int(obj1));
18540 if (SWIG_arg_fail(2)) SWIG_fail;
18541 }
18542 {
18543 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18544 if (SWIG_arg_fail(3)) SWIG_fail;
18545 if (arg3 == NULL) {
18546 SWIG_null_ref("wxDC");
18547 }
18548 if (SWIG_arg_fail(3)) SWIG_fail;
18549 }
18550 {
18551 arg4 = (int)(SWIG_As_int(obj3));
18552 if (SWIG_arg_fail(4)) SWIG_fail;
18553 }
18554 {
18555 arg5 = (int)(SWIG_As_int(obj4));
18556 if (SWIG_arg_fail(5)) SWIG_fail;
18557 }
18558 if (obj5) {
18559 {
18560 arg6 = (int)(SWIG_As_int(obj5));
18561 if (SWIG_arg_fail(6)) SWIG_fail;
18562 }
18563 }
18564 if (obj6) {
18565 {
18566 arg7 = (bool const)(SWIG_As_bool(obj6));
18567 if (SWIG_arg_fail(7)) SWIG_fail;
18568 }
18569 }
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxImageList *arg1 = (wxImageList *) 0 ;
18589 int result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "self", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18597 if (SWIG_arg_fail(1)) SWIG_fail;
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (int)(arg1)->GetImageCount();
18601
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 {
18606 resultobj = SWIG_From_int((int)(result));
18607 }
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxImageList *arg1 = (wxImageList *) 0 ;
18617 int arg2 ;
18618 bool result;
18619 PyObject * obj0 = 0 ;
18620 PyObject * obj1 = 0 ;
18621 char *kwnames[] = {
18622 (char *) "self",(char *) "index", NULL
18623 };
18624
18625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
18630 if (SWIG_arg_fail(2)) SWIG_fail;
18631 }
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 result = (bool)(arg1)->Remove(arg2);
18635
18636 wxPyEndAllowThreads(__tstate);
18637 if (PyErr_Occurred()) SWIG_fail;
18638 }
18639 {
18640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18641 }
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj;
18650 wxImageList *arg1 = (wxImageList *) 0 ;
18651 bool result;
18652 PyObject * obj0 = 0 ;
18653 char *kwnames[] = {
18654 (char *) "self", NULL
18655 };
18656
18657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18659 if (SWIG_arg_fail(1)) SWIG_fail;
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 result = (bool)(arg1)->RemoveAll();
18663
18664 wxPyEndAllowThreads(__tstate);
18665 if (PyErr_Occurred()) SWIG_fail;
18666 }
18667 {
18668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18669 }
18670 return resultobj;
18671 fail:
18672 return NULL;
18673 }
18674
18675
18676 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18677 PyObject *resultobj;
18678 wxImageList *arg1 = (wxImageList *) 0 ;
18679 int arg2 ;
18680 int *arg3 = 0 ;
18681 int *arg4 = 0 ;
18682 int temp3 ;
18683 int res3 = 0 ;
18684 int temp4 ;
18685 int res4 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 char *kwnames[] = {
18689 (char *) "self",(char *) "index", NULL
18690 };
18691
18692 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18693 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18696 if (SWIG_arg_fail(1)) SWIG_fail;
18697 {
18698 arg2 = (int)(SWIG_As_int(obj1));
18699 if (SWIG_arg_fail(2)) SWIG_fail;
18700 }
18701 {
18702 PyThreadState* __tstate = wxPyBeginAllowThreads();
18703 (arg1)->GetSize(arg2,*arg3,*arg4);
18704
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 Py_INCREF(Py_None); resultobj = Py_None;
18709 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18710 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18711 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18712 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18720 PyObject *obj;
18721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18722 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18723 Py_INCREF(obj);
18724 return Py_BuildValue((char *)"");
18725 }
18726 static int _wrap_NORMAL_FONT_set(PyObject *) {
18727 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18728 return 1;
18729 }
18730
18731
18732 static PyObject *_wrap_NORMAL_FONT_get(void) {
18733 PyObject *pyobj;
18734
18735 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18736 return pyobj;
18737 }
18738
18739
18740 static int _wrap_SMALL_FONT_set(PyObject *) {
18741 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18742 return 1;
18743 }
18744
18745
18746 static PyObject *_wrap_SMALL_FONT_get(void) {
18747 PyObject *pyobj;
18748
18749 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18750 return pyobj;
18751 }
18752
18753
18754 static int _wrap_ITALIC_FONT_set(PyObject *) {
18755 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18756 return 1;
18757 }
18758
18759
18760 static PyObject *_wrap_ITALIC_FONT_get(void) {
18761 PyObject *pyobj;
18762
18763 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18764 return pyobj;
18765 }
18766
18767
18768 static int _wrap_SWISS_FONT_set(PyObject *) {
18769 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18770 return 1;
18771 }
18772
18773
18774 static PyObject *_wrap_SWISS_FONT_get(void) {
18775 PyObject *pyobj;
18776
18777 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18778 return pyobj;
18779 }
18780
18781
18782 static int _wrap_RED_PEN_set(PyObject *) {
18783 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18784 return 1;
18785 }
18786
18787
18788 static PyObject *_wrap_RED_PEN_get(void) {
18789 PyObject *pyobj;
18790
18791 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18792 return pyobj;
18793 }
18794
18795
18796 static int _wrap_CYAN_PEN_set(PyObject *) {
18797 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18798 return 1;
18799 }
18800
18801
18802 static PyObject *_wrap_CYAN_PEN_get(void) {
18803 PyObject *pyobj;
18804
18805 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18806 return pyobj;
18807 }
18808
18809
18810 static int _wrap_GREEN_PEN_set(PyObject *) {
18811 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18812 return 1;
18813 }
18814
18815
18816 static PyObject *_wrap_GREEN_PEN_get(void) {
18817 PyObject *pyobj;
18818
18819 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18820 return pyobj;
18821 }
18822
18823
18824 static int _wrap_BLACK_PEN_set(PyObject *) {
18825 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18826 return 1;
18827 }
18828
18829
18830 static PyObject *_wrap_BLACK_PEN_get(void) {
18831 PyObject *pyobj;
18832
18833 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18834 return pyobj;
18835 }
18836
18837
18838 static int _wrap_WHITE_PEN_set(PyObject *) {
18839 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18840 return 1;
18841 }
18842
18843
18844 static PyObject *_wrap_WHITE_PEN_get(void) {
18845 PyObject *pyobj;
18846
18847 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18848 return pyobj;
18849 }
18850
18851
18852 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18853 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18854 return 1;
18855 }
18856
18857
18858 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18859 PyObject *pyobj;
18860
18861 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18862 return pyobj;
18863 }
18864
18865
18866 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18867 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18868 return 1;
18869 }
18870
18871
18872 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18873 PyObject *pyobj;
18874
18875 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18876 return pyobj;
18877 }
18878
18879
18880 static int _wrap_GREY_PEN_set(PyObject *) {
18881 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18882 return 1;
18883 }
18884
18885
18886 static PyObject *_wrap_GREY_PEN_get(void) {
18887 PyObject *pyobj;
18888
18889 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18890 return pyobj;
18891 }
18892
18893
18894 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18895 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18896 return 1;
18897 }
18898
18899
18900 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18901 PyObject *pyobj;
18902
18903 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18904 return pyobj;
18905 }
18906
18907
18908 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18909 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18910 return 1;
18911 }
18912
18913
18914 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18915 PyObject *pyobj;
18916
18917 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18918 return pyobj;
18919 }
18920
18921
18922 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18923 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18924 return 1;
18925 }
18926
18927
18928 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18929 PyObject *pyobj;
18930
18931 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18932 return pyobj;
18933 }
18934
18935
18936 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18937 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18938 return 1;
18939 }
18940
18941
18942 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18943 PyObject *pyobj;
18944
18945 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18946 return pyobj;
18947 }
18948
18949
18950 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18951 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18952 return 1;
18953 }
18954
18955
18956 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18957 PyObject *pyobj;
18958
18959 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18960 return pyobj;
18961 }
18962
18963
18964 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18965 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18966 return 1;
18967 }
18968
18969
18970 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18971 PyObject *pyobj;
18972
18973 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18974 return pyobj;
18975 }
18976
18977
18978 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18979 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18980 return 1;
18981 }
18982
18983
18984 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18985 PyObject *pyobj;
18986
18987 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18988 return pyobj;
18989 }
18990
18991
18992 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18993 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18994 return 1;
18995 }
18996
18997
18998 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18999 PyObject *pyobj;
19000
19001 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19002 return pyobj;
19003 }
19004
19005
19006 static int _wrap_RED_BRUSH_set(PyObject *) {
19007 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19008 return 1;
19009 }
19010
19011
19012 static PyObject *_wrap_RED_BRUSH_get(void) {
19013 PyObject *pyobj;
19014
19015 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19016 return pyobj;
19017 }
19018
19019
19020 static int _wrap_GREY_BRUSH_set(PyObject *) {
19021 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19022 return 1;
19023 }
19024
19025
19026 static PyObject *_wrap_GREY_BRUSH_get(void) {
19027 PyObject *pyobj;
19028
19029 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19030 return pyobj;
19031 }
19032
19033
19034 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19035 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19036 return 1;
19037 }
19038
19039
19040 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19041 PyObject *pyobj;
19042
19043 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19044 return pyobj;
19045 }
19046
19047
19048 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19049 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19050 return 1;
19051 }
19052
19053
19054 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19055 PyObject *pyobj;
19056
19057 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19058 return pyobj;
19059 }
19060
19061
19062 static int _wrap_BLACK_set(PyObject *) {
19063 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19064 return 1;
19065 }
19066
19067
19068 static PyObject *_wrap_BLACK_get(void) {
19069 PyObject *pyobj;
19070
19071 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19072 return pyobj;
19073 }
19074
19075
19076 static int _wrap_WHITE_set(PyObject *) {
19077 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19078 return 1;
19079 }
19080
19081
19082 static PyObject *_wrap_WHITE_get(void) {
19083 PyObject *pyobj;
19084
19085 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19086 return pyobj;
19087 }
19088
19089
19090 static int _wrap_RED_set(PyObject *) {
19091 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19092 return 1;
19093 }
19094
19095
19096 static PyObject *_wrap_RED_get(void) {
19097 PyObject *pyobj;
19098
19099 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19100 return pyobj;
19101 }
19102
19103
19104 static int _wrap_BLUE_set(PyObject *) {
19105 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19106 return 1;
19107 }
19108
19109
19110 static PyObject *_wrap_BLUE_get(void) {
19111 PyObject *pyobj;
19112
19113 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19114 return pyobj;
19115 }
19116
19117
19118 static int _wrap_GREEN_set(PyObject *) {
19119 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19120 return 1;
19121 }
19122
19123
19124 static PyObject *_wrap_GREEN_get(void) {
19125 PyObject *pyobj;
19126
19127 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19128 return pyobj;
19129 }
19130
19131
19132 static int _wrap_CYAN_set(PyObject *) {
19133 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19134 return 1;
19135 }
19136
19137
19138 static PyObject *_wrap_CYAN_get(void) {
19139 PyObject *pyobj;
19140
19141 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19142 return pyobj;
19143 }
19144
19145
19146 static int _wrap_LIGHT_GREY_set(PyObject *) {
19147 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19148 return 1;
19149 }
19150
19151
19152 static PyObject *_wrap_LIGHT_GREY_get(void) {
19153 PyObject *pyobj;
19154
19155 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19156 return pyobj;
19157 }
19158
19159
19160 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19161 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19162 return 1;
19163 }
19164
19165
19166 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19167 PyObject *pyobj;
19168
19169 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19170 return pyobj;
19171 }
19172
19173
19174 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19175 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19176 return 1;
19177 }
19178
19179
19180 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19181 PyObject *pyobj;
19182
19183 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19184 return pyobj;
19185 }
19186
19187
19188 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19189 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19190 return 1;
19191 }
19192
19193
19194 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19195 PyObject *pyobj;
19196
19197 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19198 return pyobj;
19199 }
19200
19201
19202 static int _wrap_NullBitmap_set(PyObject *) {
19203 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19204 return 1;
19205 }
19206
19207
19208 static PyObject *_wrap_NullBitmap_get(void) {
19209 PyObject *pyobj;
19210
19211 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19212 return pyobj;
19213 }
19214
19215
19216 static int _wrap_NullIcon_set(PyObject *) {
19217 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19218 return 1;
19219 }
19220
19221
19222 static PyObject *_wrap_NullIcon_get(void) {
19223 PyObject *pyobj;
19224
19225 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19226 return pyobj;
19227 }
19228
19229
19230 static int _wrap_NullCursor_set(PyObject *) {
19231 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19232 return 1;
19233 }
19234
19235
19236 static PyObject *_wrap_NullCursor_get(void) {
19237 PyObject *pyobj;
19238
19239 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19240 return pyobj;
19241 }
19242
19243
19244 static int _wrap_NullPen_set(PyObject *) {
19245 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19246 return 1;
19247 }
19248
19249
19250 static PyObject *_wrap_NullPen_get(void) {
19251 PyObject *pyobj;
19252
19253 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19254 return pyobj;
19255 }
19256
19257
19258 static int _wrap_NullBrush_set(PyObject *) {
19259 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19260 return 1;
19261 }
19262
19263
19264 static PyObject *_wrap_NullBrush_get(void) {
19265 PyObject *pyobj;
19266
19267 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19268 return pyobj;
19269 }
19270
19271
19272 static int _wrap_NullPalette_set(PyObject *) {
19273 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19274 return 1;
19275 }
19276
19277
19278 static PyObject *_wrap_NullPalette_get(void) {
19279 PyObject *pyobj;
19280
19281 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19282 return pyobj;
19283 }
19284
19285
19286 static int _wrap_NullFont_set(PyObject *) {
19287 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19288 return 1;
19289 }
19290
19291
19292 static PyObject *_wrap_NullFont_get(void) {
19293 PyObject *pyobj;
19294
19295 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19296 return pyobj;
19297 }
19298
19299
19300 static int _wrap_NullColour_set(PyObject *) {
19301 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19302 return 1;
19303 }
19304
19305
19306 static PyObject *_wrap_NullColour_get(void) {
19307 PyObject *pyobj;
19308
19309 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19310 return pyobj;
19311 }
19312
19313
19314 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj;
19316 wxPenList *arg1 = (wxPenList *) 0 ;
19317 wxPen *arg2 = (wxPen *) 0 ;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 char *kwnames[] = {
19321 (char *) "self",(char *) "pen", NULL
19322 };
19323
19324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19326 if (SWIG_arg_fail(1)) SWIG_fail;
19327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19328 if (SWIG_arg_fail(2)) SWIG_fail;
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 (arg1)->AddPen(arg2);
19332
19333 wxPyEndAllowThreads(__tstate);
19334 if (PyErr_Occurred()) SWIG_fail;
19335 }
19336 Py_INCREF(Py_None); resultobj = Py_None;
19337 return resultobj;
19338 fail:
19339 return NULL;
19340 }
19341
19342
19343 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19344 PyObject *resultobj;
19345 wxPenList *arg1 = (wxPenList *) 0 ;
19346 wxColour *arg2 = 0 ;
19347 int arg3 ;
19348 int arg4 ;
19349 wxPen *result;
19350 wxColour temp2 ;
19351 PyObject * obj0 = 0 ;
19352 PyObject * obj1 = 0 ;
19353 PyObject * obj2 = 0 ;
19354 PyObject * obj3 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19361 if (SWIG_arg_fail(1)) SWIG_fail;
19362 {
19363 arg2 = &temp2;
19364 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19365 }
19366 {
19367 arg3 = (int)(SWIG_As_int(obj2));
19368 if (SWIG_arg_fail(3)) SWIG_fail;
19369 }
19370 {
19371 arg4 = (int)(SWIG_As_int(obj3));
19372 if (SWIG_arg_fail(4)) SWIG_fail;
19373 }
19374 {
19375 PyThreadState* __tstate = wxPyBeginAllowThreads();
19376 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19377
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj;
19390 wxPenList *arg1 = (wxPenList *) 0 ;
19391 wxPen *arg2 = (wxPen *) 0 ;
19392 PyObject * obj0 = 0 ;
19393 PyObject * obj1 = 0 ;
19394 char *kwnames[] = {
19395 (char *) "self",(char *) "pen", NULL
19396 };
19397
19398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19400 if (SWIG_arg_fail(1)) SWIG_fail;
19401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 (arg1)->RemovePen(arg2);
19406
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 Py_INCREF(Py_None); resultobj = Py_None;
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj;
19419 wxPenList *arg1 = (wxPenList *) 0 ;
19420 int result;
19421 PyObject * obj0 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "self", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19428 if (SWIG_arg_fail(1)) SWIG_fail;
19429 {
19430 PyThreadState* __tstate = wxPyBeginAllowThreads();
19431 result = (int)(arg1)->GetCount();
19432
19433 wxPyEndAllowThreads(__tstate);
19434 if (PyErr_Occurred()) SWIG_fail;
19435 }
19436 {
19437 resultobj = SWIG_From_int((int)(result));
19438 }
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19446 PyObject *obj;
19447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19448 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19449 Py_INCREF(obj);
19450 return Py_BuildValue((char *)"");
19451 }
19452 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj;
19454 wxBrushList *arg1 = (wxBrushList *) 0 ;
19455 wxBrush *arg2 = (wxBrush *) 0 ;
19456 PyObject * obj0 = 0 ;
19457 PyObject * obj1 = 0 ;
19458 char *kwnames[] = {
19459 (char *) "self",(char *) "brush", NULL
19460 };
19461
19462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19464 if (SWIG_arg_fail(1)) SWIG_fail;
19465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19466 if (SWIG_arg_fail(2)) SWIG_fail;
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 (arg1)->AddBrush(arg2);
19470
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 Py_INCREF(Py_None); resultobj = Py_None;
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 wxBrushList *arg1 = (wxBrushList *) 0 ;
19484 wxColour *arg2 = 0 ;
19485 int arg3 = (int) wxSOLID ;
19486 wxBrush *result;
19487 wxColour temp2 ;
19488 PyObject * obj0 = 0 ;
19489 PyObject * obj1 = 0 ;
19490 PyObject * obj2 = 0 ;
19491 char *kwnames[] = {
19492 (char *) "self",(char *) "colour",(char *) "style", NULL
19493 };
19494
19495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19497 if (SWIG_arg_fail(1)) SWIG_fail;
19498 {
19499 arg2 = &temp2;
19500 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19501 }
19502 if (obj2) {
19503 {
19504 arg3 = (int)(SWIG_As_int(obj2));
19505 if (SWIG_arg_fail(3)) SWIG_fail;
19506 }
19507 }
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19523 PyObject *resultobj;
19524 wxBrushList *arg1 = (wxBrushList *) 0 ;
19525 wxBrush *arg2 = (wxBrush *) 0 ;
19526 PyObject * obj0 = 0 ;
19527 PyObject * obj1 = 0 ;
19528 char *kwnames[] = {
19529 (char *) "self",(char *) "brush", NULL
19530 };
19531
19532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19534 if (SWIG_arg_fail(1)) SWIG_fail;
19535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19536 if (SWIG_arg_fail(2)) SWIG_fail;
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 (arg1)->RemoveBrush(arg2);
19540
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 Py_INCREF(Py_None); resultobj = Py_None;
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19552 PyObject *resultobj;
19553 wxBrushList *arg1 = (wxBrushList *) 0 ;
19554 int result;
19555 PyObject * obj0 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "self", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = (int)(arg1)->GetCount();
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 {
19571 resultobj = SWIG_From_int((int)(result));
19572 }
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19580 PyObject *obj;
19581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19582 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19583 Py_INCREF(obj);
19584 return Py_BuildValue((char *)"");
19585 }
19586 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 wxColourDatabase *result;
19589 char *kwnames[] = {
19590 NULL
19591 };
19592
19593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19594 {
19595 if (!wxPyCheckForApp()) SWIG_fail;
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (wxColourDatabase *)new wxColourDatabase();
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19610 PyObject *resultobj;
19611 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19612 PyObject * obj0 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "self", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 delete arg1;
19623
19624 wxPyEndAllowThreads(__tstate);
19625 if (PyErr_Occurred()) SWIG_fail;
19626 }
19627 Py_INCREF(Py_None); resultobj = Py_None;
19628 return resultobj;
19629 fail:
19630 return NULL;
19631 }
19632
19633
19634 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19635 PyObject *resultobj;
19636 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19637 wxString *arg2 = 0 ;
19638 wxColour result;
19639 bool temp2 = false ;
19640 PyObject * obj0 = 0 ;
19641 PyObject * obj1 = 0 ;
19642 char *kwnames[] = {
19643 (char *) "self",(char *) "name", NULL
19644 };
19645
19646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 {
19650 arg2 = wxString_in_helper(obj1);
19651 if (arg2 == NULL) SWIG_fail;
19652 temp2 = true;
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19657
19658 wxPyEndAllowThreads(__tstate);
19659 if (PyErr_Occurred()) SWIG_fail;
19660 }
19661 {
19662 wxColour * resultptr;
19663 resultptr = new wxColour((wxColour &)(result));
19664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19665 }
19666 {
19667 if (temp2)
19668 delete arg2;
19669 }
19670 return resultobj;
19671 fail:
19672 {
19673 if (temp2)
19674 delete arg2;
19675 }
19676 return NULL;
19677 }
19678
19679
19680 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19681 PyObject *resultobj;
19682 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19683 wxColour *arg2 = 0 ;
19684 wxString result;
19685 wxColour temp2 ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "self",(char *) "colour", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19694 if (SWIG_arg_fail(1)) SWIG_fail;
19695 {
19696 arg2 = &temp2;
19697 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19698 }
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19702
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 {
19707 #if wxUSE_UNICODE
19708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19709 #else
19710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19711 #endif
19712 }
19713 return resultobj;
19714 fail:
19715 return NULL;
19716 }
19717
19718
19719 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19720 PyObject *resultobj;
19721 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19722 wxString *arg2 = 0 ;
19723 wxColour *arg3 = 0 ;
19724 bool temp2 = false ;
19725 wxColour temp3 ;
19726 PyObject * obj0 = 0 ;
19727 PyObject * obj1 = 0 ;
19728 PyObject * obj2 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "self",(char *) "name",(char *) "colour", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19735 if (SWIG_arg_fail(1)) SWIG_fail;
19736 {
19737 arg2 = wxString_in_helper(obj1);
19738 if (arg2 == NULL) SWIG_fail;
19739 temp2 = true;
19740 }
19741 {
19742 arg3 = &temp3;
19743 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 Py_INCREF(Py_None); resultobj = Py_None;
19753 {
19754 if (temp2)
19755 delete arg2;
19756 }
19757 return resultobj;
19758 fail:
19759 {
19760 if (temp2)
19761 delete arg2;
19762 }
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj;
19769 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19770 wxString *arg2 = 0 ;
19771 int arg3 ;
19772 int arg4 ;
19773 int arg5 ;
19774 bool temp2 = false ;
19775 PyObject * obj0 = 0 ;
19776 PyObject * obj1 = 0 ;
19777 PyObject * obj2 = 0 ;
19778 PyObject * obj3 = 0 ;
19779 PyObject * obj4 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 {
19788 arg2 = wxString_in_helper(obj1);
19789 if (arg2 == NULL) SWIG_fail;
19790 temp2 = true;
19791 }
19792 {
19793 arg3 = (int)(SWIG_As_int(obj2));
19794 if (SWIG_arg_fail(3)) SWIG_fail;
19795 }
19796 {
19797 arg4 = (int)(SWIG_As_int(obj3));
19798 if (SWIG_arg_fail(4)) SWIG_fail;
19799 }
19800 {
19801 arg5 = (int)(SWIG_As_int(obj4));
19802 if (SWIG_arg_fail(5)) SWIG_fail;
19803 }
19804 {
19805 PyThreadState* __tstate = wxPyBeginAllowThreads();
19806 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19807
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 Py_INCREF(Py_None); resultobj = Py_None;
19812 {
19813 if (temp2)
19814 delete arg2;
19815 }
19816 return resultobj;
19817 fail:
19818 {
19819 if (temp2)
19820 delete arg2;
19821 }
19822 return NULL;
19823 }
19824
19825
19826 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19827 PyObject *obj;
19828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19829 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19830 Py_INCREF(obj);
19831 return Py_BuildValue((char *)"");
19832 }
19833 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19834 PyObject *resultobj;
19835 wxFontList *arg1 = (wxFontList *) 0 ;
19836 wxFont *arg2 = (wxFont *) 0 ;
19837 PyObject * obj0 = 0 ;
19838 PyObject * obj1 = 0 ;
19839 char *kwnames[] = {
19840 (char *) "self",(char *) "font", NULL
19841 };
19842
19843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19845 if (SWIG_arg_fail(1)) SWIG_fail;
19846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19847 if (SWIG_arg_fail(2)) SWIG_fail;
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 (arg1)->AddFont(arg2);
19851
19852 wxPyEndAllowThreads(__tstate);
19853 if (PyErr_Occurred()) SWIG_fail;
19854 }
19855 Py_INCREF(Py_None); resultobj = Py_None;
19856 return resultobj;
19857 fail:
19858 return NULL;
19859 }
19860
19861
19862 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19863 PyObject *resultobj;
19864 wxFontList *arg1 = (wxFontList *) 0 ;
19865 int arg2 ;
19866 int arg3 ;
19867 int arg4 ;
19868 int arg5 ;
19869 bool arg6 = (bool) false ;
19870 wxString const &arg7_defvalue = wxPyEmptyString ;
19871 wxString *arg7 = (wxString *) &arg7_defvalue ;
19872 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19873 wxFont *result;
19874 bool temp7 = false ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 PyObject * obj2 = 0 ;
19878 PyObject * obj3 = 0 ;
19879 PyObject * obj4 = 0 ;
19880 PyObject * obj5 = 0 ;
19881 PyObject * obj6 = 0 ;
19882 PyObject * obj7 = 0 ;
19883 char *kwnames[] = {
19884 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19885 };
19886
19887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19889 if (SWIG_arg_fail(1)) SWIG_fail;
19890 {
19891 arg2 = (int)(SWIG_As_int(obj1));
19892 if (SWIG_arg_fail(2)) SWIG_fail;
19893 }
19894 {
19895 arg3 = (int)(SWIG_As_int(obj2));
19896 if (SWIG_arg_fail(3)) SWIG_fail;
19897 }
19898 {
19899 arg4 = (int)(SWIG_As_int(obj3));
19900 if (SWIG_arg_fail(4)) SWIG_fail;
19901 }
19902 {
19903 arg5 = (int)(SWIG_As_int(obj4));
19904 if (SWIG_arg_fail(5)) SWIG_fail;
19905 }
19906 if (obj5) {
19907 {
19908 arg6 = (bool)(SWIG_As_bool(obj5));
19909 if (SWIG_arg_fail(6)) SWIG_fail;
19910 }
19911 }
19912 if (obj6) {
19913 {
19914 arg7 = wxString_in_helper(obj6);
19915 if (arg7 == NULL) SWIG_fail;
19916 temp7 = true;
19917 }
19918 }
19919 if (obj7) {
19920 {
19921 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19922 if (SWIG_arg_fail(8)) SWIG_fail;
19923 }
19924 }
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19928
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19933 {
19934 if (temp7)
19935 delete arg7;
19936 }
19937 return resultobj;
19938 fail:
19939 {
19940 if (temp7)
19941 delete arg7;
19942 }
19943 return NULL;
19944 }
19945
19946
19947 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj;
19949 wxFontList *arg1 = (wxFontList *) 0 ;
19950 wxFont *arg2 = (wxFont *) 0 ;
19951 PyObject * obj0 = 0 ;
19952 PyObject * obj1 = 0 ;
19953 char *kwnames[] = {
19954 (char *) "self",(char *) "font", NULL
19955 };
19956
19957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19959 if (SWIG_arg_fail(1)) SWIG_fail;
19960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19961 if (SWIG_arg_fail(2)) SWIG_fail;
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 (arg1)->RemoveFont(arg2);
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 Py_INCREF(Py_None); resultobj = Py_None;
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxFontList *arg1 = (wxFontList *) 0 ;
19979 int result;
19980 PyObject * obj0 = 0 ;
19981 char *kwnames[] = {
19982 (char *) "self", NULL
19983 };
19984
19985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19987 if (SWIG_arg_fail(1)) SWIG_fail;
19988 {
19989 PyThreadState* __tstate = wxPyBeginAllowThreads();
19990 result = (int)(arg1)->GetCount();
19991
19992 wxPyEndAllowThreads(__tstate);
19993 if (PyErr_Occurred()) SWIG_fail;
19994 }
19995 {
19996 resultobj = SWIG_From_int((int)(result));
19997 }
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20005 PyObject *obj;
20006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20007 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20008 Py_INCREF(obj);
20009 return Py_BuildValue((char *)"");
20010 }
20011 static int _wrap_TheFontList_set(PyObject *) {
20012 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20013 return 1;
20014 }
20015
20016
20017 static PyObject *_wrap_TheFontList_get(void) {
20018 PyObject *pyobj;
20019
20020 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20021 return pyobj;
20022 }
20023
20024
20025 static int _wrap_ThePenList_set(PyObject *) {
20026 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20027 return 1;
20028 }
20029
20030
20031 static PyObject *_wrap_ThePenList_get(void) {
20032 PyObject *pyobj;
20033
20034 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20035 return pyobj;
20036 }
20037
20038
20039 static int _wrap_TheBrushList_set(PyObject *) {
20040 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20041 return 1;
20042 }
20043
20044
20045 static PyObject *_wrap_TheBrushList_get(void) {
20046 PyObject *pyobj;
20047
20048 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20049 return pyobj;
20050 }
20051
20052
20053 static int _wrap_TheColourDatabase_set(PyObject *) {
20054 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20055 return 1;
20056 }
20057
20058
20059 static PyObject *_wrap_TheColourDatabase_get(void) {
20060 PyObject *pyobj;
20061
20062 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20063 return pyobj;
20064 }
20065
20066
20067 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 wxEffects *result;
20070 char *kwnames[] = {
20071 NULL
20072 };
20073
20074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (wxEffects *)new wxEffects();
20078
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20090 PyObject *resultobj;
20091 wxEffects *arg1 = (wxEffects *) 0 ;
20092 wxColour result;
20093 PyObject * obj0 = 0 ;
20094 char *kwnames[] = {
20095 (char *) "self", NULL
20096 };
20097
20098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20100 if (SWIG_arg_fail(1)) SWIG_fail;
20101 {
20102 PyThreadState* __tstate = wxPyBeginAllowThreads();
20103 result = ((wxEffects const *)arg1)->GetHighlightColour();
20104
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 wxColour * resultptr;
20110 resultptr = new wxColour((wxColour &)(result));
20111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20112 }
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 static PyObject *_wrap_Effects_GetLightShadow(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_GetLightShadow",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)->GetLightShadow();
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_GetFaceColour(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_GetFaceColour",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)->GetFaceColour();
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_GetMediumShadow(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_GetMediumShadow",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)->GetMediumShadow();
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_GetDarkShadow(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_GetDarkShadow",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)->GetDarkShadow();
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_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxEffects *arg1 = (wxEffects *) 0 ;
20242 wxColour *arg2 = 0 ;
20243 wxColour temp2 ;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self",(char *) "c", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 arg2 = &temp2;
20255 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20260
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 Py_INCREF(Py_None); resultobj = Py_None;
20265 return resultobj;
20266 fail:
20267 return NULL;
20268 }
20269
20270
20271 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20272 PyObject *resultobj;
20273 wxEffects *arg1 = (wxEffects *) 0 ;
20274 wxColour *arg2 = 0 ;
20275 wxColour temp2 ;
20276 PyObject * obj0 = 0 ;
20277 PyObject * obj1 = 0 ;
20278 char *kwnames[] = {
20279 (char *) "self",(char *) "c", NULL
20280 };
20281
20282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20284 if (SWIG_arg_fail(1)) SWIG_fail;
20285 {
20286 arg2 = &temp2;
20287 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20288 }
20289 {
20290 PyThreadState* __tstate = wxPyBeginAllowThreads();
20291 (arg1)->SetLightShadow((wxColour const &)*arg2);
20292
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 Py_INCREF(Py_None); resultobj = Py_None;
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj;
20305 wxEffects *arg1 = (wxEffects *) 0 ;
20306 wxColour *arg2 = 0 ;
20307 wxColour temp2 ;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "c", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = &temp2;
20319 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20320 }
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 (arg1)->SetFaceColour((wxColour const &)*arg2);
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 Py_INCREF(Py_None); resultobj = Py_None;
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj;
20337 wxEffects *arg1 = (wxEffects *) 0 ;
20338 wxColour *arg2 = 0 ;
20339 wxColour temp2 ;
20340 PyObject * obj0 = 0 ;
20341 PyObject * obj1 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self",(char *) "c", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 arg2 = &temp2;
20351 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20352 }
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20356
20357 wxPyEndAllowThreads(__tstate);
20358 if (PyErr_Occurred()) SWIG_fail;
20359 }
20360 Py_INCREF(Py_None); resultobj = Py_None;
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj;
20369 wxEffects *arg1 = (wxEffects *) 0 ;
20370 wxColour *arg2 = 0 ;
20371 wxColour temp2 ;
20372 PyObject * obj0 = 0 ;
20373 PyObject * obj1 = 0 ;
20374 char *kwnames[] = {
20375 (char *) "self",(char *) "c", NULL
20376 };
20377
20378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20380 if (SWIG_arg_fail(1)) SWIG_fail;
20381 {
20382 arg2 = &temp2;
20383 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20384 }
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 Py_INCREF(Py_None); resultobj = Py_None;
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20400 PyObject *resultobj;
20401 wxEffects *arg1 = (wxEffects *) 0 ;
20402 wxColour *arg2 = 0 ;
20403 wxColour *arg3 = 0 ;
20404 wxColour *arg4 = 0 ;
20405 wxColour *arg5 = 0 ;
20406 wxColour *arg6 = 0 ;
20407 wxColour temp2 ;
20408 wxColour temp3 ;
20409 wxColour temp4 ;
20410 wxColour temp5 ;
20411 wxColour temp6 ;
20412 PyObject * obj0 = 0 ;
20413 PyObject * obj1 = 0 ;
20414 PyObject * obj2 = 0 ;
20415 PyObject * obj3 = 0 ;
20416 PyObject * obj4 = 0 ;
20417 PyObject * obj5 = 0 ;
20418 char *kwnames[] = {
20419 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20420 };
20421
20422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20424 if (SWIG_arg_fail(1)) SWIG_fail;
20425 {
20426 arg2 = &temp2;
20427 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20428 }
20429 {
20430 arg3 = &temp3;
20431 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20432 }
20433 {
20434 arg4 = &temp4;
20435 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20436 }
20437 {
20438 arg5 = &temp5;
20439 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20440 }
20441 {
20442 arg6 = &temp6;
20443 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20444 }
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20448
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 Py_INCREF(Py_None); resultobj = Py_None;
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20460 PyObject *resultobj;
20461 wxEffects *arg1 = (wxEffects *) 0 ;
20462 wxDC *arg2 = 0 ;
20463 wxRect *arg3 = 0 ;
20464 int arg4 = (int) 1 ;
20465 wxRect temp3 ;
20466 PyObject * obj0 = 0 ;
20467 PyObject * obj1 = 0 ;
20468 PyObject * obj2 = 0 ;
20469 PyObject * obj3 = 0 ;
20470 char *kwnames[] = {
20471 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20472 };
20473
20474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20476 if (SWIG_arg_fail(1)) SWIG_fail;
20477 {
20478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20479 if (SWIG_arg_fail(2)) SWIG_fail;
20480 if (arg2 == NULL) {
20481 SWIG_null_ref("wxDC");
20482 }
20483 if (SWIG_arg_fail(2)) SWIG_fail;
20484 }
20485 {
20486 arg3 = &temp3;
20487 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20488 }
20489 if (obj3) {
20490 {
20491 arg4 = (int)(SWIG_As_int(obj3));
20492 if (SWIG_arg_fail(4)) SWIG_fail;
20493 }
20494 }
20495 {
20496 PyThreadState* __tstate = wxPyBeginAllowThreads();
20497 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20498
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 Py_INCREF(Py_None); resultobj = Py_None;
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj;
20511 wxEffects *arg1 = (wxEffects *) 0 ;
20512 wxRect *arg2 = 0 ;
20513 wxDC *arg3 = 0 ;
20514 wxBitmap *arg4 = 0 ;
20515 bool result;
20516 wxRect temp2 ;
20517 PyObject * obj0 = 0 ;
20518 PyObject * obj1 = 0 ;
20519 PyObject * obj2 = 0 ;
20520 PyObject * obj3 = 0 ;
20521 char *kwnames[] = {
20522 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20523 };
20524
20525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20527 if (SWIG_arg_fail(1)) SWIG_fail;
20528 {
20529 arg2 = &temp2;
20530 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20531 }
20532 {
20533 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20534 if (SWIG_arg_fail(3)) SWIG_fail;
20535 if (arg3 == NULL) {
20536 SWIG_null_ref("wxDC");
20537 }
20538 if (SWIG_arg_fail(3)) SWIG_fail;
20539 }
20540 {
20541 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(4)) SWIG_fail;
20543 if (arg4 == NULL) {
20544 SWIG_null_ref("wxBitmap");
20545 }
20546 if (SWIG_arg_fail(4)) SWIG_fail;
20547 }
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20551
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 {
20556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20565 PyObject *obj;
20566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20567 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20568 Py_INCREF(obj);
20569 return Py_BuildValue((char *)"");
20570 }
20571 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 int arg1 ;
20574 int arg2 ;
20575 bool arg3 ;
20576 wxSplitterRenderParams *result;
20577 PyObject * obj0 = 0 ;
20578 PyObject * obj1 = 0 ;
20579 PyObject * obj2 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
20585 {
20586 arg1 = (int)(SWIG_As_int(obj0));
20587 if (SWIG_arg_fail(1)) SWIG_fail;
20588 }
20589 {
20590 arg2 = (int)(SWIG_As_int(obj1));
20591 if (SWIG_arg_fail(2)) SWIG_fail;
20592 }
20593 {
20594 arg3 = (bool)(SWIG_As_bool(obj2));
20595 if (SWIG_arg_fail(3)) SWIG_fail;
20596 }
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
20600
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj;
20613 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20614 PyObject * obj0 = 0 ;
20615 char *kwnames[] = {
20616 (char *) "self", NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
20620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20621 if (SWIG_arg_fail(1)) SWIG_fail;
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 delete arg1;
20625
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 Py_INCREF(Py_None); resultobj = Py_None;
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj;
20638 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20639 int result;
20640 PyObject * obj0 = 0 ;
20641 char *kwnames[] = {
20642 (char *) "self", NULL
20643 };
20644
20645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
20646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20647 if (SWIG_arg_fail(1)) SWIG_fail;
20648 result = (int)(int) ((arg1)->widthSash);
20649
20650 {
20651 resultobj = SWIG_From_int((int)(result));
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
20660 PyObject *resultobj;
20661 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20662 int result;
20663 PyObject * obj0 = 0 ;
20664 char *kwnames[] = {
20665 (char *) "self", NULL
20666 };
20667
20668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
20669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20670 if (SWIG_arg_fail(1)) SWIG_fail;
20671 result = (int)(int) ((arg1)->border);
20672
20673 {
20674 resultobj = SWIG_From_int((int)(result));
20675 }
20676 return resultobj;
20677 fail:
20678 return NULL;
20679 }
20680
20681
20682 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
20683 PyObject *resultobj;
20684 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
20685 bool result;
20686 PyObject * obj0 = 0 ;
20687 char *kwnames[] = {
20688 (char *) "self", NULL
20689 };
20690
20691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
20692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
20693 if (SWIG_arg_fail(1)) SWIG_fail;
20694 result = (bool)(bool) ((arg1)->isHotSensitive);
20695
20696 {
20697 resultobj = SWIG_From_bool((bool)(result));
20698 }
20699 return resultobj;
20700 fail:
20701 return NULL;
20702 }
20703
20704
20705 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
20706 PyObject *obj;
20707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20708 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
20709 Py_INCREF(obj);
20710 return Py_BuildValue((char *)"");
20711 }
20712 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20713 PyObject *resultobj;
20714 int arg1 ;
20715 int arg2 ;
20716 wxRendererVersion *result;
20717 PyObject * obj0 = 0 ;
20718 PyObject * obj1 = 0 ;
20719 char *kwnames[] = {
20720 (char *) "version_",(char *) "age_", NULL
20721 };
20722
20723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
20724 {
20725 arg1 = (int)(SWIG_As_int(obj0));
20726 if (SWIG_arg_fail(1)) SWIG_fail;
20727 }
20728 {
20729 arg2 = (int)(SWIG_As_int(obj1));
20730 if (SWIG_arg_fail(2)) SWIG_fail;
20731 }
20732 {
20733 PyThreadState* __tstate = wxPyBeginAllowThreads();
20734 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
20735
20736 wxPyEndAllowThreads(__tstate);
20737 if (PyErr_Occurred()) SWIG_fail;
20738 }
20739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj;
20748 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20749 PyObject * obj0 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 delete arg1;
20760
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 Py_INCREF(Py_None); resultobj = Py_None;
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
20772 PyObject *resultobj;
20773 wxRendererVersion *arg1 = 0 ;
20774 bool result;
20775 PyObject * obj0 = 0 ;
20776 char *kwnames[] = {
20777 (char *) "ver", NULL
20778 };
20779
20780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
20781 {
20782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20783 if (SWIG_arg_fail(1)) SWIG_fail;
20784 if (arg1 == NULL) {
20785 SWIG_null_ref("wxRendererVersion");
20786 }
20787 if (SWIG_arg_fail(1)) SWIG_fail;
20788 }
20789 {
20790 PyThreadState* __tstate = wxPyBeginAllowThreads();
20791 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
20792
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
20806 PyObject *resultobj;
20807 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20808 int result;
20809 PyObject * obj0 = 0 ;
20810 char *kwnames[] = {
20811 (char *) "self", NULL
20812 };
20813
20814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
20815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20816 if (SWIG_arg_fail(1)) SWIG_fail;
20817 result = (int)(int) ((arg1)->version);
20818
20819 {
20820 resultobj = SWIG_From_int((int)(result));
20821 }
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj;
20830 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
20831 int result;
20832 PyObject * obj0 = 0 ;
20833 char *kwnames[] = {
20834 (char *) "self", NULL
20835 };
20836
20837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
20838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 result = (int)(int) ((arg1)->age);
20841
20842 {
20843 resultobj = SWIG_From_int((int)(result));
20844 }
20845 return resultobj;
20846 fail:
20847 return NULL;
20848 }
20849
20850
20851 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
20852 PyObject *obj;
20853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20854 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
20855 Py_INCREF(obj);
20856 return Py_BuildValue((char *)"");
20857 }
20858 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
20859 PyObject *resultobj;
20860 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20861 wxWindow *arg2 = (wxWindow *) 0 ;
20862 wxDC *arg3 = 0 ;
20863 wxRect *arg4 = 0 ;
20864 int arg5 = (int) 0 ;
20865 wxRect temp4 ;
20866 PyObject * obj0 = 0 ;
20867 PyObject * obj1 = 0 ;
20868 PyObject * obj2 = 0 ;
20869 PyObject * obj3 = 0 ;
20870 PyObject * obj4 = 0 ;
20871 char *kwnames[] = {
20872 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
20873 };
20874
20875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
20877 if (SWIG_arg_fail(1)) SWIG_fail;
20878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20879 if (SWIG_arg_fail(2)) SWIG_fail;
20880 {
20881 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20882 if (SWIG_arg_fail(3)) SWIG_fail;
20883 if (arg3 == NULL) {
20884 SWIG_null_ref("wxDC");
20885 }
20886 if (SWIG_arg_fail(3)) SWIG_fail;
20887 }
20888 {
20889 arg4 = &temp4;
20890 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20891 }
20892 if (obj4) {
20893 {
20894 arg5 = (int)(SWIG_As_int(obj4));
20895 if (SWIG_arg_fail(5)) SWIG_fail;
20896 }
20897 }
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
20901
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 Py_INCREF(Py_None); resultobj = Py_None;
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
20913 PyObject *resultobj;
20914 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20915 wxWindow *arg2 = (wxWindow *) 0 ;
20916 wxDC *arg3 = 0 ;
20917 wxRect *arg4 = 0 ;
20918 int arg5 = (int) 0 ;
20919 wxRect temp4 ;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 PyObject * obj2 = 0 ;
20923 PyObject * obj3 = 0 ;
20924 PyObject * obj4 = 0 ;
20925 char *kwnames[] = {
20926 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
20927 };
20928
20929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
20931 if (SWIG_arg_fail(1)) SWIG_fail;
20932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20933 if (SWIG_arg_fail(2)) SWIG_fail;
20934 {
20935 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20936 if (SWIG_arg_fail(3)) SWIG_fail;
20937 if (arg3 == NULL) {
20938 SWIG_null_ref("wxDC");
20939 }
20940 if (SWIG_arg_fail(3)) SWIG_fail;
20941 }
20942 {
20943 arg4 = &temp4;
20944 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20945 }
20946 if (obj4) {
20947 {
20948 arg5 = (int)(SWIG_As_int(obj4));
20949 if (SWIG_arg_fail(5)) SWIG_fail;
20950 }
20951 }
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 Py_INCREF(Py_None); resultobj = Py_None;
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj;
20968 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
20969 wxWindow *arg2 = (wxWindow *) 0 ;
20970 wxDC *arg3 = 0 ;
20971 wxRect *arg4 = 0 ;
20972 int arg5 = (int) 0 ;
20973 wxRect temp4 ;
20974 PyObject * obj0 = 0 ;
20975 PyObject * obj1 = 0 ;
20976 PyObject * obj2 = 0 ;
20977 PyObject * obj3 = 0 ;
20978 PyObject * obj4 = 0 ;
20979 char *kwnames[] = {
20980 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
20981 };
20982
20983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
20985 if (SWIG_arg_fail(1)) SWIG_fail;
20986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20987 if (SWIG_arg_fail(2)) SWIG_fail;
20988 {
20989 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20990 if (SWIG_arg_fail(3)) SWIG_fail;
20991 if (arg3 == NULL) {
20992 SWIG_null_ref("wxDC");
20993 }
20994 if (SWIG_arg_fail(3)) SWIG_fail;
20995 }
20996 {
20997 arg4 = &temp4;
20998 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
20999 }
21000 if (obj4) {
21001 {
21002 arg5 = (int)(SWIG_As_int(obj4));
21003 if (SWIG_arg_fail(5)) SWIG_fail;
21004 }
21005 }
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 Py_INCREF(Py_None); resultobj = Py_None;
21014 return resultobj;
21015 fail:
21016 return NULL;
21017 }
21018
21019
21020 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21021 PyObject *resultobj;
21022 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21023 wxWindow *arg2 = (wxWindow *) 0 ;
21024 wxDC *arg3 = 0 ;
21025 wxSize *arg4 = 0 ;
21026 int arg5 ;
21027 wxOrientation arg6 ;
21028 int arg7 = (int) 0 ;
21029 wxSize temp4 ;
21030 PyObject * obj0 = 0 ;
21031 PyObject * obj1 = 0 ;
21032 PyObject * obj2 = 0 ;
21033 PyObject * obj3 = 0 ;
21034 PyObject * obj4 = 0 ;
21035 PyObject * obj5 = 0 ;
21036 PyObject * obj6 = 0 ;
21037 char *kwnames[] = {
21038 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
21039 };
21040
21041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
21042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21043 if (SWIG_arg_fail(1)) SWIG_fail;
21044 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21045 if (SWIG_arg_fail(2)) SWIG_fail;
21046 {
21047 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21048 if (SWIG_arg_fail(3)) SWIG_fail;
21049 if (arg3 == NULL) {
21050 SWIG_null_ref("wxDC");
21051 }
21052 if (SWIG_arg_fail(3)) SWIG_fail;
21053 }
21054 {
21055 arg4 = &temp4;
21056 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
21057 }
21058 {
21059 arg5 = (int)(SWIG_As_int(obj4));
21060 if (SWIG_arg_fail(5)) SWIG_fail;
21061 }
21062 {
21063 arg6 = (wxOrientation)(SWIG_As_int(obj5));
21064 if (SWIG_arg_fail(6)) SWIG_fail;
21065 }
21066 if (obj6) {
21067 {
21068 arg7 = (int)(SWIG_As_int(obj6));
21069 if (SWIG_arg_fail(7)) SWIG_fail;
21070 }
21071 }
21072 {
21073 PyThreadState* __tstate = wxPyBeginAllowThreads();
21074 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 Py_INCREF(Py_None); resultobj = Py_None;
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21089 wxWindow *arg2 = (wxWindow *) 0 ;
21090 wxDC *arg3 = 0 ;
21091 wxRect *arg4 = 0 ;
21092 int arg5 = (int) 0 ;
21093 wxRect temp4 ;
21094 PyObject * obj0 = 0 ;
21095 PyObject * obj1 = 0 ;
21096 PyObject * obj2 = 0 ;
21097 PyObject * obj3 = 0 ;
21098 PyObject * obj4 = 0 ;
21099 char *kwnames[] = {
21100 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21101 };
21102
21103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21105 if (SWIG_arg_fail(1)) SWIG_fail;
21106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21107 if (SWIG_arg_fail(2)) SWIG_fail;
21108 {
21109 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21110 if (SWIG_arg_fail(3)) SWIG_fail;
21111 if (arg3 == NULL) {
21112 SWIG_null_ref("wxDC");
21113 }
21114 if (SWIG_arg_fail(3)) SWIG_fail;
21115 }
21116 {
21117 arg4 = &temp4;
21118 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21119 }
21120 if (obj4) {
21121 {
21122 arg5 = (int)(SWIG_As_int(obj4));
21123 if (SWIG_arg_fail(5)) SWIG_fail;
21124 }
21125 }
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21129
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 Py_INCREF(Py_None); resultobj = Py_None;
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
21141 PyObject *resultobj;
21142 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21143 wxWindow *arg2 = (wxWindow *) 0 ;
21144 wxDC *arg3 = 0 ;
21145 wxRect *arg4 = 0 ;
21146 int arg5 = (int) 0 ;
21147 wxRect temp4 ;
21148 PyObject * obj0 = 0 ;
21149 PyObject * obj1 = 0 ;
21150 PyObject * obj2 = 0 ;
21151 PyObject * obj3 = 0 ;
21152 PyObject * obj4 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21161 if (SWIG_arg_fail(2)) SWIG_fail;
21162 {
21163 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21164 if (SWIG_arg_fail(3)) SWIG_fail;
21165 if (arg3 == NULL) {
21166 SWIG_null_ref("wxDC");
21167 }
21168 if (SWIG_arg_fail(3)) SWIG_fail;
21169 }
21170 {
21171 arg4 = &temp4;
21172 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21173 }
21174 if (obj4) {
21175 {
21176 arg5 = (int)(SWIG_As_int(obj4));
21177 if (SWIG_arg_fail(5)) SWIG_fail;
21178 }
21179 }
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
21183
21184 wxPyEndAllowThreads(__tstate);
21185 if (PyErr_Occurred()) SWIG_fail;
21186 }
21187 Py_INCREF(Py_None); resultobj = Py_None;
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
21195 PyObject *resultobj;
21196 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21197 wxWindow *arg2 = (wxWindow *) 0 ;
21198 SwigValueWrapper<wxSplitterRenderParams > result;
21199 PyObject * obj0 = 0 ;
21200 PyObject * obj1 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self",(char *) "win", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21209 if (SWIG_arg_fail(2)) SWIG_fail;
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 {
21218 wxSplitterRenderParams * resultptr;
21219 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
21220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
21221 }
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxRendererNative *result;
21231 char *kwnames[] = {
21232 NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 {
21239 wxRendererNative &_result_ref = wxRendererNative::Get();
21240 result = (wxRendererNative *) &_result_ref;
21241 }
21242
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj;
21255 wxRendererNative *result;
21256 char *kwnames[] = {
21257 NULL
21258 };
21259
21260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 {
21264 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
21265 result = (wxRendererNative *) &_result_ref;
21266 }
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj;
21280 wxRendererNative *result;
21281 char *kwnames[] = {
21282 NULL
21283 };
21284
21285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
21286 {
21287 PyThreadState* __tstate = wxPyBeginAllowThreads();
21288 {
21289 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
21290 result = (wxRendererNative *) &_result_ref;
21291 }
21292
21293 wxPyEndAllowThreads(__tstate);
21294 if (PyErr_Occurred()) SWIG_fail;
21295 }
21296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21297 return resultobj;
21298 fail:
21299 return NULL;
21300 }
21301
21302
21303 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21304 PyObject *resultobj;
21305 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21306 wxRendererNative *result;
21307 PyObject * obj0 = 0 ;
21308 char *kwnames[] = {
21309 (char *) "renderer", NULL
21310 };
21311
21312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
21313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21314 if (SWIG_arg_fail(1)) SWIG_fail;
21315 {
21316 PyThreadState* __tstate = wxPyBeginAllowThreads();
21317 result = (wxRendererNative *)wxRendererNative::Set(arg1);
21318
21319 wxPyEndAllowThreads(__tstate);
21320 if (PyErr_Occurred()) SWIG_fail;
21321 }
21322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21330 PyObject *resultobj;
21331 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21332 SwigValueWrapper<wxRendererVersion > result;
21333 PyObject * obj0 = 0 ;
21334 char *kwnames[] = {
21335 (char *) "self", NULL
21336 };
21337
21338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
21339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21340 if (SWIG_arg_fail(1)) SWIG_fail;
21341 {
21342 PyThreadState* __tstate = wxPyBeginAllowThreads();
21343 result = ((wxRendererNative const *)arg1)->GetVersion();
21344
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 {
21349 wxRendererVersion * resultptr;
21350 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
21351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
21352 }
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
21360 PyObject *obj;
21361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21362 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
21363 Py_INCREF(obj);
21364 return Py_BuildValue((char *)"");
21365 }
21366 static PyMethodDef SwigMethods[] = {
21367 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21368 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21369 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21370 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21371 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21372 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21373 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21374 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21375 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21376 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21377 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21378 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21379 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21380 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21381 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21382 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21383 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21384 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21385 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21386 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21387 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21388 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21389 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21390 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21391 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21392 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21393 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21394 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21395 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21396 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21397 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21398 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21399 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21400 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21401 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21402 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21403 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21404 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21405 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21406 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21407 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21408 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21409 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21410 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21411 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21412 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21413 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21414 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21415 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21416 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21417 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21418 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21419 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21420 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21421 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21422 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21423 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21424 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21425 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21426 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21427 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21428 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21429 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21430 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21431 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21432 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21433 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21434 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21435 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21436 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21437 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21438 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21439 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21440 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21441 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21442 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21443 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21444 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21445 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21446 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21447 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21448 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21449 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21450 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21451 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21452 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21453 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21454 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21455 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21456 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21457 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21458 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21459 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21460 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21461 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21462 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21463 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21464 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21465 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21466 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21467 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21468 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21469 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21470 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21471 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21472 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21473 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21474 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21475 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21476 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21477 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21478 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21479 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21480 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21481 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21482 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21483 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21484 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21485 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21486 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21487 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21488 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21489 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21490 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21491 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21492 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21493 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21494 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21495 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21496 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21497 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21498 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21499 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21500 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21501 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21502 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21503 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21504 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21505 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21506 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21507 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21508 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21509 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21510 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21511 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21512 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21513 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21514 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21515 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21516 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21517 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21518 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21519 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21520 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21521 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21522 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21523 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21524 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21525 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21526 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21527 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21528 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21530 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21533 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21538 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21540 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21546 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21548 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21550 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21554 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21556 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21557 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21564 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21569 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21570 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21573 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21579 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21591 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21592 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21625 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21627 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21634 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21642 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21646 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21649 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21654 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21662 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21671 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21673 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21677 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21681 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21706 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21720 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21746 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21755 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21775 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21809 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21813 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21814 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21817 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21819 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21824 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21825 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21826 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21828 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21830 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21832 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21838 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21840 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21842 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21844 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21854 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21856 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21858 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21859 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21861 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21863 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21864 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21868 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21869 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21871 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21873 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21875 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21880 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21884 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21888 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21889 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21890 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21892 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21894 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21895 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
21899 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
21900 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
21901 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21903 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
21905 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
21906 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
21907 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
21911 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
21913 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
21920 { NULL, NULL, 0, NULL }
21921 };
21922
21923
21924 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21925
21926 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21927 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21928 }
21929 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21930 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21931 }
21932 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21933 return (void *)((wxGDIObject *) ((wxIcon *) x));
21934 }
21935 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21936 return (void *)((wxGDIObject *) ((wxPalette *) x));
21937 }
21938 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21939 return (void *)((wxGDIObject *) ((wxPen *) x));
21940 }
21941 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21942 return (void *)((wxGDIObject *) ((wxFont *) x));
21943 }
21944 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21945 return (void *)((wxGDIObject *) ((wxCursor *) x));
21946 }
21947 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21948 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21949 }
21950 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21951 return (void *)((wxGDIObject *) ((wxRegion *) x));
21952 }
21953 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21954 return (void *)((wxGDIObject *) ((wxBrush *) x));
21955 }
21956 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21957 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21958 }
21959 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21960 return (void *)((wxDC *) ((wxScreenDC *) x));
21961 }
21962 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21963 return (void *)((wxDC *) ((wxMirrorDC *) x));
21964 }
21965 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21966 return (void *)((wxDC *) ((wxMemoryDC *) x));
21967 }
21968 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21969 return (void *)((wxDC *) ((wxWindowDC *) x));
21970 }
21971 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21972 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21973 }
21974 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21975 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21976 }
21977 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21978 return (void *)((wxDC *) ((wxClientDC *) x));
21979 }
21980 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21981 return (void *)((wxDC *) ((wxPaintDC *) x));
21982 }
21983 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21984 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21985 }
21986 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21987 return (void *)((wxDC *) ((wxPrinterDC *) x));
21988 }
21989 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21990 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21991 }
21992 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21993 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21994 }
21995 static void *_p_wxPenTo_p_wxObject(void *x) {
21996 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21997 }
21998 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21999 return (void *)((wxObject *) ((wxRegionIterator *) x));
22000 }
22001 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22002 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22003 }
22004 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22005 return (void *)((wxObject *) ((wxSizerItem *) x));
22006 }
22007 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22008 return (void *)((wxObject *) ((wxColourDatabase *) x));
22009 }
22010 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22011 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22012 }
22013 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22014 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22015 }
22016 static void *_p_wxIconTo_p_wxObject(void *x) {
22017 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22018 }
22019 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22020 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22021 }
22022 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22023 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22024 }
22025 static void *_p_wxSizerTo_p_wxObject(void *x) {
22026 return (void *)((wxObject *) ((wxSizer *) x));
22027 }
22028 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22029 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22030 }
22031 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22032 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22033 }
22034 static void *_p_wxPenListTo_p_wxObject(void *x) {
22035 return (void *)((wxObject *) ((wxPenList *) x));
22036 }
22037 static void *_p_wxEventTo_p_wxObject(void *x) {
22038 return (void *)((wxObject *) ((wxEvent *) x));
22039 }
22040 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22041 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22042 }
22043 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22044 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22045 }
22046 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22047 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22048 }
22049 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22050 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22051 }
22052 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22053 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22054 }
22055 static void *_p_wxDCTo_p_wxObject(void *x) {
22056 return (void *)((wxObject *) ((wxDC *) x));
22057 }
22058 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22059 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22060 }
22061 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22062 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22063 }
22064 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22065 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22066 }
22067 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22068 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22069 }
22070 static void *_p_wxControlTo_p_wxObject(void *x) {
22071 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22072 }
22073 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22074 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22075 }
22076 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22077 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22078 }
22079 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22080 return (void *)((wxObject *) ((wxFSFile *) x));
22081 }
22082 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22083 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22084 }
22085 static void *_p_wxRegionTo_p_wxObject(void *x) {
22086 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22087 }
22088 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22089 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22090 }
22091 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22092 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22093 }
22094 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22095 return (void *)((wxObject *) ((wxGDIObject *) x));
22096 }
22097 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22098 return (void *)((wxObject *) ((wxEffects *) x));
22099 }
22100 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22101 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22102 }
22103 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22105 }
22106 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22107 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22108 }
22109 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22110 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22111 }
22112 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22113 return (void *)((wxObject *) ((wxMenuItem *) x));
22114 }
22115 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22117 }
22118 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22119 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22120 }
22121 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22122 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22123 }
22124 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22125 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22126 }
22127 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22128 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22129 }
22130 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22131 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22132 }
22133 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22134 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22135 }
22136 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22137 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22138 }
22139 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22140 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22141 }
22142 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22143 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22144 }
22145 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22146 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22147 }
22148 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22149 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22150 }
22151 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22152 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22153 }
22154 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22155 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22156 }
22157 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22158 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22159 }
22160 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22161 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22162 }
22163 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22164 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22165 }
22166 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22167 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22168 }
22169 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
22170 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
22171 }
22172 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22173 return (void *)((wxObject *) ((wxImageHandler *) x));
22174 }
22175 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22176 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22177 }
22178 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22179 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22180 }
22181 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22182 return (void *)((wxObject *) ((wxEvtHandler *) x));
22183 }
22184 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22185 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22186 }
22187 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22188 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22189 }
22190 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22191 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22192 }
22193 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22194 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22195 }
22196 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22197 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22198 }
22199 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22200 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22201 }
22202 static void *_p_wxImageTo_p_wxObject(void *x) {
22203 return (void *)((wxObject *) ((wxImage *) x));
22204 }
22205 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22206 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22207 }
22208 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22209 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22210 }
22211 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22212 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22213 }
22214 static void *_p_wxImageListTo_p_wxObject(void *x) {
22215 return (void *)((wxObject *) ((wxImageList *) x));
22216 }
22217 static void *_p_wxCursorTo_p_wxObject(void *x) {
22218 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22219 }
22220 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22221 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22222 }
22223 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22224 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22225 }
22226 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22227 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22228 }
22229 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22230 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22231 }
22232 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22233 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22234 }
22235 static void *_p_wxWindowTo_p_wxObject(void *x) {
22236 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22237 }
22238 static void *_p_wxMenuTo_p_wxObject(void *x) {
22239 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22240 }
22241 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22242 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22243 }
22244 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22245 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22246 }
22247 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22248 return (void *)((wxObject *) ((wxBrushList *) x));
22249 }
22250 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22251 return (void *)((wxObject *) ((wxFileSystem *) x));
22252 }
22253 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22254 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22255 }
22256 static void *_p_wxMaskTo_p_wxObject(void *x) {
22257 return (void *)((wxObject *) ((wxMask *) x));
22258 }
22259 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22260 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22261 }
22262 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22263 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22264 }
22265 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22266 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22267 }
22268 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22269 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22270 }
22271 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22272 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22273 }
22274 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22275 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22276 }
22277 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22279 }
22280 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22281 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22282 }
22283 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22284 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22285 }
22286 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22287 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22288 }
22289 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22290 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22291 }
22292 static void *_p_wxFontTo_p_wxObject(void *x) {
22293 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22294 }
22295 static void *_p_wxBrushTo_p_wxObject(void *x) {
22296 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22297 }
22298 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22299 return (void *)((wxObject *) ((wxMetaFile *) x));
22300 }
22301 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22302 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22303 }
22304 static void *_p_wxColourTo_p_wxObject(void *x) {
22305 return (void *)((wxObject *) ((wxColour *) x));
22306 }
22307 static void *_p_wxFontListTo_p_wxObject(void *x) {
22308 return (void *)((wxObject *) ((wxFontList *) x));
22309 }
22310 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22311 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22312 }
22313 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22314 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22315 }
22316 static void *_p_wxControlTo_p_wxWindow(void *x) {
22317 return (void *)((wxWindow *) ((wxControl *) x));
22318 }
22319 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22320 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22321 }
22322 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22323 return (void *)((wxWindow *) ((wxMenuBar *) x));
22324 }
22325 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}};
22326 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}};
22327 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}};
22328 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}};
22329 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}};
22330 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}};
22331 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}};
22332 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}};
22333 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}};
22334 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}};
22335 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}};
22336 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}};
22337 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}};
22338 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}};
22339 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}};
22340 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}};
22341 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}};
22342 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}};
22343 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}};
22344 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}};
22345 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}};
22346 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}};
22347 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}};
22348 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}};
22349 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegionIterator", _p_wxRegionIteratorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPen", _p_wxPenTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColourDatabase", _p_wxColourDatabaseTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPenList", _p_wxPenListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMask", _p_wxMaskTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFont", _p_wxFontTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClientDC", _p_wxClientDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMemoryDC", _p_wxMemoryDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxRegion", _p_wxRegionTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDC", _p_wxDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIcon", _p_wxIconTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDC", _p_wxWindowDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGDIObject", _p_wxGDIObjectTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEffects", _p_wxEffectsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPostScriptDC", _p_wxPostScriptDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
22350 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}};
22351 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}};
22352 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}};
22353 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}};
22354 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}};
22355 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}};
22356 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}};
22357 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}};
22358 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}};
22359 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}};
22360 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}};
22361 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}};
22362 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}};
22363 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}};
22364 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}};
22365 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}};
22366 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}};
22367 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}};
22368 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}};
22369 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}};
22370 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}};
22371 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}};
22372 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}};
22373 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}};
22374 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}};
22375 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}};
22376 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}};
22377 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}};
22378 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}};
22379 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}};
22380 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}};
22381 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}};
22382 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}};
22383 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}};
22384 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}};
22385 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}};
22386 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}};
22387 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}};
22388 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}};
22389
22390 static swig_type_info *swig_types_initial[] = {
22391 _swigt__p_wxPostScriptDC,
22392 _swigt__p_wxBrush,
22393 _swigt__p_wxColour,
22394 _swigt__p_wxDC,
22395 _swigt__p_wxMirrorDC,
22396 _swigt__p_form_ops_t,
22397 _swigt__p_wxRendererVersion,
22398 _swigt__p_wxDuplexMode,
22399 _swigt__p_wxPyFontEnumerator,
22400 _swigt__p_char,
22401 _swigt__p_wxIconLocation,
22402 _swigt__p_wxImage,
22403 _swigt__p_wxMetaFileDC,
22404 _swigt__p_wxMask,
22405 _swigt__p_wxSize,
22406 _swigt__p_wxFont,
22407 _swigt__p_wxWindow,
22408 _swigt__p_double,
22409 _swigt__p_wxMemoryDC,
22410 _swigt__p_wxFontMapper,
22411 _swigt__p_wxEffects,
22412 _swigt__p_wxNativeEncodingInfo,
22413 _swigt__p_wxPalette,
22414 _swigt__p_wxBitmap,
22415 _swigt__p_wxObject,
22416 _swigt__p_wxRegionIterator,
22417 _swigt__p_wxRect,
22418 _swigt__p_wxPaperSize,
22419 _swigt__p_wxString,
22420 _swigt__unsigned_int,
22421 _swigt__p_unsigned_int,
22422 _swigt__p_wxPrinterDC,
22423 _swigt__p_wxIconBundle,
22424 _swigt__p_wxPoint,
22425 _swigt__p_wxDash,
22426 _swigt__p_wxScreenDC,
22427 _swigt__p_wxCursor,
22428 _swigt__p_wxClientDC,
22429 _swigt__p_wxBufferedDC,
22430 _swigt__p_wxImageList,
22431 _swigt__p_unsigned_char,
22432 _swigt__p_wxGDIObject,
22433 _swigt__p_wxIcon,
22434 _swigt__p_wxLocale,
22435 _swigt__ptrdiff_t,
22436 _swigt__std__ptrdiff_t,
22437 _swigt__p_wxRegion,
22438 _swigt__p_wxLanguageInfo,
22439 _swigt__p_wxWindowDC,
22440 _swigt__p_wxPrintData,
22441 _swigt__p_wxBrushList,
22442 _swigt__p_wxFontList,
22443 _swigt__p_wxPen,
22444 _swigt__p_wxBufferedPaintDC,
22445 _swigt__p_wxPaintDC,
22446 _swigt__p_wxPenList,
22447 _swigt__p_int,
22448 _swigt__p_wxMetaFile,
22449 _swigt__p_wxRendererNative,
22450 _swigt__p_unsigned_long,
22451 _swigt__p_wxNativeFontInfo,
22452 _swigt__p_wxEncodingConverter,
22453 _swigt__p_wxSplitterRenderParams,
22454 _swigt__p_wxColourDatabase,
22455 0
22456 };
22457
22458
22459 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22460
22461 static swig_const_info swig_const_table[] = {
22462 {0, 0, 0, 0.0, 0, 0}};
22463
22464 #ifdef __cplusplus
22465 }
22466 #endif
22467
22468
22469 #ifdef __cplusplus
22470 extern "C" {
22471 #endif
22472
22473 /* Python-specific SWIG API */
22474 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22475 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22476 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22477
22478 /* -----------------------------------------------------------------------------
22479 * global variable support code.
22480 * ----------------------------------------------------------------------------- */
22481
22482 typedef struct swig_globalvar {
22483 char *name; /* Name of global variable */
22484 PyObject *(*get_attr)(); /* Return the current value */
22485 int (*set_attr)(PyObject *); /* Set the value */
22486 struct swig_globalvar *next;
22487 } swig_globalvar;
22488
22489 typedef struct swig_varlinkobject {
22490 PyObject_HEAD
22491 swig_globalvar *vars;
22492 } swig_varlinkobject;
22493
22494 static PyObject *
22495 swig_varlink_repr(swig_varlinkobject *v) {
22496 v = v;
22497 return PyString_FromString("<Swig global variables>");
22498 }
22499
22500 static int
22501 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22502 swig_globalvar *var;
22503 flags = flags;
22504 fprintf(fp,"Swig global variables { ");
22505 for (var = v->vars; var; var=var->next) {
22506 fprintf(fp,"%s", var->name);
22507 if (var->next) fprintf(fp,", ");
22508 }
22509 fprintf(fp," }\n");
22510 return 0;
22511 }
22512
22513 static PyObject *
22514 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22515 swig_globalvar *var = v->vars;
22516 while (var) {
22517 if (strcmp(var->name,n) == 0) {
22518 return (*var->get_attr)();
22519 }
22520 var = var->next;
22521 }
22522 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22523 return NULL;
22524 }
22525
22526 static int
22527 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22528 swig_globalvar *var = v->vars;
22529 while (var) {
22530 if (strcmp(var->name,n) == 0) {
22531 return (*var->set_attr)(p);
22532 }
22533 var = var->next;
22534 }
22535 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22536 return 1;
22537 }
22538
22539 static PyTypeObject varlinktype = {
22540 PyObject_HEAD_INIT(0)
22541 0, /* Number of items in variable part (ob_size) */
22542 (char *)"swigvarlink", /* Type name (tp_name) */
22543 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22544 0, /* Itemsize (tp_itemsize) */
22545 0, /* Deallocator (tp_dealloc) */
22546 (printfunc) swig_varlink_print, /* Print (tp_print) */
22547 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22548 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22549 0, /* tp_compare */
22550 (reprfunc) swig_varlink_repr, /* tp_repr */
22551 0, /* tp_as_number */
22552 0, /* tp_as_sequence */
22553 0, /* tp_as_mapping */
22554 0, /* tp_hash */
22555 0, /* tp_call */
22556 0, /* tp_str */
22557 0, /* tp_getattro */
22558 0, /* tp_setattro */
22559 0, /* tp_as_buffer */
22560 0, /* tp_flags */
22561 0, /* tp_doc */
22562 #if PY_VERSION_HEX >= 0x02000000
22563 0, /* tp_traverse */
22564 0, /* tp_clear */
22565 #endif
22566 #if PY_VERSION_HEX >= 0x02010000
22567 0, /* tp_richcompare */
22568 0, /* tp_weaklistoffset */
22569 #endif
22570 #if PY_VERSION_HEX >= 0x02020000
22571 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22572 #endif
22573 #if PY_VERSION_HEX >= 0x02030000
22574 0, /* tp_del */
22575 #endif
22576 #ifdef COUNT_ALLOCS
22577 0,0,0,0 /* tp_alloc -> tp_next */
22578 #endif
22579 };
22580
22581 /* Create a variable linking object for use later */
22582 static PyObject *
22583 SWIG_Python_newvarlink(void) {
22584 swig_varlinkobject *result = 0;
22585 result = PyMem_NEW(swig_varlinkobject,1);
22586 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22587 result->ob_type = &varlinktype;
22588 result->vars = 0;
22589 result->ob_refcnt = 0;
22590 Py_XINCREF((PyObject *) result);
22591 return ((PyObject*) result);
22592 }
22593
22594 static void
22595 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22596 swig_varlinkobject *v;
22597 swig_globalvar *gv;
22598 v= (swig_varlinkobject *) p;
22599 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22600 gv->name = (char *) malloc(strlen(name)+1);
22601 strcpy(gv->name,name);
22602 gv->get_attr = get_attr;
22603 gv->set_attr = set_attr;
22604 gv->next = v->vars;
22605 v->vars = gv;
22606 }
22607
22608 /* -----------------------------------------------------------------------------
22609 * constants/methods manipulation
22610 * ----------------------------------------------------------------------------- */
22611
22612 /* Install Constants */
22613 static void
22614 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22615 PyObject *obj = 0;
22616 size_t i;
22617 for (i = 0; constants[i].type; i++) {
22618 switch(constants[i].type) {
22619 case SWIG_PY_INT:
22620 obj = PyInt_FromLong(constants[i].lvalue);
22621 break;
22622 case SWIG_PY_FLOAT:
22623 obj = PyFloat_FromDouble(constants[i].dvalue);
22624 break;
22625 case SWIG_PY_STRING:
22626 if (constants[i].pvalue) {
22627 obj = PyString_FromString((char *) constants[i].pvalue);
22628 } else {
22629 Py_INCREF(Py_None);
22630 obj = Py_None;
22631 }
22632 break;
22633 case SWIG_PY_POINTER:
22634 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22635 break;
22636 case SWIG_PY_BINARY:
22637 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22638 break;
22639 default:
22640 obj = 0;
22641 break;
22642 }
22643 if (obj) {
22644 PyDict_SetItemString(d,constants[i].name,obj);
22645 Py_DECREF(obj);
22646 }
22647 }
22648 }
22649
22650 /* -----------------------------------------------------------------------------*/
22651 /* Fix SwigMethods to carry the callback ptrs when needed */
22652 /* -----------------------------------------------------------------------------*/
22653
22654 static void
22655 SWIG_Python_FixMethods(PyMethodDef *methods,
22656 swig_const_info *const_table,
22657 swig_type_info **types,
22658 swig_type_info **types_initial) {
22659 size_t i;
22660 for (i = 0; methods[i].ml_name; ++i) {
22661 char *c = methods[i].ml_doc;
22662 if (c && (c = strstr(c, "swig_ptr: "))) {
22663 int j;
22664 swig_const_info *ci = 0;
22665 char *name = c + 10;
22666 for (j = 0; const_table[j].type; j++) {
22667 if (strncmp(const_table[j].name, name,
22668 strlen(const_table[j].name)) == 0) {
22669 ci = &(const_table[j]);
22670 break;
22671 }
22672 }
22673 if (ci) {
22674 size_t shift = (ci->ptype) - types;
22675 swig_type_info *ty = types_initial[shift];
22676 size_t ldoc = (c - methods[i].ml_doc);
22677 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22678 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22679 char *buff = ndoc;
22680 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22681 strncpy(buff, methods[i].ml_doc, ldoc);
22682 buff += ldoc;
22683 strncpy(buff, "swig_ptr: ", 10);
22684 buff += 10;
22685 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22686 methods[i].ml_doc = ndoc;
22687 }
22688 }
22689 }
22690 }
22691
22692 /* -----------------------------------------------------------------------------*
22693 * Initialize type list
22694 * -----------------------------------------------------------------------------*/
22695
22696 #if PY_MAJOR_VERSION < 2
22697 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22698 is copied out of Python/modsupport.c in python version 2.3.4 */
22699 static int
22700 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22701 {
22702 PyObject *dict;
22703 if (!PyModule_Check(m)) {
22704 PyErr_SetString(PyExc_TypeError,
22705 "PyModule_AddObject() needs module as first arg");
22706 return -1;
22707 }
22708 if (!o) {
22709 PyErr_SetString(PyExc_TypeError,
22710 "PyModule_AddObject() needs non-NULL value");
22711 return -1;
22712 }
22713
22714 dict = PyModule_GetDict(m);
22715 if (dict == NULL) {
22716 /* Internal error -- modules must have a dict! */
22717 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22718 PyModule_GetName(m));
22719 return -1;
22720 }
22721 if (PyDict_SetItemString(dict, name, o))
22722 return -1;
22723 Py_DECREF(o);
22724 return 0;
22725 }
22726 #endif
22727
22728 static swig_type_info **
22729 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22730 static PyMethodDef swig_empty_runtime_method_table[] = {
22731 {
22732 NULL, NULL, 0, NULL
22733 }
22734 };/* Sentinel */
22735
22736 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22737 swig_empty_runtime_method_table);
22738 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22739 if (pointer && module) {
22740 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22741 }
22742 return type_list_handle;
22743 }
22744
22745 static swig_type_info **
22746 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22747 swig_type_info **type_pointer;
22748
22749 /* first check if module already created */
22750 type_pointer = SWIG_Python_GetTypeListHandle();
22751 if (type_pointer) {
22752 return type_pointer;
22753 } else {
22754 /* create a new module and variable */
22755 return SWIG_Python_SetTypeListHandle(type_list_handle);
22756 }
22757 }
22758
22759 #ifdef __cplusplus
22760 }
22761 #endif
22762
22763 /* -----------------------------------------------------------------------------*
22764 * Partial Init method
22765 * -----------------------------------------------------------------------------*/
22766
22767 #ifdef SWIG_LINK_RUNTIME
22768 #ifdef __cplusplus
22769 extern "C"
22770 #endif
22771 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22772 #endif
22773
22774 #ifdef __cplusplus
22775 extern "C"
22776 #endif
22777 SWIGEXPORT(void) SWIG_init(void) {
22778 static PyObject *SWIG_globals = 0;
22779 static int typeinit = 0;
22780 PyObject *m, *d;
22781 int i;
22782 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22783
22784 /* Fix SwigMethods to carry the callback ptrs when needed */
22785 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22786
22787 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22788 d = PyModule_GetDict(m);
22789
22790 if (!typeinit) {
22791 #ifdef SWIG_LINK_RUNTIME
22792 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22793 #else
22794 # ifndef SWIG_STATIC_RUNTIME
22795 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22796 # endif
22797 #endif
22798 for (i = 0; swig_types_initial[i]; i++) {
22799 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22800 }
22801 typeinit = 1;
22802 }
22803 SWIG_InstallConstants(d,swig_const_table);
22804
22805 {
22806 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22807 }
22808 {
22809 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22810 }
22811 {
22812 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22813 }
22814 {
22815 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22816 }
22817 {
22818 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22819 }
22820 {
22821 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22822 }
22823 {
22824 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22825 }
22826 {
22827 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22828 }
22829 {
22830 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22831 }
22832 {
22833 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22834 }
22835 {
22836 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22837 }
22838 {
22839 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22840 }
22841 {
22842 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22843 }
22844 {
22845 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22846 }
22847 {
22848 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22849 }
22850 {
22851 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22852 }
22853 {
22854 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22855 }
22856 {
22857 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22900 }
22901 {
22902 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22903 }
22904 {
22905 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22906 }
22907 {
22908 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22909 }
22910 {
22911 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22912 }
22913 {
22914 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22915 }
22916 {
22917 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22918 }
22919 {
22920 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22921 }
22922 {
22923 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22924 }
22925 {
22926 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22927 }
22928 {
22929 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22930 }
22931 {
22932 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22933 }
22934 {
22935 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22936 }
22937 {
22938 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22939 }
22940 {
22941 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22942 }
22943 {
22944 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22945 }
22946 {
22947 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22948 }
22949 {
22950 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22951 }
22952 {
22953 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22954 }
22955 {
22956 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22957 }
22958 {
22959 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22960 }
22961 {
22962 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22963 }
22964 {
22965 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22966 }
22967 {
22968 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22969 }
22970 {
22971 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22972 }
22973 {
22974 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22975 }
22976 {
22977 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22978 }
22979 {
22980 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22981 }
22982 {
22983 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22984 }
22985 {
22986 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22987 }
22988 {
22989 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22990 }
22991 {
22992 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22993 }
22994 {
22995 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22996 }
22997 {
22998 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22999 }
23000 {
23001 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23002 }
23003 {
23004 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23005 }
23006 {
23007 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23008 }
23009 {
23010 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23011 }
23012 {
23013 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23014 }
23015 {
23016 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23017 }
23018 {
23019 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23020 }
23021 {
23022 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23023 }
23024 {
23025 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23026 }
23027 {
23028 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23029 }
23030 {
23031 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23032 }
23033 {
23034 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23035 }
23036 {
23037 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23038 }
23039 {
23040 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23041 }
23042 {
23043 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23044 }
23045 {
23046 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23047 }
23048 {
23049 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23050 }
23051 {
23052 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23053 }
23054 {
23055 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23056 }
23057 {
23058 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23059 }
23060 {
23061 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23062 }
23063 {
23064 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23065 }
23066 {
23067 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23068 }
23069 {
23070 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23071 }
23072 {
23073 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23074 }
23075 {
23076 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23077 }
23078 {
23079 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23080 }
23081 {
23082 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23083 }
23084 {
23085 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23086 }
23087 {
23088 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23089 }
23090 {
23091 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23092 }
23093 {
23094 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23095 }
23096 {
23097 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23098 }
23099 {
23100 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23101 }
23102 {
23103 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23104 }
23105 {
23106 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23107 }
23108 {
23109 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23110 }
23111 {
23112 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23113 }
23114 {
23115 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23116 }
23117 {
23118 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23119 }
23120 {
23121 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23122 }
23123 {
23124 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23125 }
23126 {
23127 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23128 }
23129 {
23130 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23131 }
23132 {
23133 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23134 }
23135 {
23136 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23137 }
23138 {
23139 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23140 }
23141 {
23142 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23143 }
23144 {
23145 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23146 }
23147 {
23148 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23149 }
23150 {
23151 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23152 }
23153 {
23154 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23155 }
23156 {
23157 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23158 }
23159 {
23160 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23161 }
23162 {
23163 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23164 }
23165 {
23166 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23167 }
23168 {
23169 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23170 }
23171 {
23172 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23173 }
23174 {
23175 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23176 }
23177 {
23178 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23179 }
23180 {
23181 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23182 }
23183 {
23184 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23185 }
23186
23187 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23188
23189 {
23190 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23191 }
23192 {
23193 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23194 }
23195 {
23196 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23197 }
23198 {
23199 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23200 }
23201 {
23202 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23203 }
23204 {
23205 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23206 }
23207 {
23208 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23209 }
23210 {
23211 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23212 }
23213 {
23214 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23215 }
23216 {
23217 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23218 }
23219 {
23220 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23221 }
23222 {
23223 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23224 }
23225 {
23226 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23227 }
23228 {
23229 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23230 }
23231 {
23232 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23233 }
23234 {
23235 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23236 }
23237 {
23238 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23239 }
23240 {
23241 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23242 }
23243 {
23244 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23245 }
23246 {
23247 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23248 }
23249 {
23250 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23251 }
23252 {
23253 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23254 }
23255 {
23256 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23257 }
23258 {
23259 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23260 }
23261 {
23262 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23263 }
23264 {
23265 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23266 }
23267 {
23268 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23269 }
23270 {
23271 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23272 }
23273 {
23274 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23275 }
23276 {
23277 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23278 }
23279 {
23280 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23281 }
23282 {
23283 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23284 }
23285 {
23286 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23287 }
23288 {
23289 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23290 }
23291 {
23292 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23293 }
23294 {
23295 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23296 }
23297 {
23298 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23299 }
23300 {
23301 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23302 }
23303 {
23304 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23305 }
23306 {
23307 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23308 }
23309 {
23310 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23311 }
23312 {
23313 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23314 }
23315 {
23316 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23317 }
23318 {
23319 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23320 }
23321 {
23322 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23323 }
23324 {
23325 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23326 }
23327 {
23328 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23329 }
23330 {
23331 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23332 }
23333 {
23334 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23335 }
23336 {
23337 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23338 }
23339 {
23340 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23341 }
23342 {
23343 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23344 }
23345 {
23346 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23347 }
23348 {
23349 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23350 }
23351 {
23352 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23353 }
23354 {
23355 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23356 }
23357 {
23358 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23359 }
23360 {
23361 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23362 }
23363 {
23364 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23365 }
23366 {
23367 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23368 }
23369 {
23370 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23371 }
23372 {
23373 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23374 }
23375 {
23376 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23377 }
23378 {
23379 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23380 }
23381 {
23382 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23383 }
23384 {
23385 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23386 }
23387 {
23388 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23389 }
23390 {
23391 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23392 }
23393 {
23394 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23395 }
23396 {
23397 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23398 }
23399 {
23400 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23401 }
23402 {
23403 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23404 }
23405 {
23406 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23407 }
23408 {
23409 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23410 }
23411 {
23412 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23413 }
23414 {
23415 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23416 }
23417 {
23418 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23419 }
23420 {
23421 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23422 }
23423 {
23424 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23425 }
23426 {
23427 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23428 }
23429 {
23430 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23431 }
23432 {
23433 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23434 }
23435 {
23436 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23437 }
23438 {
23439 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23440 }
23441 {
23442 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23443 }
23444 {
23445 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23446 }
23447 {
23448 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23449 }
23450 {
23451 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23452 }
23453 {
23454 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23455 }
23456 {
23457 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23458 }
23459 {
23460 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23461 }
23462 {
23463 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23464 }
23465 {
23466 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23467 }
23468 {
23469 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23470 }
23471 {
23472 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23473 }
23474 {
23475 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23476 }
23477 {
23478 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23479 }
23480 {
23481 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23482 }
23483 {
23484 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23485 }
23486 {
23487 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23488 }
23489 {
23490 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23491 }
23492 {
23493 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23494 }
23495 {
23496 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23497 }
23498 {
23499 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23500 }
23501 {
23502 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23503 }
23504 {
23505 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23506 }
23507 {
23508 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23509 }
23510 {
23511 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23512 }
23513 {
23514 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23515 }
23516 {
23517 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23518 }
23519 {
23520 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23521 }
23522 {
23523 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23524 }
23525 {
23526 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23527 }
23528 {
23529 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23530 }
23531 {
23532 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23533 }
23534 {
23535 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23536 }
23537 {
23538 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23539 }
23540 {
23541 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23542 }
23543 {
23544 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23545 }
23546 {
23547 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23548 }
23549 {
23550 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23551 }
23552 {
23553 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23554 }
23555 {
23556 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23557 }
23558 {
23559 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23560 }
23561 {
23562 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23563 }
23564 {
23565 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23566 }
23567 {
23568 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23569 }
23570 {
23571 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23572 }
23573 {
23574 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23575 }
23576 {
23577 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23578 }
23579 {
23580 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23581 }
23582 {
23583 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23584 }
23585 {
23586 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23587 }
23588 {
23589 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23590 }
23591 {
23592 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23593 }
23594 {
23595 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23596 }
23597 {
23598 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23599 }
23600 {
23601 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23602 }
23603 {
23604 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23605 }
23606 {
23607 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23608 }
23609 {
23610 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23611 }
23612 {
23613 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23614 }
23615 {
23616 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23617 }
23618 {
23619 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23620 }
23621 {
23622 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23623 }
23624 {
23625 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23626 }
23627 {
23628 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23629 }
23630 {
23631 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23632 }
23633 {
23634 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23635 }
23636 {
23637 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23638 }
23639 {
23640 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23641 }
23642 {
23643 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23644 }
23645 {
23646 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23647 }
23648 {
23649 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23650 }
23651 {
23652 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23653 }
23654 {
23655 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23656 }
23657 {
23658 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23659 }
23660 {
23661 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23662 }
23663 {
23664 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23665 }
23666 {
23667 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23668 }
23669 {
23670 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23671 }
23672 {
23673 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23674 }
23675 {
23676 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23677 }
23678 {
23679 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23680 }
23681 {
23682 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23683 }
23684 {
23685 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23686 }
23687 {
23688 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23689 }
23690 {
23691 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23692 }
23693 {
23694 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23695 }
23696 {
23697 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23698 }
23699 {
23700 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23701 }
23702 {
23703 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23704 }
23705 {
23706 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23707 }
23708 {
23709 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23710 }
23711 {
23712 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23713 }
23714 {
23715 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23716 }
23717 {
23718 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23719 }
23720 {
23721 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23722 }
23723 {
23724 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23725 }
23726 {
23727 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23728 }
23729 {
23730 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23731 }
23732 {
23733 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23734 }
23735 {
23736 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23737 }
23738 {
23739 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23740 }
23741 {
23742 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23743 }
23744 {
23745 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23746 }
23747 {
23748 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23749 }
23750 {
23751 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23752 }
23753 {
23754 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23755 }
23756 {
23757 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23758 }
23759 {
23760 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23761 }
23762 {
23763 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23764 }
23765 {
23766 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23767 }
23768 {
23769 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23770 }
23771 {
23772 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23773 }
23774 {
23775 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23776 }
23777 {
23778 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23779 }
23780 {
23781 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23782 }
23783 {
23784 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23785 }
23786 {
23787 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23788 }
23789 {
23790 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23791 }
23792 {
23793 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23794 }
23795 {
23796 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23797 }
23798 {
23799 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23800 }
23801 {
23802 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23803 }
23804 {
23805 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23806 }
23807 {
23808 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23809 }
23810 {
23811 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23812 }
23813 {
23814 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23815 }
23816 {
23817 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23818 }
23819 {
23820 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23821 }
23822 {
23823 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23824 }
23825 {
23826 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23827 }
23828 {
23829 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23830 }
23831 {
23832 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23833 }
23834 {
23835 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23836 }
23837 {
23838 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23839 }
23840 {
23841 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23842 }
23843 {
23844 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23845 }
23846 {
23847 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23848 }
23849 {
23850 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23851 }
23852 {
23853 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23854 }
23855 {
23856 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23857 }
23858 {
23859 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23860 }
23861 {
23862 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23863 }
23864 {
23865 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23866 }
23867 {
23868 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23869 }
23870 {
23871 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23872 }
23873 {
23874 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23875 }
23876 {
23877 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23878 }
23879 {
23880 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23881 }
23882 {
23883 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23884 }
23885 {
23886 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23887 }
23888 {
23889 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23890 }
23891 {
23892 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23893 }
23894 {
23895 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23896 }
23897 {
23898 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23899 }
23900 {
23901 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23902 }
23903 {
23904 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23905 }
23906 {
23907 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23908 }
23909 {
23910 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23911 }
23912 {
23913 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23914 }
23915 {
23916 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23917 }
23918 {
23919 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23920 }
23921 {
23922 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23923 }
23924 {
23925 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23926 }
23927 {
23928 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23929 }
23930 {
23931 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23932 }
23933 {
23934 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23935 }
23936 {
23937 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23938 }
23939 {
23940 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23941 }
23942 {
23943 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23944 }
23945 {
23946 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23947 }
23948 {
23949 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23950 }
23951 {
23952 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23953 }
23954 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23955 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23956 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23957 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23958 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23959 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23960 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23961 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23962 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23963 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23964 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23965 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23966 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23967 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23968 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23969 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23970 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23971 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23972 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23973 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23974 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23975 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23976 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23977 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23978 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23979 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23980 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23981 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23982 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23983 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23984 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23985 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23986 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23987 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23988 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23989 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23990 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23991 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23992 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23993 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23994 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23995 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23996 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23997 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23998 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23999 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24000 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24001 {
24002 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
24003 }
24004 {
24005 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
24006 }
24007 {
24008 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
24009 }
24010 {
24011 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
24012 }
24013 {
24014 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
24015 }
24016 {
24017 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
24018 }
24019 {
24020 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
24021 }
24022 {
24023 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
24024 }
24025 {
24026 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
24027 }
24028 {
24029 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
24030 }
24031 {
24032 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
24033 }
24034 {
24035 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
24036 }
24037 {
24038 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
24039 }
24040 {
24041 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
24042 }
24043 {
24044 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
24045 }
24046
24047 // Work around a chicken/egg problem in drawlist.cpp
24048 wxPyDrawList_SetAPIPtr();
24049
24050 }
24051
wxWidgets (Impactor)