]> 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
Version
[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 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794 static wxSize wxBitmap_GetSize(wxBitmap *self){
1795 wxSize size(self->GetWidth(), self->GetHeight());
1796 return size;
1797 }
1798 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1799 wxMask *mask = new wxMask(*self, colour);
1800 self->SetMask(mask);
1801 }
1802 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1803 self->SetWidth(size.x);
1804 self->SetHeight(size.y);
1805 }
1806 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1807 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1808 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1809 if ( !colour.Ok() )
1810 return new wxMask(bitmap, *wxBLACK);
1811 else
1812 return new wxMask(bitmap, colour);
1813 }
1814
1815 #include <wx/iconbndl.h>
1816
1817 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1818 wxIcon* icon = new wxIcon();
1819 icon->CopyFromBitmap(bmp);
1820 return icon;
1821 }
1822 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1823 char** cArray = NULL;
1824 wxIcon* icon;
1825
1826 cArray = ConvertListOfStrings(listOfStrings);
1827 if (! cArray)
1828 return NULL;
1829 icon = new wxIcon(cArray);
1830 delete [] cArray;
1831 return icon;
1832 }
1833 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1834
1835
1836
1837 return new wxIconLocation(*filename);
1838
1839 }
1840 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1841
1842
1843
1844 // do nothing
1845
1846 }
1847 static int wxIconLocation_GetIndex(wxIconLocation *self){
1848
1849
1850
1851 return -1;
1852
1853 }
1854
1855 SWIGINTERNSHORT long
1856 SWIG_As_long(PyObject* obj)
1857 {
1858 long v;
1859 if (!SWIG_AsVal_long(obj, &v)) {
1860 /*
1861 this is needed to make valgrind/purify happier.
1862 */
1863 memset((void*)&v, 0, sizeof(long));
1864 }
1865 return v;
1866 }
1867
1868
1869 SWIGINTERNSHORT int
1870 SWIG_Check_long(PyObject* obj)
1871 {
1872 return SWIG_AsVal_long(obj, (long*)0);
1873 }
1874
1875 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1876 #ifdef __WXGTK__
1877 wxImage img(cursorName, type);
1878 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1880 return new wxCursor(img);
1881 #else
1882 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1883 #endif
1884 }
1885
1886
1887 static void wxRegionIterator_Next(wxRegionIterator *self){
1888 (*self) ++;
1889 }
1890 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1891 return self->operator bool();
1892 }
1893
1894 #include <wx/fontutil.h>
1895 #include <wx/fontmap.h>
1896 #include <wx/fontenum.h>
1897
1898 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1899 return self->ToString();
1900 }
1901
1902 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1903 static wxNativeEncodingInfo info;
1904 if ( wxGetNativeFontEncoding(encoding, &info) )
1905 return &info;
1906 else
1907 return NULL;
1908 }
1909
1910 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1911 wxFontEncoding alt_enc;
1912 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1913 return PyInt_FromLong(alt_enc);
1914 else {
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918 }
1919 static wxFont *new_wxFont(wxString const &info){
1920 wxNativeFontInfo nfi;
1921 nfi.FromString(info);
1922 return new wxFont(nfi);
1923 }
1924 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1925 return wxFont::New(pointSize, family, flags, face, encoding);
1926 }
1927 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1928 return wxFontBase::New(pixelSize, family,
1929 style, weight, underlined,
1930 face, encoding);
1931 }
1932 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1933 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1934
1935 class wxPyFontEnumerator : public wxFontEnumerator {
1936 public:
1937 wxPyFontEnumerator() {}
1938 ~wxPyFontEnumerator() {}
1939
1940 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1941 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1942
1943 PYPRIVATE;
1944 };
1945
1946 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1947 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1948
1949
1950 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1951 wxArrayString* arr = self->GetEncodings();
1952 if (arr)
1953 return wxArrayString2PyList_helper(*arr);
1954 else
1955 return PyList_New(0);
1956 }
1957 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1958 wxArrayString* arr = self->GetFacenames();
1959 if (arr)
1960 return wxArrayString2PyList_helper(*arr);
1961 else
1962 return PyList_New(0);
1963 }
1964
1965 #include <locale.h>
1966
1967 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1968 wxLocale* loc;
1969 if (language == -1)
1970 loc = new wxLocale();
1971 else
1972 loc = new wxLocale(language, flags);
1973 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1974 // for the floating point conversions and such to work right.
1975 #if PY_VERSION_HEX < 0x02040000
1976 setlocale(LC_NUMERIC, "C");
1977 #endif
1978 return loc;
1979 }
1980 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1981 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1982 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1983 // for the floating point conversions and such to work right.
1984 #if PY_VERSION_HEX < 0x02040000
1985 setlocale(LC_NUMERIC, "C");
1986 #endif
1987 return rc;
1988 }
1989 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1990 bool rc = self->Init(language, flags);
1991 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1992 // for the floating point conversions and such to work right.
1993 #if PY_VERSION_HEX < 0x02040000
1994 setlocale(LC_NUMERIC, "C");
1995 #endif
1996 return rc;
1997 }
1998
1999 #include "wx/wxPython/pydrawxxx.h"
2000
2001 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2002 wxColour col;
2003 self->GetPixel(x, y, &col);
2004 return col;
2005 }
2006 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2007 wxColour col;
2008 self->GetPixel(pt, &col);
2009 return col;
2010 }
2011
2012 SWIGINTERN int
2013 SWIG_AsVal_double(PyObject *obj, double* val)
2014 {
2015 if (PyNumber_Check(obj)) {
2016 if (val) *val = PyFloat_AsDouble(obj);
2017 return 1;
2018 }
2019 else {
2020 SWIG_type_error("number", obj);
2021 }
2022 return 0;
2023 }
2024
2025
2026 SWIGINTERNSHORT double
2027 SWIG_As_double(PyObject* obj)
2028 {
2029 double v;
2030 if (!SWIG_AsVal_double(obj, &v)) {
2031 /*
2032 this is needed to make valgrind/purify happier.
2033 */
2034 memset((void*)&v, 0, sizeof(double));
2035 }
2036 return v;
2037 }
2038
2039
2040 SWIGINTERNSHORT int
2041 SWIG_Check_double(PyObject* obj)
2042 {
2043 return SWIG_AsVal_double(obj, (double*)0);
2044 }
2045
2046 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2047 wxRect rv;
2048 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2049 return rv;
2050 }
2051
2052 static wxRect wxDC_GetClippingRect(wxDC *self){
2053 wxRect rect;
2054 self->GetClippingBox(rect);
2055 return rect;
2056 }
2057 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2058 wxArrayInt widths;
2059 self->GetPartialTextExtents(text, widths);
2060 return widths;
2061 }
2062
2063 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2064 #define SWIG_From_double PyFloat_FromDouble
2065 /*@@*/
2066
2067
2068 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2069 self->SetLogicalOrigin(point.x, point.y);
2070 }
2071 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2072 self->SetDeviceOrigin(point.x, point.y);
2073 }
2074 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2075 self->CalcBoundingBox(point.x, point.y);
2076 }
2077 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2078 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2079 }
2080 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2081 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2082 }
2083 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2084 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2085 }
2086 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2087 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2088 }
2089 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2090 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2091 }
2092 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2093 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2094 }
2095
2096 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2097 *x1 = dc->MinX();
2098 *y1 = dc->MinY();
2099 *x2 = dc->MaxX();
2100 *y2 = dc->MaxY();
2101 }
2102
2103
2104 #include <wx/dcbuffer.h>
2105
2106
2107 #include <wx/dcps.h>
2108
2109
2110 class wxMetaFile : public wxObject {
2111 public:
2112 wxMetaFile(const wxString&)
2113 { wxPyRaiseNotImplemented(); }
2114 };
2115
2116 class wxMetaFileDC : public wxClientDC {
2117 public:
2118 wxMetaFileDC(const wxString&, int, int, const wxString&)
2119 { wxPyRaiseNotImplemented(); }
2120 };
2121
2122
2123
2124 class wxPrinterDC : public wxClientDC {
2125 public:
2126 wxPrinterDC(const wxPrintData&)
2127 { wxPyRaiseNotImplemented(); }
2128
2129 };
2130
2131
2132
2133 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2134 self->AddColour(name, wxColour(red, green, blue));
2135 }
2136
2137 #include <wx/effects.h>
2138
2139 #ifdef __cplusplus
2140 extern "C" {
2141 #endif
2142 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2143 PyObject *resultobj;
2144 wxGDIObject *result;
2145 char *kwnames[] = {
2146 NULL
2147 };
2148
2149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2150 {
2151 if (!wxPyCheckForApp()) SWIG_fail;
2152 PyThreadState* __tstate = wxPyBeginAllowThreads();
2153 result = (wxGDIObject *)new wxGDIObject();
2154
2155 wxPyEndAllowThreads(__tstate);
2156 if (PyErr_Occurred()) SWIG_fail;
2157 }
2158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2159 return resultobj;
2160 fail:
2161 return NULL;
2162 }
2163
2164
2165 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2166 PyObject *resultobj;
2167 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2168 PyObject * obj0 = 0 ;
2169 char *kwnames[] = {
2170 (char *) "self", NULL
2171 };
2172
2173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2175 if (SWIG_arg_fail(1)) SWIG_fail;
2176 {
2177 PyThreadState* __tstate = wxPyBeginAllowThreads();
2178 delete arg1;
2179
2180 wxPyEndAllowThreads(__tstate);
2181 if (PyErr_Occurred()) SWIG_fail;
2182 }
2183 Py_INCREF(Py_None); resultobj = Py_None;
2184 return resultobj;
2185 fail:
2186 return NULL;
2187 }
2188
2189
2190 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2191 PyObject *resultobj;
2192 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2193 bool result;
2194 PyObject * obj0 = 0 ;
2195 char *kwnames[] = {
2196 (char *) "self", NULL
2197 };
2198
2199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2201 if (SWIG_arg_fail(1)) SWIG_fail;
2202 {
2203 PyThreadState* __tstate = wxPyBeginAllowThreads();
2204 result = (bool)(arg1)->GetVisible();
2205
2206 wxPyEndAllowThreads(__tstate);
2207 if (PyErr_Occurred()) SWIG_fail;
2208 }
2209 {
2210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2211 }
2212 return resultobj;
2213 fail:
2214 return NULL;
2215 }
2216
2217
2218 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2219 PyObject *resultobj;
2220 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2221 bool arg2 ;
2222 PyObject * obj0 = 0 ;
2223 PyObject * obj1 = 0 ;
2224 char *kwnames[] = {
2225 (char *) "self",(char *) "visible", NULL
2226 };
2227
2228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2230 if (SWIG_arg_fail(1)) SWIG_fail;
2231 {
2232 arg2 = (bool)(SWIG_As_bool(obj1));
2233 if (SWIG_arg_fail(2)) SWIG_fail;
2234 }
2235 {
2236 PyThreadState* __tstate = wxPyBeginAllowThreads();
2237 (arg1)->SetVisible(arg2);
2238
2239 wxPyEndAllowThreads(__tstate);
2240 if (PyErr_Occurred()) SWIG_fail;
2241 }
2242 Py_INCREF(Py_None); resultobj = Py_None;
2243 return resultobj;
2244 fail:
2245 return NULL;
2246 }
2247
2248
2249 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2250 PyObject *resultobj;
2251 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2252 bool result;
2253 PyObject * obj0 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2260 if (SWIG_arg_fail(1)) SWIG_fail;
2261 {
2262 PyThreadState* __tstate = wxPyBeginAllowThreads();
2263 result = (bool)(arg1)->IsNull();
2264
2265 wxPyEndAllowThreads(__tstate);
2266 if (PyErr_Occurred()) SWIG_fail;
2267 }
2268 {
2269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2270 }
2271 return resultobj;
2272 fail:
2273 return NULL;
2274 }
2275
2276
2277 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2278 PyObject *obj;
2279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2280 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2281 Py_INCREF(obj);
2282 return Py_BuildValue((char *)"");
2283 }
2284 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2285 PyObject *resultobj;
2286 byte arg1 = (byte) 0 ;
2287 byte arg2 = (byte) 0 ;
2288 byte arg3 = (byte) 0 ;
2289 wxColour *result;
2290 PyObject * obj0 = 0 ;
2291 PyObject * obj1 = 0 ;
2292 PyObject * obj2 = 0 ;
2293 char *kwnames[] = {
2294 (char *) "red",(char *) "green",(char *) "blue", NULL
2295 };
2296
2297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2298 if (obj0) {
2299 {
2300 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2301 if (SWIG_arg_fail(1)) SWIG_fail;
2302 }
2303 }
2304 if (obj1) {
2305 {
2306 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2307 if (SWIG_arg_fail(2)) SWIG_fail;
2308 }
2309 }
2310 if (obj2) {
2311 {
2312 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2313 if (SWIG_arg_fail(3)) SWIG_fail;
2314 }
2315 }
2316 {
2317 PyThreadState* __tstate = wxPyBeginAllowThreads();
2318 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2319
2320 wxPyEndAllowThreads(__tstate);
2321 if (PyErr_Occurred()) SWIG_fail;
2322 }
2323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2324 return resultobj;
2325 fail:
2326 return NULL;
2327 }
2328
2329
2330 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2331 PyObject *resultobj;
2332 wxString *arg1 = 0 ;
2333 wxColour *result;
2334 bool temp1 = false ;
2335 PyObject * obj0 = 0 ;
2336 char *kwnames[] = {
2337 (char *) "colorName", NULL
2338 };
2339
2340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2341 {
2342 arg1 = wxString_in_helper(obj0);
2343 if (arg1 == NULL) SWIG_fail;
2344 temp1 = true;
2345 }
2346 {
2347 if (!wxPyCheckForApp()) SWIG_fail;
2348 PyThreadState* __tstate = wxPyBeginAllowThreads();
2349 result = (wxColour *)new wxColour((wxString const &)*arg1);
2350
2351 wxPyEndAllowThreads(__tstate);
2352 if (PyErr_Occurred()) SWIG_fail;
2353 }
2354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2355 {
2356 if (temp1)
2357 delete arg1;
2358 }
2359 return resultobj;
2360 fail:
2361 {
2362 if (temp1)
2363 delete arg1;
2364 }
2365 return NULL;
2366 }
2367
2368
2369 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2370 PyObject *resultobj;
2371 unsigned long arg1 ;
2372 wxColour *result;
2373 PyObject * obj0 = 0 ;
2374 char *kwnames[] = {
2375 (char *) "colRGB", NULL
2376 };
2377
2378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2379 {
2380 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2381 if (SWIG_arg_fail(1)) SWIG_fail;
2382 }
2383 {
2384 PyThreadState* __tstate = wxPyBeginAllowThreads();
2385 result = (wxColour *)new wxColour(arg1);
2386
2387 wxPyEndAllowThreads(__tstate);
2388 if (PyErr_Occurred()) SWIG_fail;
2389 }
2390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2391 return resultobj;
2392 fail:
2393 return NULL;
2394 }
2395
2396
2397 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2398 PyObject *resultobj;
2399 wxColour *arg1 = (wxColour *) 0 ;
2400 PyObject * obj0 = 0 ;
2401 char *kwnames[] = {
2402 (char *) "self", NULL
2403 };
2404
2405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2407 if (SWIG_arg_fail(1)) SWIG_fail;
2408 {
2409 PyThreadState* __tstate = wxPyBeginAllowThreads();
2410 delete arg1;
2411
2412 wxPyEndAllowThreads(__tstate);
2413 if (PyErr_Occurred()) SWIG_fail;
2414 }
2415 Py_INCREF(Py_None); resultobj = Py_None;
2416 return resultobj;
2417 fail:
2418 return NULL;
2419 }
2420
2421
2422 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2423 PyObject *resultobj;
2424 wxColour *arg1 = (wxColour *) 0 ;
2425 byte result;
2426 PyObject * obj0 = 0 ;
2427 char *kwnames[] = {
2428 (char *) "self", NULL
2429 };
2430
2431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2433 if (SWIG_arg_fail(1)) SWIG_fail;
2434 {
2435 PyThreadState* __tstate = wxPyBeginAllowThreads();
2436 result = (byte)(arg1)->Red();
2437
2438 wxPyEndAllowThreads(__tstate);
2439 if (PyErr_Occurred()) SWIG_fail;
2440 }
2441 {
2442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2443 }
2444 return resultobj;
2445 fail:
2446 return NULL;
2447 }
2448
2449
2450 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2451 PyObject *resultobj;
2452 wxColour *arg1 = (wxColour *) 0 ;
2453 byte result;
2454 PyObject * obj0 = 0 ;
2455 char *kwnames[] = {
2456 (char *) "self", NULL
2457 };
2458
2459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2461 if (SWIG_arg_fail(1)) SWIG_fail;
2462 {
2463 PyThreadState* __tstate = wxPyBeginAllowThreads();
2464 result = (byte)(arg1)->Green();
2465
2466 wxPyEndAllowThreads(__tstate);
2467 if (PyErr_Occurred()) SWIG_fail;
2468 }
2469 {
2470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2471 }
2472 return resultobj;
2473 fail:
2474 return NULL;
2475 }
2476
2477
2478 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2479 PyObject *resultobj;
2480 wxColour *arg1 = (wxColour *) 0 ;
2481 byte result;
2482 PyObject * obj0 = 0 ;
2483 char *kwnames[] = {
2484 (char *) "self", NULL
2485 };
2486
2487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2489 if (SWIG_arg_fail(1)) SWIG_fail;
2490 {
2491 PyThreadState* __tstate = wxPyBeginAllowThreads();
2492 result = (byte)(arg1)->Blue();
2493
2494 wxPyEndAllowThreads(__tstate);
2495 if (PyErr_Occurred()) SWIG_fail;
2496 }
2497 {
2498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2499 }
2500 return resultobj;
2501 fail:
2502 return NULL;
2503 }
2504
2505
2506 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2507 PyObject *resultobj;
2508 wxColour *arg1 = (wxColour *) 0 ;
2509 bool result;
2510 PyObject * obj0 = 0 ;
2511 char *kwnames[] = {
2512 (char *) "self", NULL
2513 };
2514
2515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2517 if (SWIG_arg_fail(1)) SWIG_fail;
2518 {
2519 PyThreadState* __tstate = wxPyBeginAllowThreads();
2520 result = (bool)(arg1)->Ok();
2521
2522 wxPyEndAllowThreads(__tstate);
2523 if (PyErr_Occurred()) SWIG_fail;
2524 }
2525 {
2526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2527 }
2528 return resultobj;
2529 fail:
2530 return NULL;
2531 }
2532
2533
2534 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2535 PyObject *resultobj;
2536 wxColour *arg1 = (wxColour *) 0 ;
2537 byte arg2 ;
2538 byte arg3 ;
2539 byte arg4 ;
2540 PyObject * obj0 = 0 ;
2541 PyObject * obj1 = 0 ;
2542 PyObject * obj2 = 0 ;
2543 PyObject * obj3 = 0 ;
2544 char *kwnames[] = {
2545 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2546 };
2547
2548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2550 if (SWIG_arg_fail(1)) SWIG_fail;
2551 {
2552 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2553 if (SWIG_arg_fail(2)) SWIG_fail;
2554 }
2555 {
2556 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2557 if (SWIG_arg_fail(3)) SWIG_fail;
2558 }
2559 {
2560 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2561 if (SWIG_arg_fail(4)) SWIG_fail;
2562 }
2563 {
2564 PyThreadState* __tstate = wxPyBeginAllowThreads();
2565 (arg1)->Set(arg2,arg3,arg4);
2566
2567 wxPyEndAllowThreads(__tstate);
2568 if (PyErr_Occurred()) SWIG_fail;
2569 }
2570 Py_INCREF(Py_None); resultobj = Py_None;
2571 return resultobj;
2572 fail:
2573 return NULL;
2574 }
2575
2576
2577 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2578 PyObject *resultobj;
2579 wxColour *arg1 = (wxColour *) 0 ;
2580 unsigned long arg2 ;
2581 PyObject * obj0 = 0 ;
2582 PyObject * obj1 = 0 ;
2583 char *kwnames[] = {
2584 (char *) "self",(char *) "colRGB", NULL
2585 };
2586
2587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2589 if (SWIG_arg_fail(1)) SWIG_fail;
2590 {
2591 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2592 if (SWIG_arg_fail(2)) SWIG_fail;
2593 }
2594 {
2595 PyThreadState* __tstate = wxPyBeginAllowThreads();
2596 (arg1)->Set(arg2);
2597
2598 wxPyEndAllowThreads(__tstate);
2599 if (PyErr_Occurred()) SWIG_fail;
2600 }
2601 Py_INCREF(Py_None); resultobj = Py_None;
2602 return resultobj;
2603 fail:
2604 return NULL;
2605 }
2606
2607
2608 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2609 PyObject *resultobj;
2610 wxColour *arg1 = (wxColour *) 0 ;
2611 wxString *arg2 = 0 ;
2612 bool temp2 = false ;
2613 PyObject * obj0 = 0 ;
2614 PyObject * obj1 = 0 ;
2615 char *kwnames[] = {
2616 (char *) "self",(char *) "colourName", NULL
2617 };
2618
2619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2621 if (SWIG_arg_fail(1)) SWIG_fail;
2622 {
2623 arg2 = wxString_in_helper(obj1);
2624 if (arg2 == NULL) SWIG_fail;
2625 temp2 = true;
2626 }
2627 {
2628 PyThreadState* __tstate = wxPyBeginAllowThreads();
2629 (arg1)->InitFromName((wxString const &)*arg2);
2630
2631 wxPyEndAllowThreads(__tstate);
2632 if (PyErr_Occurred()) SWIG_fail;
2633 }
2634 Py_INCREF(Py_None); resultobj = Py_None;
2635 {
2636 if (temp2)
2637 delete arg2;
2638 }
2639 return resultobj;
2640 fail:
2641 {
2642 if (temp2)
2643 delete arg2;
2644 }
2645 return NULL;
2646 }
2647
2648
2649 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2650 PyObject *resultobj;
2651 wxColour *arg1 = (wxColour *) 0 ;
2652 long result;
2653 PyObject * obj0 = 0 ;
2654 char *kwnames[] = {
2655 (char *) "self", NULL
2656 };
2657
2658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2660 if (SWIG_arg_fail(1)) SWIG_fail;
2661 {
2662 PyThreadState* __tstate = wxPyBeginAllowThreads();
2663 result = (long)((wxColour const *)arg1)->GetPixel();
2664
2665 wxPyEndAllowThreads(__tstate);
2666 if (PyErr_Occurred()) SWIG_fail;
2667 }
2668 {
2669 resultobj = SWIG_From_long((long)(result));
2670 }
2671 return resultobj;
2672 fail:
2673 return NULL;
2674 }
2675
2676
2677 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2678 PyObject *resultobj;
2679 wxColour *arg1 = (wxColour *) 0 ;
2680 wxColour *arg2 = 0 ;
2681 bool result;
2682 wxColour temp2 ;
2683 PyObject * obj0 = 0 ;
2684 PyObject * obj1 = 0 ;
2685 char *kwnames[] = {
2686 (char *) "self",(char *) "colour", NULL
2687 };
2688
2689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2691 if (SWIG_arg_fail(1)) SWIG_fail;
2692 {
2693 arg2 = &temp2;
2694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2695 }
2696 {
2697 PyThreadState* __tstate = wxPyBeginAllowThreads();
2698 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2699
2700 wxPyEndAllowThreads(__tstate);
2701 if (PyErr_Occurred()) SWIG_fail;
2702 }
2703 {
2704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2705 }
2706 return resultobj;
2707 fail:
2708 return NULL;
2709 }
2710
2711
2712 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2713 PyObject *resultobj;
2714 wxColour *arg1 = (wxColour *) 0 ;
2715 wxColour *arg2 = 0 ;
2716 bool result;
2717 wxColour temp2 ;
2718 PyObject * obj0 = 0 ;
2719 PyObject * obj1 = 0 ;
2720 char *kwnames[] = {
2721 (char *) "self",(char *) "colour", NULL
2722 };
2723
2724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2726 if (SWIG_arg_fail(1)) SWIG_fail;
2727 {
2728 arg2 = &temp2;
2729 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2730 }
2731 {
2732 PyThreadState* __tstate = wxPyBeginAllowThreads();
2733 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2734
2735 wxPyEndAllowThreads(__tstate);
2736 if (PyErr_Occurred()) SWIG_fail;
2737 }
2738 {
2739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2740 }
2741 return resultobj;
2742 fail:
2743 return NULL;
2744 }
2745
2746
2747 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2748 PyObject *resultobj;
2749 wxColour *arg1 = (wxColour *) 0 ;
2750 PyObject *result;
2751 PyObject * obj0 = 0 ;
2752 char *kwnames[] = {
2753 (char *) "self", NULL
2754 };
2755
2756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2758 if (SWIG_arg_fail(1)) SWIG_fail;
2759 {
2760 PyThreadState* __tstate = wxPyBeginAllowThreads();
2761 result = (PyObject *)wxColour_Get(arg1);
2762
2763 wxPyEndAllowThreads(__tstate);
2764 if (PyErr_Occurred()) SWIG_fail;
2765 }
2766 resultobj = result;
2767 return resultobj;
2768 fail:
2769 return NULL;
2770 }
2771
2772
2773 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2774 PyObject *resultobj;
2775 wxColour *arg1 = (wxColour *) 0 ;
2776 unsigned long result;
2777 PyObject * obj0 = 0 ;
2778 char *kwnames[] = {
2779 (char *) "self", NULL
2780 };
2781
2782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2784 if (SWIG_arg_fail(1)) SWIG_fail;
2785 {
2786 PyThreadState* __tstate = wxPyBeginAllowThreads();
2787 result = (unsigned long)wxColour_GetRGB(arg1);
2788
2789 wxPyEndAllowThreads(__tstate);
2790 if (PyErr_Occurred()) SWIG_fail;
2791 }
2792 {
2793 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2794 }
2795 return resultobj;
2796 fail:
2797 return NULL;
2798 }
2799
2800
2801 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2802 PyObject *obj;
2803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2804 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2805 Py_INCREF(obj);
2806 return Py_BuildValue((char *)"");
2807 }
2808 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2809 PyObject *resultobj;
2810 int arg1 ;
2811 unsigned char *arg2 = (unsigned char *) 0 ;
2812 unsigned char *arg3 = (unsigned char *) 0 ;
2813 unsigned char *arg4 = (unsigned char *) 0 ;
2814 wxPalette *result;
2815 PyObject * obj0 = 0 ;
2816 PyObject * obj1 = 0 ;
2817 PyObject * obj2 = 0 ;
2818 PyObject * obj3 = 0 ;
2819 char *kwnames[] = {
2820 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2821 };
2822
2823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2824 {
2825 arg1 = (int)(SWIG_As_int(obj0));
2826 if (SWIG_arg_fail(1)) SWIG_fail;
2827 }
2828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2829 if (SWIG_arg_fail(2)) SWIG_fail;
2830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(3)) SWIG_fail;
2832 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2833 if (SWIG_arg_fail(4)) SWIG_fail;
2834 {
2835 if (!wxPyCheckForApp()) SWIG_fail;
2836 PyThreadState* __tstate = wxPyBeginAllowThreads();
2837 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2838
2839 wxPyEndAllowThreads(__tstate);
2840 if (PyErr_Occurred()) SWIG_fail;
2841 }
2842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2843 return resultobj;
2844 fail:
2845 return NULL;
2846 }
2847
2848
2849 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2850 PyObject *resultobj;
2851 wxPalette *arg1 = (wxPalette *) 0 ;
2852 PyObject * obj0 = 0 ;
2853 char *kwnames[] = {
2854 (char *) "self", NULL
2855 };
2856
2857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(1)) SWIG_fail;
2860 {
2861 PyThreadState* __tstate = wxPyBeginAllowThreads();
2862 delete arg1;
2863
2864 wxPyEndAllowThreads(__tstate);
2865 if (PyErr_Occurred()) SWIG_fail;
2866 }
2867 Py_INCREF(Py_None); resultobj = Py_None;
2868 return resultobj;
2869 fail:
2870 return NULL;
2871 }
2872
2873
2874 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2875 PyObject *resultobj;
2876 wxPalette *arg1 = (wxPalette *) 0 ;
2877 byte arg2 ;
2878 byte arg3 ;
2879 byte arg4 ;
2880 int result;
2881 PyObject * obj0 = 0 ;
2882 PyObject * obj1 = 0 ;
2883 PyObject * obj2 = 0 ;
2884 PyObject * obj3 = 0 ;
2885 char *kwnames[] = {
2886 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2887 };
2888
2889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 {
2893 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2894 if (SWIG_arg_fail(2)) SWIG_fail;
2895 }
2896 {
2897 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2898 if (SWIG_arg_fail(3)) SWIG_fail;
2899 }
2900 {
2901 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2902 if (SWIG_arg_fail(4)) SWIG_fail;
2903 }
2904 {
2905 PyThreadState* __tstate = wxPyBeginAllowThreads();
2906 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2907
2908 wxPyEndAllowThreads(__tstate);
2909 if (PyErr_Occurred()) SWIG_fail;
2910 }
2911 {
2912 resultobj = SWIG_From_int((int)(result));
2913 }
2914 return resultobj;
2915 fail:
2916 return NULL;
2917 }
2918
2919
2920 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2921 PyObject *resultobj;
2922 wxPalette *arg1 = (wxPalette *) 0 ;
2923 int arg2 ;
2924 byte *arg3 = (byte *) 0 ;
2925 byte *arg4 = (byte *) 0 ;
2926 byte *arg5 = (byte *) 0 ;
2927 bool result;
2928 byte temp3 ;
2929 int res3 = 0 ;
2930 byte temp4 ;
2931 int res4 = 0 ;
2932 byte temp5 ;
2933 int res5 = 0 ;
2934 PyObject * obj0 = 0 ;
2935 PyObject * obj1 = 0 ;
2936 char *kwnames[] = {
2937 (char *) "self",(char *) "pixel", NULL
2938 };
2939
2940 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2941 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2942 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2945 if (SWIG_arg_fail(1)) SWIG_fail;
2946 {
2947 arg2 = (int)(SWIG_As_int(obj1));
2948 if (SWIG_arg_fail(2)) SWIG_fail;
2949 }
2950 {
2951 PyThreadState* __tstate = wxPyBeginAllowThreads();
2952 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2953
2954 wxPyEndAllowThreads(__tstate);
2955 if (PyErr_Occurred()) SWIG_fail;
2956 }
2957 {
2958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2959 }
2960 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2961 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2962 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2963 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2964 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2965 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2966 return resultobj;
2967 fail:
2968 return NULL;
2969 }
2970
2971
2972 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2973 PyObject *resultobj;
2974 wxPalette *arg1 = (wxPalette *) 0 ;
2975 int result;
2976 PyObject * obj0 = 0 ;
2977 char *kwnames[] = {
2978 (char *) "self", NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2983 if (SWIG_arg_fail(1)) SWIG_fail;
2984 {
2985 PyThreadState* __tstate = wxPyBeginAllowThreads();
2986 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2987
2988 wxPyEndAllowThreads(__tstate);
2989 if (PyErr_Occurred()) SWIG_fail;
2990 }
2991 {
2992 resultobj = SWIG_From_int((int)(result));
2993 }
2994 return resultobj;
2995 fail:
2996 return NULL;
2997 }
2998
2999
3000 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3001 PyObject *resultobj;
3002 wxPalette *arg1 = (wxPalette *) 0 ;
3003 bool result;
3004 PyObject * obj0 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 {
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = (bool)(arg1)->Ok();
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3029 PyObject *obj;
3030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3031 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3032 Py_INCREF(obj);
3033 return Py_BuildValue((char *)"");
3034 }
3035 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3036 PyObject *resultobj;
3037 wxColour *arg1 = 0 ;
3038 int arg2 = (int) 1 ;
3039 int arg3 = (int) wxSOLID ;
3040 wxPen *result;
3041 wxColour temp1 ;
3042 PyObject * obj0 = 0 ;
3043 PyObject * obj1 = 0 ;
3044 PyObject * obj2 = 0 ;
3045 char *kwnames[] = {
3046 (char *) "colour",(char *) "width",(char *) "style", NULL
3047 };
3048
3049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3050 {
3051 arg1 = &temp1;
3052 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3053 }
3054 if (obj1) {
3055 {
3056 arg2 = (int)(SWIG_As_int(obj1));
3057 if (SWIG_arg_fail(2)) SWIG_fail;
3058 }
3059 }
3060 if (obj2) {
3061 {
3062 arg3 = (int)(SWIG_As_int(obj2));
3063 if (SWIG_arg_fail(3)) SWIG_fail;
3064 }
3065 }
3066 {
3067 if (!wxPyCheckForApp()) SWIG_fail;
3068 PyThreadState* __tstate = wxPyBeginAllowThreads();
3069 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3070
3071 wxPyEndAllowThreads(__tstate);
3072 if (PyErr_Occurred()) SWIG_fail;
3073 }
3074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3075 return resultobj;
3076 fail:
3077 return NULL;
3078 }
3079
3080
3081 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3082 PyObject *resultobj;
3083 wxPen *arg1 = (wxPen *) 0 ;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "self", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 {
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 delete arg1;
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 Py_INCREF(Py_None); resultobj = Py_None;
3100 return resultobj;
3101 fail:
3102 return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3107 PyObject *resultobj;
3108 wxPen *arg1 = (wxPen *) 0 ;
3109 int result;
3110 PyObject * obj0 = 0 ;
3111 char *kwnames[] = {
3112 (char *) "self", NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3117 if (SWIG_arg_fail(1)) SWIG_fail;
3118 {
3119 PyThreadState* __tstate = wxPyBeginAllowThreads();
3120 result = (int)(arg1)->GetCap();
3121
3122 wxPyEndAllowThreads(__tstate);
3123 if (PyErr_Occurred()) SWIG_fail;
3124 }
3125 {
3126 resultobj = SWIG_From_int((int)(result));
3127 }
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxPen *arg1 = (wxPen *) 0 ;
3137 wxColour result;
3138 PyObject * obj0 = 0 ;
3139 char *kwnames[] = {
3140 (char *) "self", NULL
3141 };
3142
3143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 {
3147 PyThreadState* __tstate = wxPyBeginAllowThreads();
3148 result = (arg1)->GetColour();
3149
3150 wxPyEndAllowThreads(__tstate);
3151 if (PyErr_Occurred()) SWIG_fail;
3152 }
3153 {
3154 wxColour * resultptr;
3155 resultptr = new wxColour((wxColour &)(result));
3156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 int result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3175 if (SWIG_arg_fail(1)) SWIG_fail;
3176 {
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 result = (int)(arg1)->GetJoin();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 resultobj = SWIG_From_int((int)(result));
3185 }
3186 return resultobj;
3187 fail:
3188 return NULL;
3189 }
3190
3191
3192 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3193 PyObject *resultobj;
3194 wxPen *arg1 = (wxPen *) 0 ;
3195 int result;
3196 PyObject * obj0 = 0 ;
3197 char *kwnames[] = {
3198 (char *) "self", NULL
3199 };
3200
3201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3203 if (SWIG_arg_fail(1)) SWIG_fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (int)(arg1)->GetStyle();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 {
3212 resultobj = SWIG_From_int((int)(result));
3213 }
3214 return resultobj;
3215 fail:
3216 return NULL;
3217 }
3218
3219
3220 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3221 PyObject *resultobj;
3222 wxPen *arg1 = (wxPen *) 0 ;
3223 int result;
3224 PyObject * obj0 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "self", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3231 if (SWIG_arg_fail(1)) SWIG_fail;
3232 {
3233 PyThreadState* __tstate = wxPyBeginAllowThreads();
3234 result = (int)(arg1)->GetWidth();
3235
3236 wxPyEndAllowThreads(__tstate);
3237 if (PyErr_Occurred()) SWIG_fail;
3238 }
3239 {
3240 resultobj = SWIG_From_int((int)(result));
3241 }
3242 return resultobj;
3243 fail:
3244 return NULL;
3245 }
3246
3247
3248 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3249 PyObject *resultobj;
3250 wxPen *arg1 = (wxPen *) 0 ;
3251 bool result;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "self", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3259 if (SWIG_arg_fail(1)) SWIG_fail;
3260 {
3261 PyThreadState* __tstate = wxPyBeginAllowThreads();
3262 result = (bool)(arg1)->Ok();
3263
3264 wxPyEndAllowThreads(__tstate);
3265 if (PyErr_Occurred()) SWIG_fail;
3266 }
3267 {
3268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3269 }
3270 return resultobj;
3271 fail:
3272 return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxPen *arg1 = (wxPen *) 0 ;
3279 int arg2 ;
3280 PyObject * obj0 = 0 ;
3281 PyObject * obj1 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self",(char *) "cap_style", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 (arg1)->SetCap(arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 return resultobj;
3302 fail:
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxPen *arg1 = (wxPen *) 0 ;
3310 wxColour *arg2 = 0 ;
3311 wxColour temp2 ;
3312 PyObject * obj0 = 0 ;
3313 PyObject * obj1 = 0 ;
3314 char *kwnames[] = {
3315 (char *) "self",(char *) "colour", NULL
3316 };
3317
3318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3320 if (SWIG_arg_fail(1)) SWIG_fail;
3321 {
3322 arg2 = &temp2;
3323 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3324 }
3325 {
3326 PyThreadState* __tstate = wxPyBeginAllowThreads();
3327 (arg1)->SetColour(*arg2);
3328
3329 wxPyEndAllowThreads(__tstate);
3330 if (PyErr_Occurred()) SWIG_fail;
3331 }
3332 Py_INCREF(Py_None); resultobj = Py_None;
3333 return resultobj;
3334 fail:
3335 return NULL;
3336 }
3337
3338
3339 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj;
3341 wxPen *arg1 = (wxPen *) 0 ;
3342 int arg2 ;
3343 PyObject * obj0 = 0 ;
3344 PyObject * obj1 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "self",(char *) "join_style", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3351 if (SWIG_arg_fail(1)) SWIG_fail;
3352 {
3353 arg2 = (int)(SWIG_As_int(obj1));
3354 if (SWIG_arg_fail(2)) SWIG_fail;
3355 }
3356 {
3357 PyThreadState* __tstate = wxPyBeginAllowThreads();
3358 (arg1)->SetJoin(arg2);
3359
3360 wxPyEndAllowThreads(__tstate);
3361 if (PyErr_Occurred()) SWIG_fail;
3362 }
3363 Py_INCREF(Py_None); resultobj = Py_None;
3364 return resultobj;
3365 fail:
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxPen *arg1 = (wxPen *) 0 ;
3373 int arg2 ;
3374 PyObject * obj0 = 0 ;
3375 PyObject * obj1 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self",(char *) "style", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 {
3384 arg2 = (int)(SWIG_As_int(obj1));
3385 if (SWIG_arg_fail(2)) SWIG_fail;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 (arg1)->SetStyle(arg2);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 Py_INCREF(Py_None); resultobj = Py_None;
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 wxPen *arg1 = (wxPen *) 0 ;
3404 int arg2 ;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "self",(char *) "width", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3413 if (SWIG_arg_fail(1)) SWIG_fail;
3414 {
3415 arg2 = (int)(SWIG_As_int(obj1));
3416 if (SWIG_arg_fail(2)) SWIG_fail;
3417 }
3418 {
3419 PyThreadState* __tstate = wxPyBeginAllowThreads();
3420 (arg1)->SetWidth(arg2);
3421
3422 wxPyEndAllowThreads(__tstate);
3423 if (PyErr_Occurred()) SWIG_fail;
3424 }
3425 Py_INCREF(Py_None); resultobj = Py_None;
3426 return resultobj;
3427 fail:
3428 return NULL;
3429 }
3430
3431
3432 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3433 PyObject *resultobj;
3434 wxPen *arg1 = (wxPen *) 0 ;
3435 int arg2 ;
3436 wxDash *arg3 = (wxDash *) 0 ;
3437 PyObject * obj0 = 0 ;
3438 PyObject * obj1 = 0 ;
3439 char *kwnames[] = {
3440 (char *) "self",(char *) "dashes", NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3445 if (SWIG_arg_fail(1)) SWIG_fail;
3446 {
3447 arg2 = PyList_Size(obj1);
3448 arg3 = (wxDash*)byte_LIST_helper(obj1);
3449 if (arg3 == NULL) SWIG_fail;
3450 }
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 (arg1)->SetDashes(arg2,arg3);
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 Py_INCREF(Py_None); resultobj = Py_None;
3459 {
3460 if (arg3) delete [] arg3;
3461 }
3462 return resultobj;
3463 fail:
3464 {
3465 if (arg3) delete [] arg3;
3466 }
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxPen *arg1 = (wxPen *) 0 ;
3474 PyObject *result;
3475 PyObject * obj0 = 0 ;
3476 char *kwnames[] = {
3477 (char *) "self", NULL
3478 };
3479
3480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3482 if (SWIG_arg_fail(1)) SWIG_fail;
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (PyObject *)wxPen_GetDashes(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 resultobj = result;
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxPen *arg1 = (wxPen *) 0 ;
3500 PyObject *arg2 = (PyObject *) 0 ;
3501 PyObject *arg3 = (PyObject *) 0 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 PyObject * obj2 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 arg2 = obj1;
3513 arg3 = obj2;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 wxPen__SetDashes(arg1,arg2,arg3);
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 Py_INCREF(Py_None); resultobj = Py_None;
3522 return resultobj;
3523 fail:
3524 return NULL;
3525 }
3526
3527
3528 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3529 PyObject *resultobj;
3530 wxPen *arg1 = (wxPen *) 0 ;
3531 int result;
3532 PyObject * obj0 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 PyThreadState* __tstate = wxPyBeginAllowThreads();
3542 result = (int)((wxPen const *)arg1)->GetDashCount();
3543
3544 wxPyEndAllowThreads(__tstate);
3545 if (PyErr_Occurred()) SWIG_fail;
3546 }
3547 {
3548 resultobj = SWIG_From_int((int)(result));
3549 }
3550 return resultobj;
3551 fail:
3552 return NULL;
3553 }
3554
3555
3556 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 wxPen *arg1 = (wxPen *) 0 ;
3559 wxPen *arg2 = (wxPen *) 0 ;
3560 bool result;
3561 PyObject * obj0 = 0 ;
3562 PyObject * obj1 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self",(char *) "other", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(2)) SWIG_fail;
3572 {
3573 PyThreadState* __tstate = wxPyBeginAllowThreads();
3574 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3575
3576 wxPyEndAllowThreads(__tstate);
3577 if (PyErr_Occurred()) SWIG_fail;
3578 }
3579 {
3580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3581 }
3582 return resultobj;
3583 fail:
3584 return NULL;
3585 }
3586
3587
3588 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3589 PyObject *resultobj;
3590 wxPen *arg1 = (wxPen *) 0 ;
3591 wxPen *arg2 = (wxPen *) 0 ;
3592 bool result;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "other", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(2)) SWIG_fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3621 PyObject *obj;
3622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3623 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3624 Py_INCREF(obj);
3625 return Py_BuildValue((char *)"");
3626 }
3627 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj;
3629 wxColour *arg1 = 0 ;
3630 int arg2 = (int) wxSOLID ;
3631 wxBrush *result;
3632 wxColour temp1 ;
3633 PyObject * obj0 = 0 ;
3634 PyObject * obj1 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "colour",(char *) "style", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3640 {
3641 arg1 = &temp1;
3642 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3643 }
3644 if (obj1) {
3645 {
3646 arg2 = (int)(SWIG_As_int(obj1));
3647 if (SWIG_arg_fail(2)) SWIG_fail;
3648 }
3649 }
3650 {
3651 if (!wxPyCheckForApp()) SWIG_fail;
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 wxBrush *arg1 = (wxBrush *) 0 ;
3668 PyObject * obj0 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "self", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3675 if (SWIG_arg_fail(1)) SWIG_fail;
3676 {
3677 PyThreadState* __tstate = wxPyBeginAllowThreads();
3678 delete arg1;
3679
3680 wxPyEndAllowThreads(__tstate);
3681 if (PyErr_Occurred()) SWIG_fail;
3682 }
3683 Py_INCREF(Py_None); resultobj = Py_None;
3684 return resultobj;
3685 fail:
3686 return NULL;
3687 }
3688
3689
3690 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3691 PyObject *resultobj;
3692 wxBrush *arg1 = (wxBrush *) 0 ;
3693 wxColour *arg2 = 0 ;
3694 wxColour temp2 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "self",(char *) "col", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3703 if (SWIG_arg_fail(1)) SWIG_fail;
3704 {
3705 arg2 = &temp2;
3706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3707 }
3708 {
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 (arg1)->SetColour((wxColour const &)*arg2);
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxBrush *arg1 = (wxBrush *) 0 ;
3725 int arg2 ;
3726 PyObject * obj0 = 0 ;
3727 PyObject * obj1 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self",(char *) "style", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 arg2 = (int)(SWIG_As_int(obj1));
3737 if (SWIG_arg_fail(2)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 (arg1)->SetStyle(arg2);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxBrush *arg1 = (wxBrush *) 0 ;
3756 wxBitmap *arg2 = 0 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "stipple", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(2)) SWIG_fail;
3769 if (arg2 == NULL) {
3770 SWIG_null_ref("wxBitmap");
3771 }
3772 if (SWIG_arg_fail(2)) SWIG_fail;
3773 }
3774 {
3775 PyThreadState* __tstate = wxPyBeginAllowThreads();
3776 (arg1)->SetStipple((wxBitmap const &)*arg2);
3777
3778 wxPyEndAllowThreads(__tstate);
3779 if (PyErr_Occurred()) SWIG_fail;
3780 }
3781 Py_INCREF(Py_None); resultobj = Py_None;
3782 return resultobj;
3783 fail:
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj;
3790 wxBrush *arg1 = (wxBrush *) 0 ;
3791 wxColour result;
3792 PyObject * obj0 = 0 ;
3793 char *kwnames[] = {
3794 (char *) "self", NULL
3795 };
3796
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3799 if (SWIG_arg_fail(1)) SWIG_fail;
3800 {
3801 PyThreadState* __tstate = wxPyBeginAllowThreads();
3802 result = ((wxBrush const *)arg1)->GetColour();
3803
3804 wxPyEndAllowThreads(__tstate);
3805 if (PyErr_Occurred()) SWIG_fail;
3806 }
3807 {
3808 wxColour * resultptr;
3809 resultptr = new wxColour((wxColour &)(result));
3810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3811 }
3812 return resultobj;
3813 fail:
3814 return NULL;
3815 }
3816
3817
3818 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3819 PyObject *resultobj;
3820 wxBrush *arg1 = (wxBrush *) 0 ;
3821 int result;
3822 PyObject * obj0 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 result = (int)((wxBrush const *)arg1)->GetStyle();
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 {
3838 resultobj = SWIG_From_int((int)(result));
3839 }
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj;
3848 wxBrush *arg1 = (wxBrush *) 0 ;
3849 wxBitmap *result;
3850 PyObject * obj0 = 0 ;
3851 char *kwnames[] = {
3852 (char *) "self", NULL
3853 };
3854
3855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3857 if (SWIG_arg_fail(1)) SWIG_fail;
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
3872 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3873 PyObject *resultobj;
3874 wxBrush *arg1 = (wxBrush *) 0 ;
3875 bool result;
3876 PyObject * obj0 = 0 ;
3877 char *kwnames[] = {
3878 (char *) "self", NULL
3879 };
3880
3881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3883 if (SWIG_arg_fail(1)) SWIG_fail;
3884 {
3885 PyThreadState* __tstate = wxPyBeginAllowThreads();
3886 result = (bool)((wxBrush const *)arg1)->IsHatch();
3887
3888 wxPyEndAllowThreads(__tstate);
3889 if (PyErr_Occurred()) SWIG_fail;
3890 }
3891 {
3892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3893 }
3894 return resultobj;
3895 fail:
3896 return NULL;
3897 }
3898
3899
3900 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3901 PyObject *resultobj;
3902 wxBrush *arg1 = (wxBrush *) 0 ;
3903 bool result;
3904 PyObject * obj0 = 0 ;
3905 char *kwnames[] = {
3906 (char *) "self", NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3911 if (SWIG_arg_fail(1)) SWIG_fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (bool)(arg1)->Ok();
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 {
3920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3921 }
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3929 PyObject *obj;
3930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3931 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3932 Py_INCREF(obj);
3933 return Py_BuildValue((char *)"");
3934 }
3935 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxString *arg1 = 0 ;
3938 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3939 wxBitmap *result;
3940 bool temp1 = false ;
3941 PyObject * obj0 = 0 ;
3942 PyObject * obj1 = 0 ;
3943 char *kwnames[] = {
3944 (char *) "name",(char *) "type", NULL
3945 };
3946
3947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3948 {
3949 arg1 = wxString_in_helper(obj0);
3950 if (arg1 == NULL) SWIG_fail;
3951 temp1 = true;
3952 }
3953 if (obj1) {
3954 {
3955 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3956 if (SWIG_arg_fail(2)) SWIG_fail;
3957 }
3958 }
3959 {
3960 if (!wxPyCheckForApp()) SWIG_fail;
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
3968 {
3969 if (temp1)
3970 delete arg1;
3971 }
3972 return resultobj;
3973 fail:
3974 {
3975 if (temp1)
3976 delete arg1;
3977 }
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 wxBitmap *arg1 = (wxBitmap *) 0 ;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 {
3994 PyThreadState* __tstate = wxPyBeginAllowThreads();
3995 delete arg1;
3996
3997 wxPyEndAllowThreads(__tstate);
3998 if (PyErr_Occurred()) SWIG_fail;
3999 }
4000 Py_INCREF(Py_None); resultobj = Py_None;
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 int arg1 ;
4010 int arg2 ;
4011 int arg3 = (int) -1 ;
4012 wxBitmap *result;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 PyObject * obj2 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "width",(char *) "height",(char *) "depth", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4021 {
4022 arg1 = (int)(SWIG_As_int(obj0));
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 }
4025 {
4026 arg2 = (int)(SWIG_As_int(obj1));
4027 if (SWIG_arg_fail(2)) SWIG_fail;
4028 }
4029 if (obj2) {
4030 {
4031 arg3 = (int)(SWIG_As_int(obj2));
4032 if (SWIG_arg_fail(3)) SWIG_fail;
4033 }
4034 }
4035 {
4036 if (!wxPyCheckForApp()) SWIG_fail;
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 wxIcon *arg1 = 0 ;
4053 wxBitmap *result;
4054 PyObject * obj0 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "icon", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4060 {
4061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4062 if (SWIG_arg_fail(1)) SWIG_fail;
4063 if (arg1 == NULL) {
4064 SWIG_null_ref("wxIcon");
4065 }
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 }
4068 {
4069 if (!wxPyCheckForApp()) SWIG_fail;
4070 PyThreadState* __tstate = wxPyBeginAllowThreads();
4071 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4072
4073 wxPyEndAllowThreads(__tstate);
4074 if (PyErr_Occurred()) SWIG_fail;
4075 }
4076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4077 return resultobj;
4078 fail:
4079 return NULL;
4080 }
4081
4082
4083 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4084 PyObject *resultobj;
4085 wxImage *arg1 = 0 ;
4086 int arg2 = (int) -1 ;
4087 wxBitmap *result;
4088 PyObject * obj0 = 0 ;
4089 PyObject * obj1 = 0 ;
4090 char *kwnames[] = {
4091 (char *) "image",(char *) "depth", NULL
4092 };
4093
4094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4095 {
4096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4097 if (SWIG_arg_fail(1)) SWIG_fail;
4098 if (arg1 == NULL) {
4099 SWIG_null_ref("wxImage");
4100 }
4101 if (SWIG_arg_fail(1)) SWIG_fail;
4102 }
4103 if (obj1) {
4104 {
4105 arg2 = (int)(SWIG_As_int(obj1));
4106 if (SWIG_arg_fail(2)) SWIG_fail;
4107 }
4108 }
4109 {
4110 if (!wxPyCheckForApp()) SWIG_fail;
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj;
4126 PyObject *arg1 = (PyObject *) 0 ;
4127 wxBitmap *result;
4128 PyObject * obj0 = 0 ;
4129 char *kwnames[] = {
4130 (char *) "listOfStrings", NULL
4131 };
4132
4133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4134 arg1 = obj0;
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = (wxBitmap *)new_wxBitmap(arg1);
4139
4140 wxPyEndAllowThreads(__tstate);
4141 if (PyErr_Occurred()) SWIG_fail;
4142 }
4143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 PyObject *arg1 = (PyObject *) 0 ;
4153 int arg2 ;
4154 int arg3 ;
4155 int arg4 = (int) 1 ;
4156 wxBitmap *result;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 PyObject * obj2 = 0 ;
4160 PyObject * obj3 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4166 arg1 = obj0;
4167 {
4168 arg2 = (int)(SWIG_As_int(obj1));
4169 if (SWIG_arg_fail(2)) SWIG_fail;
4170 }
4171 {
4172 arg3 = (int)(SWIG_As_int(obj2));
4173 if (SWIG_arg_fail(3)) SWIG_fail;
4174 }
4175 if (obj3) {
4176 {
4177 arg4 = (int)(SWIG_As_int(obj3));
4178 if (SWIG_arg_fail(4)) SWIG_fail;
4179 }
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4185
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4197 PyObject *resultobj;
4198 wxBitmap *arg1 = (wxBitmap *) 0 ;
4199 bool result;
4200 PyObject * obj0 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)(arg1)->Ok();
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj;
4226 wxBitmap *arg1 = (wxBitmap *) 0 ;
4227 int result;
4228 PyObject * obj0 = 0 ;
4229 char *kwnames[] = {
4230 (char *) "self", NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4235 if (SWIG_arg_fail(1)) SWIG_fail;
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (int)(arg1)->GetWidth();
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 {
4244 resultobj = SWIG_From_int((int)(result));
4245 }
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxBitmap *arg1 = (wxBitmap *) 0 ;
4255 int result;
4256 PyObject * obj0 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = (int)(arg1)->GetHeight();
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 {
4272 resultobj = SWIG_From_int((int)(result));
4273 }
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 wxBitmap *arg1 = (wxBitmap *) 0 ;
4283 int result;
4284 PyObject * obj0 = 0 ;
4285 char *kwnames[] = {
4286 (char *) "self", NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4291 if (SWIG_arg_fail(1)) SWIG_fail;
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 result = (int)(arg1)->GetDepth();
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 {
4300 resultobj = SWIG_From_int((int)(result));
4301 }
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxBitmap *arg1 = (wxBitmap *) 0 ;
4311 wxSize result;
4312 PyObject * obj0 = 0 ;
4313 char *kwnames[] = {
4314 (char *) "self", NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4319 if (SWIG_arg_fail(1)) SWIG_fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = wxBitmap_GetSize(arg1);
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 wxSize * resultptr;
4329 resultptr = new wxSize((wxSize &)(result));
4330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxBitmap *arg1 = (wxBitmap *) 0 ;
4341 SwigValueWrapper<wxImage > result;
4342 PyObject * obj0 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = ((wxBitmap const *)arg1)->ConvertToImage();
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 wxImage * resultptr;
4359 resultptr = new wxImage((wxImage &)(result));
4360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxBitmap *arg1 = (wxBitmap *) 0 ;
4371 wxMask *result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4388 return resultobj;
4389 fail:
4390 return NULL;
4391 }
4392
4393
4394 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4395 PyObject *resultobj;
4396 wxBitmap *arg1 = (wxBitmap *) 0 ;
4397 wxMask *arg2 = (wxMask *) 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "self",(char *) "mask", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4408 if (SWIG_arg_fail(2)) SWIG_fail;
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 (arg1)->SetMask(arg2);
4412
4413 wxPyEndAllowThreads(__tstate);
4414 if (PyErr_Occurred()) SWIG_fail;
4415 }
4416 Py_INCREF(Py_None); resultobj = Py_None;
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj;
4425 wxBitmap *arg1 = (wxBitmap *) 0 ;
4426 wxColour *arg2 = 0 ;
4427 wxColour temp2 ;
4428 PyObject * obj0 = 0 ;
4429 PyObject * obj1 = 0 ;
4430 char *kwnames[] = {
4431 (char *) "self",(char *) "colour", NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4436 if (SWIG_arg_fail(1)) SWIG_fail;
4437 {
4438 arg2 = &temp2;
4439 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4440 }
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxBitmap *arg1 = (wxBitmap *) 0 ;
4458 wxRect *arg2 = 0 ;
4459 SwigValueWrapper<wxBitmap > result;
4460 wxRect temp2 ;
4461 PyObject * obj0 = 0 ;
4462 PyObject * obj1 = 0 ;
4463 char *kwnames[] = {
4464 (char *) "self",(char *) "rect", NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(1)) SWIG_fail;
4470 {
4471 arg2 = &temp2;
4472 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 wxBitmap * resultptr;
4483 resultptr = new wxBitmap((wxBitmap &)(result));
4484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 wxString *arg2 = 0 ;
4496 wxBitmapType arg3 ;
4497 wxPalette *arg4 = (wxPalette *) NULL ;
4498 bool result;
4499 bool temp2 = false ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 PyObject * obj2 = 0 ;
4503 PyObject * obj3 = 0 ;
4504 char *kwnames[] = {
4505 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4506 };
4507
4508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4510 if (SWIG_arg_fail(1)) SWIG_fail;
4511 {
4512 arg2 = wxString_in_helper(obj1);
4513 if (arg2 == NULL) SWIG_fail;
4514 temp2 = true;
4515 }
4516 {
4517 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4518 if (SWIG_arg_fail(3)) SWIG_fail;
4519 }
4520 if (obj3) {
4521 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4522 if (SWIG_arg_fail(4)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4527
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 {
4535 if (temp2)
4536 delete arg2;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp2)
4542 delete arg2;
4543 }
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxBitmap *arg1 = (wxBitmap *) 0 ;
4551 wxString *arg2 = 0 ;
4552 wxBitmapType arg3 ;
4553 bool result;
4554 bool temp2 = false ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 PyObject * obj2 = 0 ;
4558 char *kwnames[] = {
4559 (char *) "self",(char *) "name",(char *) "type", NULL
4560 };
4561
4562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4564 if (SWIG_arg_fail(1)) SWIG_fail;
4565 {
4566 arg2 = wxString_in_helper(obj1);
4567 if (arg2 == NULL) SWIG_fail;
4568 temp2 = true;
4569 }
4570 {
4571 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4572 if (SWIG_arg_fail(3)) SWIG_fail;
4573 }
4574 {
4575 PyThreadState* __tstate = wxPyBeginAllowThreads();
4576 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4577
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 {
4582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4583 }
4584 {
4585 if (temp2)
4586 delete arg2;
4587 }
4588 return resultobj;
4589 fail:
4590 {
4591 if (temp2)
4592 delete arg2;
4593 }
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxBitmap *arg1 = (wxBitmap *) 0 ;
4601 wxPalette *result;
4602 PyObject * obj0 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj;
4626 wxBitmap *arg1 = (wxBitmap *) 0 ;
4627 wxIcon *arg2 = 0 ;
4628 bool result;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char *kwnames[] = {
4632 (char *) "self",(char *) "icon", NULL
4633 };
4634
4635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4637 if (SWIG_arg_fail(1)) SWIG_fail;
4638 {
4639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4640 if (SWIG_arg_fail(2)) SWIG_fail;
4641 if (arg2 == NULL) {
4642 SWIG_null_ref("wxIcon");
4643 }
4644 if (SWIG_arg_fail(2)) SWIG_fail;
4645 }
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 {
4654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4655 }
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxBitmap *arg1 = (wxBitmap *) 0 ;
4665 int arg2 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "height", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 arg2 = (int)(SWIG_As_int(obj1));
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 }
4679 {
4680 PyThreadState* __tstate = wxPyBeginAllowThreads();
4681 (arg1)->SetHeight(arg2);
4682
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 Py_INCREF(Py_None); resultobj = Py_None;
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj;
4695 wxBitmap *arg1 = (wxBitmap *) 0 ;
4696 int arg2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "self",(char *) "width", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4705 if (SWIG_arg_fail(1)) SWIG_fail;
4706 {
4707 arg2 = (int)(SWIG_As_int(obj1));
4708 if (SWIG_arg_fail(2)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 (arg1)->SetWidth(arg2);
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 Py_INCREF(Py_None); resultobj = Py_None;
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxBitmap *arg1 = (wxBitmap *) 0 ;
4727 int arg2 ;
4728 PyObject * obj0 = 0 ;
4729 PyObject * obj1 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self",(char *) "depth", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 arg2 = (int)(SWIG_As_int(obj1));
4739 if (SWIG_arg_fail(2)) SWIG_fail;
4740 }
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 (arg1)->SetDepth(arg2);
4744
4745 wxPyEndAllowThreads(__tstate);
4746 if (PyErr_Occurred()) SWIG_fail;
4747 }
4748 Py_INCREF(Py_None); resultobj = Py_None;
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj;
4757 wxBitmap *arg1 = (wxBitmap *) 0 ;
4758 wxSize *arg2 = 0 ;
4759 wxSize temp2 ;
4760 PyObject * obj0 = 0 ;
4761 PyObject * obj1 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "self",(char *) "size", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4768 if (SWIG_arg_fail(1)) SWIG_fail;
4769 {
4770 arg2 = &temp2;
4771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 Py_INCREF(Py_None); resultobj = Py_None;
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj;
4789 wxBitmap *arg1 = (wxBitmap *) 0 ;
4790 wxBitmap *arg2 = (wxBitmap *) 0 ;
4791 bool result;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char *kwnames[] = {
4795 (char *) "self",(char *) "other", NULL
4796 };
4797
4798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4800 if (SWIG_arg_fail(1)) SWIG_fail;
4801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(2)) SWIG_fail;
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4806
4807 wxPyEndAllowThreads(__tstate);
4808 if (PyErr_Occurred()) SWIG_fail;
4809 }
4810 {
4811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4812 }
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj;
4821 wxBitmap *arg1 = (wxBitmap *) 0 ;
4822 wxBitmap *arg2 = (wxBitmap *) 0 ;
4823 bool result;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 char *kwnames[] = {
4827 (char *) "self",(char *) "other", NULL
4828 };
4829
4830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4832 if (SWIG_arg_fail(1)) SWIG_fail;
4833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4834 if (SWIG_arg_fail(2)) SWIG_fail;
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 {
4843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4844 }
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4852 PyObject *obj;
4853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4854 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4855 Py_INCREF(obj);
4856 return Py_BuildValue((char *)"");
4857 }
4858 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj;
4860 wxBitmap *arg1 = 0 ;
4861 wxColour const &arg2_defvalue = wxNullColour ;
4862 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4863 wxMask *result;
4864 wxColour temp2 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char *kwnames[] = {
4868 (char *) "bitmap",(char *) "colour", NULL
4869 };
4870
4871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4872 {
4873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4874 if (SWIG_arg_fail(1)) SWIG_fail;
4875 if (arg1 == NULL) {
4876 SWIG_null_ref("wxBitmap");
4877 }
4878 if (SWIG_arg_fail(1)) SWIG_fail;
4879 }
4880 if (obj1) {
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 }
4886 {
4887 if (!wxPyCheckForApp()) SWIG_fail;
4888 PyThreadState* __tstate = wxPyBeginAllowThreads();
4889 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4890
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4902 PyObject *obj;
4903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4904 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4905 Py_INCREF(obj);
4906 return Py_BuildValue((char *)"");
4907 }
4908 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxString *arg1 = 0 ;
4911 wxBitmapType arg2 ;
4912 int arg3 = (int) -1 ;
4913 int arg4 = (int) -1 ;
4914 wxIcon *result;
4915 bool temp1 = false ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 PyObject * obj2 = 0 ;
4919 PyObject * obj3 = 0 ;
4920 char *kwnames[] = {
4921 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4922 };
4923
4924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4925 {
4926 arg1 = wxString_in_helper(obj0);
4927 if (arg1 == NULL) SWIG_fail;
4928 temp1 = true;
4929 }
4930 {
4931 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4932 if (SWIG_arg_fail(2)) SWIG_fail;
4933 }
4934 if (obj2) {
4935 {
4936 arg3 = (int)(SWIG_As_int(obj2));
4937 if (SWIG_arg_fail(3)) SWIG_fail;
4938 }
4939 }
4940 if (obj3) {
4941 {
4942 arg4 = (int)(SWIG_As_int(obj3));
4943 if (SWIG_arg_fail(4)) SWIG_fail;
4944 }
4945 }
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4955 {
4956 if (temp1)
4957 delete arg1;
4958 }
4959 return resultobj;
4960 fail:
4961 {
4962 if (temp1)
4963 delete arg1;
4964 }
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxIcon *arg1 = (wxIcon *) 0 ;
4972 PyObject * obj0 = 0 ;
4973 char *kwnames[] = {
4974 (char *) "self", NULL
4975 };
4976
4977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
4978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4979 if (SWIG_arg_fail(1)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 delete arg1;
4983
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 Py_INCREF(Py_None); resultobj = Py_None;
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxIcon *result;
4997 char *kwnames[] = {
4998 NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5002 {
5003 if (!wxPyCheckForApp()) SWIG_fail;
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = (wxIcon *)new wxIcon();
5006
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5018 PyObject *resultobj;
5019 wxIconLocation *arg1 = 0 ;
5020 wxIcon *result;
5021 PyObject * obj0 = 0 ;
5022 char *kwnames[] = {
5023 (char *) "loc", NULL
5024 };
5025
5026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5027 {
5028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(1)) SWIG_fail;
5030 if (arg1 == NULL) {
5031 SWIG_null_ref("wxIconLocation");
5032 }
5033 if (SWIG_arg_fail(1)) SWIG_fail;
5034 }
5035 {
5036 if (!wxPyCheckForApp()) SWIG_fail;
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5039
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5051 PyObject *resultobj;
5052 wxBitmap *arg1 = 0 ;
5053 wxIcon *result;
5054 PyObject * obj0 = 0 ;
5055 char *kwnames[] = {
5056 (char *) "bmp", NULL
5057 };
5058
5059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5060 {
5061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5062 if (SWIG_arg_fail(1)) SWIG_fail;
5063 if (arg1 == NULL) {
5064 SWIG_null_ref("wxBitmap");
5065 }
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 }
5068 {
5069 if (!wxPyCheckForApp()) SWIG_fail;
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 PyObject *arg1 = (PyObject *) 0 ;
5086 wxIcon *result;
5087 PyObject * obj0 = 0 ;
5088 char *kwnames[] = {
5089 (char *) "listOfStrings", NULL
5090 };
5091
5092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5093 arg1 = obj0;
5094 {
5095 if (!wxPyCheckForApp()) SWIG_fail;
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (wxIcon *)new_wxIcon(arg1);
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj;
5111 wxIcon *arg1 = (wxIcon *) 0 ;
5112 wxString *arg2 = 0 ;
5113 wxBitmapType arg3 ;
5114 bool result;
5115 bool temp2 = false ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 PyObject * obj2 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "name",(char *) "type", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = wxString_in_helper(obj1);
5128 if (arg2 == NULL) SWIG_fail;
5129 temp2 = true;
5130 }
5131 {
5132 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5133 if (SWIG_arg_fail(3)) SWIG_fail;
5134 }
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5138
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 {
5143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5144 }
5145 {
5146 if (temp2)
5147 delete arg2;
5148 }
5149 return resultobj;
5150 fail:
5151 {
5152 if (temp2)
5153 delete arg2;
5154 }
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxIcon *arg1 = (wxIcon *) 0 ;
5162 bool result;
5163 PyObject * obj0 = 0 ;
5164 char *kwnames[] = {
5165 (char *) "self", NULL
5166 };
5167
5168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(1)) SWIG_fail;
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 result = (bool)(arg1)->Ok();
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 {
5179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5180 }
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxIcon *arg1 = (wxIcon *) 0 ;
5190 int result;
5191 PyObject * obj0 = 0 ;
5192 char *kwnames[] = {
5193 (char *) "self", NULL
5194 };
5195
5196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5198 if (SWIG_arg_fail(1)) SWIG_fail;
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 result = (int)(arg1)->GetWidth();
5202
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 {
5207 resultobj = SWIG_From_int((int)(result));
5208 }
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5216 PyObject *resultobj;
5217 wxIcon *arg1 = (wxIcon *) 0 ;
5218 int result;
5219 PyObject * obj0 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 result = (int)(arg1)->GetHeight();
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 {
5235 resultobj = SWIG_From_int((int)(result));
5236 }
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxIcon *arg1 = (wxIcon *) 0 ;
5246 int result;
5247 PyObject * obj0 = 0 ;
5248 char *kwnames[] = {
5249 (char *) "self", NULL
5250 };
5251
5252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5254 if (SWIG_arg_fail(1)) SWIG_fail;
5255 {
5256 PyThreadState* __tstate = wxPyBeginAllowThreads();
5257 result = (int)(arg1)->GetDepth();
5258
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 {
5263 resultobj = SWIG_From_int((int)(result));
5264 }
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj;
5273 wxIcon *arg1 = (wxIcon *) 0 ;
5274 int arg2 ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self",(char *) "w", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 arg2 = (int)(SWIG_As_int(obj1));
5286 if (SWIG_arg_fail(2)) SWIG_fail;
5287 }
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 (arg1)->SetWidth(arg2);
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 Py_INCREF(Py_None); resultobj = Py_None;
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxIcon *arg1 = (wxIcon *) 0 ;
5305 int arg2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "self",(char *) "h", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5314 if (SWIG_arg_fail(1)) SWIG_fail;
5315 {
5316 arg2 = (int)(SWIG_As_int(obj1));
5317 if (SWIG_arg_fail(2)) SWIG_fail;
5318 }
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 (arg1)->SetHeight(arg2);
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 Py_INCREF(Py_None); resultobj = Py_None;
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj;
5335 wxIcon *arg1 = (wxIcon *) 0 ;
5336 int arg2 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self",(char *) "d", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 arg2 = (int)(SWIG_As_int(obj1));
5348 if (SWIG_arg_fail(2)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetDepth(arg2);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxIcon *arg1 = (wxIcon *) 0 ;
5367 wxBitmap *arg2 = 0 ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "bmp", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5379 if (SWIG_arg_fail(2)) SWIG_fail;
5380 if (arg2 == NULL) {
5381 SWIG_null_ref("wxBitmap");
5382 }
5383 if (SWIG_arg_fail(2)) SWIG_fail;
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5388
5389 wxPyEndAllowThreads(__tstate);
5390 if (PyErr_Occurred()) SWIG_fail;
5391 }
5392 Py_INCREF(Py_None); resultobj = Py_None;
5393 return resultobj;
5394 fail:
5395 return NULL;
5396 }
5397
5398
5399 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5400 PyObject *obj;
5401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5402 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5403 Py_INCREF(obj);
5404 return Py_BuildValue((char *)"");
5405 }
5406 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5409 int arg2 = (int) 0 ;
5410 wxIconLocation *result;
5411 bool temp1 = false ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "filename",(char *) "num", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5419 if (obj0) {
5420 {
5421 arg1 = wxString_in_helper(obj0);
5422 if (arg1 == NULL) SWIG_fail;
5423 temp1 = true;
5424 }
5425 }
5426 if (obj1) {
5427 {
5428 arg2 = (int)(SWIG_As_int(obj1));
5429 if (SWIG_arg_fail(2)) SWIG_fail;
5430 }
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 return resultobj;
5445 fail:
5446 {
5447 if (temp1)
5448 delete arg1;
5449 }
5450 return NULL;
5451 }
5452
5453
5454 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj;
5456 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 delete arg1;
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 Py_INCREF(Py_None); resultobj = Py_None;
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj;
5481 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5482 bool result;
5483 PyObject * obj0 = 0 ;
5484 char *kwnames[] = {
5485 (char *) "self", NULL
5486 };
5487
5488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5490 if (SWIG_arg_fail(1)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5494
5495 wxPyEndAllowThreads(__tstate);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj;
5509 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5510 wxString *arg2 = 0 ;
5511 bool temp2 = false ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self",(char *) "filename", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 arg2 = wxString_in_helper(obj1);
5523 if (arg2 == NULL) SWIG_fail;
5524 temp2 = true;
5525 }
5526 {
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 (arg1)->SetFileName((wxString const &)*arg2);
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 Py_INCREF(Py_None); resultobj = Py_None;
5534 {
5535 if (temp2)
5536 delete arg2;
5537 }
5538 return resultobj;
5539 fail:
5540 {
5541 if (temp2)
5542 delete arg2;
5543 }
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5551 wxString *result;
5552 PyObject * obj0 = 0 ;
5553 char *kwnames[] = {
5554 (char *) "self", NULL
5555 };
5556
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(1)) SWIG_fail;
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 {
5563 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5564 result = (wxString *) &_result_ref;
5565 }
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 {
5571 #if wxUSE_UNICODE
5572 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5573 #else
5574 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5575 #endif
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5586 int arg2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "num", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = (int)(SWIG_As_int(obj1));
5598 if (SWIG_arg_fail(2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 wxIconLocation_SetIndex(arg1,arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5617 int result;
5618 PyObject * obj0 = 0 ;
5619 char *kwnames[] = {
5620 (char *) "self", NULL
5621 };
5622
5623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5625 if (SWIG_arg_fail(1)) SWIG_fail;
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (int)wxIconLocation_GetIndex(arg1);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 {
5634 resultobj = SWIG_From_int((int)(result));
5635 }
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5643 PyObject *obj;
5644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5645 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5646 Py_INCREF(obj);
5647 return Py_BuildValue((char *)"");
5648 }
5649 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxIconBundle *result;
5652 char *kwnames[] = {
5653 NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxIconBundle *)new wxIconBundle();
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxString *arg1 = 0 ;
5674 long arg2 ;
5675 wxIconBundle *result;
5676 bool temp1 = false ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "file",(char *) "type", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5684 {
5685 arg1 = wxString_in_helper(obj0);
5686 if (arg1 == NULL) SWIG_fail;
5687 temp1 = true;
5688 }
5689 {
5690 arg2 = (long)(SWIG_As_long(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5701 {
5702 if (temp1)
5703 delete arg1;
5704 }
5705 return resultobj;
5706 fail:
5707 {
5708 if (temp1)
5709 delete arg1;
5710 }
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxIcon *arg1 = 0 ;
5718 wxIconBundle *result;
5719 PyObject * obj0 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "icon", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5725 {
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 if (arg1 == NULL) {
5729 SWIG_null_ref("wxIcon");
5730 }
5731 if (SWIG_arg_fail(1)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5750 PyObject * obj0 = 0 ;
5751 char *kwnames[] = {
5752 (char *) "self", NULL
5753 };
5754
5755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5757 if (SWIG_arg_fail(1)) SWIG_fail;
5758 {
5759 PyThreadState* __tstate = wxPyBeginAllowThreads();
5760 delete arg1;
5761
5762 wxPyEndAllowThreads(__tstate);
5763 if (PyErr_Occurred()) SWIG_fail;
5764 }
5765 Py_INCREF(Py_None); resultobj = Py_None;
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5775 wxIcon *arg2 = 0 ;
5776 PyObject * obj0 = 0 ;
5777 PyObject * obj1 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "self",(char *) "icon", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5784 if (SWIG_arg_fail(1)) SWIG_fail;
5785 {
5786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(2)) SWIG_fail;
5788 if (arg2 == NULL) {
5789 SWIG_null_ref("wxIcon");
5790 }
5791 if (SWIG_arg_fail(2)) SWIG_fail;
5792 }
5793 {
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 (arg1)->AddIcon((wxIcon const &)*arg2);
5796
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 Py_INCREF(Py_None); resultobj = Py_None;
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj;
5809 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5810 wxString *arg2 = 0 ;
5811 long arg3 ;
5812 bool temp2 = false ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 PyObject * obj2 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "file",(char *) "type", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = wxString_in_helper(obj1);
5825 if (arg2 == NULL) SWIG_fail;
5826 temp2 = true;
5827 }
5828 {
5829 arg3 = (long)(SWIG_As_long(obj2));
5830 if (SWIG_arg_fail(3)) SWIG_fail;
5831 }
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5857 wxSize *arg2 = 0 ;
5858 wxIcon *result;
5859 wxSize temp2 ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 char *kwnames[] = {
5863 (char *) "self",(char *) "size", NULL
5864 };
5865
5866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5868 if (SWIG_arg_fail(1)) SWIG_fail;
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 {
5876 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5877 result = (wxIcon *) &_result_ref;
5878 }
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 wxIcon* resultptr = new wxIcon(*result);
5885 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5886 }
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5894 PyObject *obj;
5895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5896 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5897 Py_INCREF(obj);
5898 return Py_BuildValue((char *)"");
5899 }
5900 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxString *arg1 = 0 ;
5903 long arg2 ;
5904 int arg3 = (int) 0 ;
5905 int arg4 = (int) 0 ;
5906 wxCursor *result;
5907 bool temp1 = false ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 PyObject * obj2 = 0 ;
5911 PyObject * obj3 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5917 {
5918 arg1 = wxString_in_helper(obj0);
5919 if (arg1 == NULL) SWIG_fail;
5920 temp1 = true;
5921 }
5922 {
5923 arg2 = (long)(SWIG_As_long(obj1));
5924 if (SWIG_arg_fail(2)) SWIG_fail;
5925 }
5926 if (obj2) {
5927 {
5928 arg3 = (int)(SWIG_As_int(obj2));
5929 if (SWIG_arg_fail(3)) SWIG_fail;
5930 }
5931 }
5932 if (obj3) {
5933 {
5934 arg4 = (int)(SWIG_As_int(obj3));
5935 if (SWIG_arg_fail(4)) SWIG_fail;
5936 }
5937 }
5938 {
5939 if (!wxPyCheckForApp()) SWIG_fail;
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5947 {
5948 if (temp1)
5949 delete arg1;
5950 }
5951 return resultobj;
5952 fail:
5953 {
5954 if (temp1)
5955 delete arg1;
5956 }
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxCursor *arg1 = (wxCursor *) 0 ;
5964 PyObject * obj0 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 delete arg1;
5975
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 Py_INCREF(Py_None); resultobj = Py_None;
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj;
5988 int arg1 ;
5989 wxCursor *result;
5990 PyObject * obj0 = 0 ;
5991 char *kwnames[] = {
5992 (char *) "id", NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
5996 {
5997 arg1 = (int)(SWIG_As_int(obj0));
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxCursor *)new wxCursor(arg1);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj;
6017 wxImage *arg1 = 0 ;
6018 wxCursor *result;
6019 PyObject * obj0 = 0 ;
6020 char *kwnames[] = {
6021 (char *) "image", NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6025 {
6026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6027 if (SWIG_arg_fail(1)) SWIG_fail;
6028 if (arg1 == NULL) {
6029 SWIG_null_ref("wxImage");
6030 }
6031 if (SWIG_arg_fail(1)) SWIG_fail;
6032 }
6033 {
6034 if (!wxPyCheckForApp()) SWIG_fail;
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxCursor *arg1 = (wxCursor *) 0 ;
6051 bool result;
6052 PyObject * obj0 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)(arg1)->Ok();
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6077 PyObject *obj;
6078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6079 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6080 Py_INCREF(obj);
6081 return Py_BuildValue((char *)"");
6082 }
6083 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 int arg1 = (int) 0 ;
6086 int arg2 = (int) 0 ;
6087 int arg3 = (int) 0 ;
6088 int arg4 = (int) 0 ;
6089 wxRegion *result;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 PyObject * obj2 = 0 ;
6093 PyObject * obj3 = 0 ;
6094 char *kwnames[] = {
6095 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6096 };
6097
6098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6099 if (obj0) {
6100 {
6101 arg1 = (int)(SWIG_As_int(obj0));
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 }
6104 }
6105 if (obj1) {
6106 {
6107 arg2 = (int)(SWIG_As_int(obj1));
6108 if (SWIG_arg_fail(2)) SWIG_fail;
6109 }
6110 }
6111 if (obj2) {
6112 {
6113 arg3 = (int)(SWIG_As_int(obj2));
6114 if (SWIG_arg_fail(3)) SWIG_fail;
6115 }
6116 }
6117 if (obj3) {
6118 {
6119 arg4 = (int)(SWIG_As_int(obj3));
6120 if (SWIG_arg_fail(4)) SWIG_fail;
6121 }
6122 }
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxBitmap *arg1 = 0 ;
6141 wxRegion *result;
6142 PyObject * obj0 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "bmp", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6148 {
6149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6150 if (SWIG_arg_fail(1)) SWIG_fail;
6151 if (arg1 == NULL) {
6152 SWIG_null_ref("wxBitmap");
6153 }
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 }
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxBitmap *arg1 = 0 ;
6174 wxColour *arg2 = 0 ;
6175 int arg3 = (int) 0 ;
6176 wxRegion *result;
6177 wxColour temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 PyObject * obj2 = 0 ;
6181 char *kwnames[] = {
6182 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6183 };
6184
6185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6186 {
6187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6188 if (SWIG_arg_fail(1)) SWIG_fail;
6189 if (arg1 == NULL) {
6190 SWIG_null_ref("wxBitmap");
6191 }
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 }
6194 {
6195 arg2 = &temp2;
6196 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6197 }
6198 if (obj2) {
6199 {
6200 arg3 = (int)(SWIG_As_int(obj2));
6201 if (SWIG_arg_fail(3)) SWIG_fail;
6202 }
6203 }
6204 {
6205 if (!wxPyCheckForApp()) SWIG_fail;
6206 PyThreadState* __tstate = wxPyBeginAllowThreads();
6207 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6208
6209 wxPyEndAllowThreads(__tstate);
6210 if (PyErr_Occurred()) SWIG_fail;
6211 }
6212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 int arg1 ;
6222 wxPoint *arg2 = (wxPoint *) 0 ;
6223 int arg3 = (int) wxWINDING_RULE ;
6224 wxRegion *result;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "points",(char *) "fillStyle", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6232 {
6233 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6234 if (arg2 == NULL) SWIG_fail;
6235 }
6236 if (obj1) {
6237 {
6238 arg3 = (int)(SWIG_As_int(obj1));
6239 if (SWIG_arg_fail(3)) SWIG_fail;
6240 }
6241 }
6242 {
6243 if (!wxPyCheckForApp()) SWIG_fail;
6244 PyThreadState* __tstate = wxPyBeginAllowThreads();
6245 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6246
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6251 {
6252 if (arg2) delete [] arg2;
6253 }
6254 return resultobj;
6255 fail:
6256 {
6257 if (arg2) delete [] arg2;
6258 }
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 wxRegion *arg1 = (wxRegion *) 0 ;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "self", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6273 if (SWIG_arg_fail(1)) SWIG_fail;
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 delete arg1;
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRegion *arg1 = (wxRegion *) 0 ;
6291 PyObject * obj0 = 0 ;
6292 char *kwnames[] = {
6293 (char *) "self", NULL
6294 };
6295
6296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6298 if (SWIG_arg_fail(1)) SWIG_fail;
6299 {
6300 PyThreadState* __tstate = wxPyBeginAllowThreads();
6301 (arg1)->Clear();
6302
6303 wxPyEndAllowThreads(__tstate);
6304 if (PyErr_Occurred()) SWIG_fail;
6305 }
6306 Py_INCREF(Py_None); resultobj = Py_None;
6307 return resultobj;
6308 fail:
6309 return NULL;
6310 }
6311
6312
6313 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6314 PyObject *resultobj;
6315 wxRegion *arg1 = (wxRegion *) 0 ;
6316 int arg2 ;
6317 int arg3 ;
6318 bool result;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self",(char *) "x",(char *) "y", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 arg2 = (int)(SWIG_As_int(obj1));
6331 if (SWIG_arg_fail(2)) SWIG_fail;
6332 }
6333 {
6334 arg3 = (int)(SWIG_As_int(obj2));
6335 if (SWIG_arg_fail(3)) SWIG_fail;
6336 }
6337 {
6338 PyThreadState* __tstate = wxPyBeginAllowThreads();
6339 result = (bool)(arg1)->Offset(arg2,arg3);
6340
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 {
6345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6346 }
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRegion *arg1 = (wxRegion *) 0 ;
6356 int arg2 ;
6357 int arg3 ;
6358 wxRegionContain result;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 PyObject * obj2 = 0 ;
6362 char *kwnames[] = {
6363 (char *) "self",(char *) "x",(char *) "y", NULL
6364 };
6365
6366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6368 if (SWIG_arg_fail(1)) SWIG_fail;
6369 {
6370 arg2 = (int)(SWIG_As_int(obj1));
6371 if (SWIG_arg_fail(2)) SWIG_fail;
6372 }
6373 {
6374 arg3 = (int)(SWIG_As_int(obj2));
6375 if (SWIG_arg_fail(3)) SWIG_fail;
6376 }
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_From_int((result));
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxRegion *arg1 = (wxRegion *) 0 ;
6394 wxPoint *arg2 = 0 ;
6395 wxRegionContain result;
6396 wxPoint temp2 ;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self",(char *) "pt", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 arg2 = &temp2;
6408 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6409 }
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_From_int((result));
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxRegion *arg1 = (wxRegion *) 0 ;
6427 wxRect *arg2 = 0 ;
6428 wxRegionContain result;
6429 wxRect temp2 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self",(char *) "rect", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 {
6440 arg2 = &temp2;
6441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_From_int((result));
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxRegion *arg1 = (wxRegion *) 0 ;
6460 int arg2 ;
6461 int arg3 ;
6462 int arg4 ;
6463 int arg5 ;
6464 wxRegionContain result;
6465 PyObject * obj0 = 0 ;
6466 PyObject * obj1 = 0 ;
6467 PyObject * obj2 = 0 ;
6468 PyObject * obj3 = 0 ;
6469 PyObject * obj4 = 0 ;
6470 char *kwnames[] = {
6471 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6472 };
6473
6474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6476 if (SWIG_arg_fail(1)) SWIG_fail;
6477 {
6478 arg2 = (int)(SWIG_As_int(obj1));
6479 if (SWIG_arg_fail(2)) SWIG_fail;
6480 }
6481 {
6482 arg3 = (int)(SWIG_As_int(obj2));
6483 if (SWIG_arg_fail(3)) SWIG_fail;
6484 }
6485 {
6486 arg4 = (int)(SWIG_As_int(obj3));
6487 if (SWIG_arg_fail(4)) SWIG_fail;
6488 }
6489 {
6490 arg5 = (int)(SWIG_As_int(obj4));
6491 if (SWIG_arg_fail(5)) SWIG_fail;
6492 }
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_From_int((result));
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxRegion *arg1 = (wxRegion *) 0 ;
6510 wxRect result;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (arg1)->GetBox();
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 {
6527 wxRect * resultptr;
6528 resultptr = new wxRect((wxRect &)(result));
6529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6530 }
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 wxRegion *arg1 = (wxRegion *) 0 ;
6540 int arg2 ;
6541 int arg3 ;
6542 int arg4 ;
6543 int arg5 ;
6544 bool result;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 PyObject * obj2 = 0 ;
6548 PyObject * obj3 = 0 ;
6549 PyObject * obj4 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 arg2 = (int)(SWIG_As_int(obj1));
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 }
6561 {
6562 arg3 = (int)(SWIG_As_int(obj2));
6563 if (SWIG_arg_fail(3)) SWIG_fail;
6564 }
6565 {
6566 arg4 = (int)(SWIG_As_int(obj3));
6567 if (SWIG_arg_fail(4)) SWIG_fail;
6568 }
6569 {
6570 arg5 = (int)(SWIG_As_int(obj4));
6571 if (SWIG_arg_fail(5)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 {
6581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6582 }
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxRegion *arg1 = (wxRegion *) 0 ;
6592 wxRect *arg2 = 0 ;
6593 bool result;
6594 wxRect temp2 ;
6595 PyObject * obj0 = 0 ;
6596 PyObject * obj1 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self",(char *) "rect", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 arg2 = &temp2;
6606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6607 }
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6611
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 {
6616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6617 }
6618 return resultobj;
6619 fail:
6620 return NULL;
6621 }
6622
6623
6624 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6625 PyObject *resultobj;
6626 wxRegion *arg1 = (wxRegion *) 0 ;
6627 wxRegion *arg2 = 0 ;
6628 bool result;
6629 PyObject * obj0 = 0 ;
6630 PyObject * obj1 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self",(char *) "region", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(2)) SWIG_fail;
6641 if (arg2 == NULL) {
6642 SWIG_null_ref("wxRegion");
6643 }
6644 if (SWIG_arg_fail(2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 {
6654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6655 }
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj;
6664 wxRegion *arg1 = (wxRegion *) 0 ;
6665 bool result;
6666 PyObject * obj0 = 0 ;
6667 char *kwnames[] = {
6668 (char *) "self", NULL
6669 };
6670
6671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6673 if (SWIG_arg_fail(1)) SWIG_fail;
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (bool)(arg1)->IsEmpty();
6677
6678 wxPyEndAllowThreads(__tstate);
6679 if (PyErr_Occurred()) SWIG_fail;
6680 }
6681 {
6682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6683 }
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 wxRegion *arg1 = (wxRegion *) 0 ;
6693 int arg2 ;
6694 int arg3 ;
6695 int arg4 ;
6696 int arg5 ;
6697 bool result;
6698 PyObject * obj0 = 0 ;
6699 PyObject * obj1 = 0 ;
6700 PyObject * obj2 = 0 ;
6701 PyObject * obj3 = 0 ;
6702 PyObject * obj4 = 0 ;
6703 char *kwnames[] = {
6704 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6705 };
6706
6707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6709 if (SWIG_arg_fail(1)) SWIG_fail;
6710 {
6711 arg2 = (int)(SWIG_As_int(obj1));
6712 if (SWIG_arg_fail(2)) SWIG_fail;
6713 }
6714 {
6715 arg3 = (int)(SWIG_As_int(obj2));
6716 if (SWIG_arg_fail(3)) SWIG_fail;
6717 }
6718 {
6719 arg4 = (int)(SWIG_As_int(obj3));
6720 if (SWIG_arg_fail(4)) SWIG_fail;
6721 }
6722 {
6723 arg5 = (int)(SWIG_As_int(obj4));
6724 if (SWIG_arg_fail(5)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxRegion *arg1 = (wxRegion *) 0 ;
6745 wxRect *arg2 = 0 ;
6746 bool result;
6747 wxRect temp2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "rect", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = &temp2;
6759 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 {
6769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6770 }
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj;
6779 wxRegion *arg1 = (wxRegion *) 0 ;
6780 wxRegion *arg2 = 0 ;
6781 bool result;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "region", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(2)) SWIG_fail;
6794 if (arg2 == NULL) {
6795 SWIG_null_ref("wxRegion");
6796 }
6797 if (SWIG_arg_fail(2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 {
6807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6808 }
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6816 PyObject *resultobj;
6817 wxRegion *arg1 = (wxRegion *) 0 ;
6818 int arg2 ;
6819 int arg3 ;
6820 int arg4 ;
6821 int arg5 ;
6822 bool result;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 PyObject * obj3 = 0 ;
6827 PyObject * obj4 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = (int)(SWIG_As_int(obj1));
6837 if (SWIG_arg_fail(2)) SWIG_fail;
6838 }
6839 {
6840 arg3 = (int)(SWIG_As_int(obj2));
6841 if (SWIG_arg_fail(3)) SWIG_fail;
6842 }
6843 {
6844 arg4 = (int)(SWIG_As_int(obj3));
6845 if (SWIG_arg_fail(4)) SWIG_fail;
6846 }
6847 {
6848 arg5 = (int)(SWIG_As_int(obj4));
6849 if (SWIG_arg_fail(5)) SWIG_fail;
6850 }
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 {
6859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6868 PyObject *resultobj;
6869 wxRegion *arg1 = (wxRegion *) 0 ;
6870 wxRect *arg2 = 0 ;
6871 bool result;
6872 wxRect temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char *kwnames[] = {
6876 (char *) "self",(char *) "rect", NULL
6877 };
6878
6879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6881 if (SWIG_arg_fail(1)) SWIG_fail;
6882 {
6883 arg2 = &temp2;
6884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6885 }
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6889
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 {
6894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxRegion *arg1 = (wxRegion *) 0 ;
6905 wxRegion *arg2 = 0 ;
6906 bool result;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char *kwnames[] = {
6910 (char *) "self",(char *) "region", NULL
6911 };
6912
6913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6915 if (SWIG_arg_fail(1)) SWIG_fail;
6916 {
6917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(2)) SWIG_fail;
6919 if (arg2 == NULL) {
6920 SWIG_null_ref("wxRegion");
6921 }
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 {
6932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6933 }
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj;
6942 wxRegion *arg1 = (wxRegion *) 0 ;
6943 int arg2 ;
6944 int arg3 ;
6945 int arg4 ;
6946 int arg5 ;
6947 bool result;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 PyObject * obj2 = 0 ;
6951 PyObject * obj3 = 0 ;
6952 PyObject * obj4 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 arg2 = (int)(SWIG_As_int(obj1));
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 }
6964 {
6965 arg3 = (int)(SWIG_As_int(obj2));
6966 if (SWIG_arg_fail(3)) SWIG_fail;
6967 }
6968 {
6969 arg4 = (int)(SWIG_As_int(obj3));
6970 if (SWIG_arg_fail(4)) SWIG_fail;
6971 }
6972 {
6973 arg5 = (int)(SWIG_As_int(obj4));
6974 if (SWIG_arg_fail(5)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 {
6984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6985 }
6986 return resultobj;
6987 fail:
6988 return NULL;
6989 }
6990
6991
6992 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
6993 PyObject *resultobj;
6994 wxRegion *arg1 = (wxRegion *) 0 ;
6995 wxRect *arg2 = 0 ;
6996 bool result;
6997 wxRect temp2 ;
6998 PyObject * obj0 = 0 ;
6999 PyObject * obj1 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "self",(char *) "rect", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7006 if (SWIG_arg_fail(1)) SWIG_fail;
7007 {
7008 arg2 = &temp2;
7009 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7010 }
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 {
7019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxRegion *arg1 = (wxRegion *) 0 ;
7030 wxRegion *arg2 = 0 ;
7031 bool result;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 char *kwnames[] = {
7035 (char *) "self",(char *) "region", NULL
7036 };
7037
7038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7040 if (SWIG_arg_fail(1)) SWIG_fail;
7041 {
7042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(2)) SWIG_fail;
7044 if (arg2 == NULL) {
7045 SWIG_null_ref("wxRegion");
7046 }
7047 if (SWIG_arg_fail(2)) SWIG_fail;
7048 }
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 {
7057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7058 }
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxRegion *arg1 = (wxRegion *) 0 ;
7068 SwigValueWrapper<wxBitmap > result;
7069 PyObject * obj0 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "self", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 result = (arg1)->ConvertToBitmap();
7080
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 {
7085 wxBitmap * resultptr;
7086 resultptr = new wxBitmap((wxBitmap &)(result));
7087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxRegion *arg1 = (wxRegion *) 0 ;
7098 wxBitmap *arg2 = 0 ;
7099 bool result;
7100 PyObject * obj0 = 0 ;
7101 PyObject * obj1 = 0 ;
7102 char *kwnames[] = {
7103 (char *) "self",(char *) "bmp", NULL
7104 };
7105
7106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7108 if (SWIG_arg_fail(1)) SWIG_fail;
7109 {
7110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(2)) SWIG_fail;
7112 if (arg2 == NULL) {
7113 SWIG_null_ref("wxBitmap");
7114 }
7115 if (SWIG_arg_fail(2)) SWIG_fail;
7116 }
7117 {
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7120
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 {
7125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7126 }
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxRegion *arg1 = (wxRegion *) 0 ;
7136 wxBitmap *arg2 = 0 ;
7137 wxColour *arg3 = 0 ;
7138 int arg4 = (int) 0 ;
7139 bool result;
7140 wxColour temp3 ;
7141 PyObject * obj0 = 0 ;
7142 PyObject * obj1 = 0 ;
7143 PyObject * obj2 = 0 ;
7144 PyObject * obj3 = 0 ;
7145 char *kwnames[] = {
7146 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7147 };
7148
7149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7151 if (SWIG_arg_fail(1)) SWIG_fail;
7152 {
7153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(2)) SWIG_fail;
7155 if (arg2 == NULL) {
7156 SWIG_null_ref("wxBitmap");
7157 }
7158 if (SWIG_arg_fail(2)) SWIG_fail;
7159 }
7160 {
7161 arg3 = &temp3;
7162 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7163 }
7164 if (obj3) {
7165 {
7166 arg4 = (int)(SWIG_As_int(obj3));
7167 if (SWIG_arg_fail(4)) SWIG_fail;
7168 }
7169 }
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 {
7178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7187 PyObject *obj;
7188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7189 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7190 Py_INCREF(obj);
7191 return Py_BuildValue((char *)"");
7192 }
7193 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxRegion *arg1 = 0 ;
7196 wxRegionIterator *result;
7197 PyObject * obj0 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "region", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7203 {
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 if (arg1 == NULL) {
7207 SWIG_null_ref("wxRegion");
7208 }
7209 if (SWIG_arg_fail(1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7215
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj;
7228 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7229 PyObject * obj0 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 delete arg1;
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 Py_INCREF(Py_None); resultobj = Py_None;
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7254 int result;
7255 PyObject * obj0 = 0 ;
7256 char *kwnames[] = {
7257 (char *) "self", NULL
7258 };
7259
7260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7262 if (SWIG_arg_fail(1)) SWIG_fail;
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 result = (int)(arg1)->GetX();
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = SWIG_From_int((int)(result));
7272 }
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj;
7281 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7282 int result;
7283 PyObject * obj0 = 0 ;
7284 char *kwnames[] = {
7285 (char *) "self", NULL
7286 };
7287
7288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7290 if (SWIG_arg_fail(1)) SWIG_fail;
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (int)(arg1)->GetY();
7294
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 {
7299 resultobj = SWIG_From_int((int)(result));
7300 }
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7310 int result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "self", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7318 if (SWIG_arg_fail(1)) SWIG_fail;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (int)(arg1)->GetW();
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = SWIG_From_int((int)(result));
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj;
7337 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7338 int result;
7339 PyObject * obj0 = 0 ;
7340 char *kwnames[] = {
7341 (char *) "self", NULL
7342 };
7343
7344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7346 if (SWIG_arg_fail(1)) SWIG_fail;
7347 {
7348 PyThreadState* __tstate = wxPyBeginAllowThreads();
7349 result = (int)(arg1)->GetWidth();
7350
7351 wxPyEndAllowThreads(__tstate);
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 {
7355 resultobj = SWIG_From_int((int)(result));
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7364 PyObject *resultobj;
7365 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7366 int result;
7367 PyObject * obj0 = 0 ;
7368 char *kwnames[] = {
7369 (char *) "self", NULL
7370 };
7371
7372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7374 if (SWIG_arg_fail(1)) SWIG_fail;
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = (int)(arg1)->GetH();
7378
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 {
7383 resultobj = SWIG_From_int((int)(result));
7384 }
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj;
7393 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7394 int result;
7395 PyObject * obj0 = 0 ;
7396 char *kwnames[] = {
7397 (char *) "self", NULL
7398 };
7399
7400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(1)) SWIG_fail;
7403 {
7404 PyThreadState* __tstate = wxPyBeginAllowThreads();
7405 result = (int)(arg1)->GetHeight();
7406
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 {
7411 resultobj = SWIG_From_int((int)(result));
7412 }
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7422 wxRect result;
7423 PyObject * obj0 = 0 ;
7424 char *kwnames[] = {
7425 (char *) "self", NULL
7426 };
7427
7428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7430 if (SWIG_arg_fail(1)) SWIG_fail;
7431 {
7432 PyThreadState* __tstate = wxPyBeginAllowThreads();
7433 result = (arg1)->GetRect();
7434
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 {
7439 wxRect * resultptr;
7440 resultptr = new wxRect((wxRect &)(result));
7441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7442 }
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7452 bool result;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)(arg1)->HaveRects();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 {
7469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7470 }
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7480 PyObject * obj0 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Reset();
7491
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 Py_INCREF(Py_None); resultobj = Py_None;
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7505 PyObject * obj0 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 wxRegionIterator_Next(arg1);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 Py_INCREF(Py_None); resultobj = Py_None;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj;
7529 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7530 bool result;
7531 PyObject * obj0 = 0 ;
7532 char *kwnames[] = {
7533 (char *) "self", NULL
7534 };
7535
7536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",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 result = (bool)wxRegionIterator___nonzero__(arg1);
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7556 PyObject *obj;
7557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7558 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7559 Py_INCREF(obj);
7560 return Py_BuildValue((char *)"");
7561 }
7562 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj;
7564 wxNativeFontInfo *result;
7565 char *kwnames[] = {
7566 NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7587 PyObject * obj0 = 0 ;
7588 char *kwnames[] = {
7589 (char *) "self", NULL
7590 };
7591
7592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7594 if (SWIG_arg_fail(1)) SWIG_fail;
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 delete arg1;
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 Py_INCREF(Py_None); resultobj = Py_None;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7612 PyObject * obj0 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 (arg1)->Init();
7623
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 Py_INCREF(Py_None); resultobj = Py_None;
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7637 wxFont *arg2 = 0 ;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self",(char *) "font", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(2)) SWIG_fail;
7650 if (arg2 == NULL) {
7651 SWIG_null_ref("wxFont");
7652 }
7653 if (SWIG_arg_fail(2)) SWIG_fail;
7654 }
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->InitFromFont((wxFont const &)*arg2);
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 Py_INCREF(Py_None); resultobj = Py_None;
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj;
7671 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7672 int result;
7673 PyObject * obj0 = 0 ;
7674 char *kwnames[] = {
7675 (char *) "self", NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7680 if (SWIG_arg_fail(1)) SWIG_fail;
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7684
7685 wxPyEndAllowThreads(__tstate);
7686 if (PyErr_Occurred()) SWIG_fail;
7687 }
7688 {
7689 resultobj = SWIG_From_int((int)(result));
7690 }
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7698 PyObject *resultobj;
7699 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7700 wxFontStyle result;
7701 PyObject * obj0 = 0 ;
7702 char *kwnames[] = {
7703 (char *) "self", NULL
7704 };
7705
7706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7708 if (SWIG_arg_fail(1)) SWIG_fail;
7709 {
7710 PyThreadState* __tstate = wxPyBeginAllowThreads();
7711 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7712
7713 wxPyEndAllowThreads(__tstate);
7714 if (PyErr_Occurred()) SWIG_fail;
7715 }
7716 resultobj = SWIG_From_int((result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj;
7725 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7726 wxFontWeight result;
7727 PyObject * obj0 = 0 ;
7728 char *kwnames[] = {
7729 (char *) "self", NULL
7730 };
7731
7732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7734 if (SWIG_arg_fail(1)) SWIG_fail;
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7738
7739 wxPyEndAllowThreads(__tstate);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_From_int((result));
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj;
7751 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7752 bool result;
7753 PyObject * obj0 = 0 ;
7754 char *kwnames[] = {
7755 (char *) "self", NULL
7756 };
7757
7758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7760 if (SWIG_arg_fail(1)) SWIG_fail;
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7780 wxString result;
7781 PyObject * obj0 = 0 ;
7782 char *kwnames[] = {
7783 (char *) "self", NULL
7784 };
7785
7786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7788 if (SWIG_arg_fail(1)) SWIG_fail;
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7792
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 {
7797 #if wxUSE_UNICODE
7798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7799 #else
7800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7801 #endif
7802 }
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7810 PyObject *resultobj;
7811 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7812 wxFontFamily result;
7813 PyObject * obj0 = 0 ;
7814 char *kwnames[] = {
7815 (char *) "self", NULL
7816 };
7817
7818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7820 if (SWIG_arg_fail(1)) SWIG_fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_From_int((result));
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7838 wxFontEncoding result;
7839 PyObject * obj0 = 0 ;
7840 char *kwnames[] = {
7841 (char *) "self", NULL
7842 };
7843
7844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_From_int((result));
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj;
7863 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7864 int arg2 ;
7865 PyObject * obj0 = 0 ;
7866 PyObject * obj1 = 0 ;
7867 char *kwnames[] = {
7868 (char *) "self",(char *) "pointsize", NULL
7869 };
7870
7871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7873 if (SWIG_arg_fail(1)) SWIG_fail;
7874 {
7875 arg2 = (int)(SWIG_As_int(obj1));
7876 if (SWIG_arg_fail(2)) SWIG_fail;
7877 }
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 (arg1)->SetPointSize(arg2);
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 Py_INCREF(Py_None); resultobj = Py_None;
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7895 wxFontStyle arg2 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "self",(char *) "style", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7904 if (SWIG_arg_fail(1)) SWIG_fail;
7905 {
7906 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7907 if (SWIG_arg_fail(2)) SWIG_fail;
7908 }
7909 {
7910 PyThreadState* __tstate = wxPyBeginAllowThreads();
7911 (arg1)->SetStyle((wxFontStyle )arg2);
7912
7913 wxPyEndAllowThreads(__tstate);
7914 if (PyErr_Occurred()) SWIG_fail;
7915 }
7916 Py_INCREF(Py_None); resultobj = Py_None;
7917 return resultobj;
7918 fail:
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7926 wxFontWeight arg2 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "weight", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 (arg1)->SetWeight((wxFontWeight )arg2);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 Py_INCREF(Py_None); resultobj = Py_None;
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7957 bool arg2 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "self",(char *) "underlined", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(1)) SWIG_fail;
7967 {
7968 arg2 = (bool)(SWIG_As_bool(obj1));
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 (arg1)->SetUnderlined(arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7988 wxString arg2 ;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self",(char *) "facename", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 wxString* sptr = wxString_in_helper(obj1);
8000 if (sptr == NULL) SWIG_fail;
8001 arg2 = *sptr;
8002 delete sptr;
8003 }
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetFaceName(arg2);
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 Py_INCREF(Py_None); resultobj = Py_None;
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj;
8020 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8021 wxFontFamily arg2 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "self",(char *) "family", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8030 if (SWIG_arg_fail(1)) SWIG_fail;
8031 {
8032 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8033 if (SWIG_arg_fail(2)) SWIG_fail;
8034 }
8035 {
8036 PyThreadState* __tstate = wxPyBeginAllowThreads();
8037 (arg1)->SetFamily((wxFontFamily )arg2);
8038
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 Py_INCREF(Py_None); resultobj = Py_None;
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj;
8051 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8052 wxFontEncoding arg2 ;
8053 PyObject * obj0 = 0 ;
8054 PyObject * obj1 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self",(char *) "encoding", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8064 if (SWIG_arg_fail(2)) SWIG_fail;
8065 }
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 (arg1)->SetEncoding((wxFontEncoding )arg2);
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 Py_INCREF(Py_None); resultobj = Py_None;
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8083 wxString *arg2 = 0 ;
8084 bool result;
8085 bool temp2 = false ;
8086 PyObject * obj0 = 0 ;
8087 PyObject * obj1 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self",(char *) "s", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 arg2 = wxString_in_helper(obj1);
8097 if (arg2 == NULL) SWIG_fail;
8098 temp2 = true;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8109 }
8110 {
8111 if (temp2)
8112 delete arg2;
8113 }
8114 return resultobj;
8115 fail:
8116 {
8117 if (temp2)
8118 delete arg2;
8119 }
8120 return NULL;
8121 }
8122
8123
8124 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj;
8126 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8127 wxString result;
8128 PyObject * obj0 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = ((wxNativeFontInfo const *)arg1)->ToString();
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8159 wxString result;
8160 PyObject * obj0 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = wxNativeFontInfo___str__(arg1);
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 #if wxUSE_UNICODE
8177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8178 #else
8179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8180 #endif
8181 }
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8189 PyObject *resultobj;
8190 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8191 wxString *arg2 = 0 ;
8192 bool result;
8193 bool temp2 = false ;
8194 PyObject * obj0 = 0 ;
8195 PyObject * obj1 = 0 ;
8196 char *kwnames[] = {
8197 (char *) "self",(char *) "s", NULL
8198 };
8199
8200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8202 if (SWIG_arg_fail(1)) SWIG_fail;
8203 {
8204 arg2 = wxString_in_helper(obj1);
8205 if (arg2 == NULL) SWIG_fail;
8206 temp2 = true;
8207 }
8208 {
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8211
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 {
8216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8217 }
8218 {
8219 if (temp2)
8220 delete arg2;
8221 }
8222 return resultobj;
8223 fail:
8224 {
8225 if (temp2)
8226 delete arg2;
8227 }
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8235 wxString result;
8236 PyObject * obj0 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 #if wxUSE_UNICODE
8253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8254 #else
8255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8256 #endif
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8265 PyObject *obj;
8266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8267 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8268 Py_INCREF(obj);
8269 return Py_BuildValue((char *)"");
8270 }
8271 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8272 PyObject *resultobj;
8273 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8274 wxString *arg2 = (wxString *) 0 ;
8275 bool temp2 = false ;
8276 PyObject * obj0 = 0 ;
8277 PyObject * obj1 = 0 ;
8278 char *kwnames[] = {
8279 (char *) "self",(char *) "facename", NULL
8280 };
8281
8282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8284 if (SWIG_arg_fail(1)) SWIG_fail;
8285 {
8286 arg2 = wxString_in_helper(obj1);
8287 if (arg2 == NULL) SWIG_fail;
8288 temp2 = true;
8289 }
8290 if (arg1) (arg1)->facename = *arg2;
8291
8292 Py_INCREF(Py_None); resultobj = Py_None;
8293 {
8294 if (temp2)
8295 delete arg2;
8296 }
8297 return resultobj;
8298 fail:
8299 {
8300 if (temp2)
8301 delete arg2;
8302 }
8303 return NULL;
8304 }
8305
8306
8307 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj;
8309 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8310 wxString *result;
8311 PyObject * obj0 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 result = (wxString *)& ((arg1)->facename);
8320
8321 {
8322 #if wxUSE_UNICODE
8323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8324 #else
8325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8326 #endif
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8337 wxFontEncoding arg2 ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "encoding", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 {
8348 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8349 if (SWIG_arg_fail(2)) SWIG_fail;
8350 }
8351 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8352
8353 Py_INCREF(Py_None); resultobj = Py_None;
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8363 wxFontEncoding result;
8364 PyObject * obj0 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 result = (wxFontEncoding) ((arg1)->encoding);
8373
8374 resultobj = SWIG_From_int((result));
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxNativeEncodingInfo *result;
8384 char *kwnames[] = {
8385 NULL
8386 };
8387
8388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8392
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj;
8405 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 delete arg1;
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 Py_INCREF(Py_None); resultobj = Py_None;
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8431 wxString *arg2 = 0 ;
8432 bool result;
8433 bool temp2 = false ;
8434 PyObject * obj0 = 0 ;
8435 PyObject * obj1 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self",(char *) "s", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 arg2 = wxString_in_helper(obj1);
8445 if (arg2 == NULL) SWIG_fail;
8446 temp2 = true;
8447 }
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8451
8452 wxPyEndAllowThreads(__tstate);
8453 if (PyErr_Occurred()) SWIG_fail;
8454 }
8455 {
8456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8457 }
8458 {
8459 if (temp2)
8460 delete arg2;
8461 }
8462 return resultobj;
8463 fail:
8464 {
8465 if (temp2)
8466 delete arg2;
8467 }
8468 return NULL;
8469 }
8470
8471
8472 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj;
8474 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8475 wxString result;
8476 PyObject * obj0 = 0 ;
8477 char *kwnames[] = {
8478 (char *) "self", NULL
8479 };
8480
8481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8483 if (SWIG_arg_fail(1)) SWIG_fail;
8484 {
8485 PyThreadState* __tstate = wxPyBeginAllowThreads();
8486 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8487
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 {
8492 #if wxUSE_UNICODE
8493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8494 #else
8495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8496 #endif
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxFontEncoding arg1 ;
8514 wxNativeEncodingInfo *result;
8515 PyObject * obj0 = 0 ;
8516 char *kwnames[] = {
8517 (char *) "encoding", NULL
8518 };
8519
8520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8521 {
8522 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 }
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj;
8541 wxNativeEncodingInfo *arg1 = 0 ;
8542 bool result;
8543 PyObject * obj0 = 0 ;
8544 char *kwnames[] = {
8545 (char *) "info", NULL
8546 };
8547
8548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8549 {
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 if (arg1 == NULL) {
8553 SWIG_null_ref("wxNativeEncodingInfo");
8554 }
8555 if (SWIG_arg_fail(1)) SWIG_fail;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 {
8565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8566 }
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj;
8575 wxFontMapper *result;
8576 char *kwnames[] = {
8577 NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (wxFontMapper *)new wxFontMapper();
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8598 PyObject * obj0 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 delete arg1;
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 Py_INCREF(Py_None); resultobj = Py_None;
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj;
8622 wxFontMapper *result;
8623 char *kwnames[] = {
8624 NULL
8625 };
8626
8627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (wxFontMapper *)wxFontMapper::Get();
8631
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj;
8644 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8645 wxFontMapper *result;
8646 PyObject * obj0 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "mapper", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8669 PyObject *resultobj;
8670 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8671 wxString *arg2 = 0 ;
8672 bool arg3 = (bool) true ;
8673 wxFontEncoding result;
8674 bool temp2 = false ;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 PyObject * obj2 = 0 ;
8678 char *kwnames[] = {
8679 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8680 };
8681
8682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 {
8686 arg2 = wxString_in_helper(obj1);
8687 if (arg2 == NULL) SWIG_fail;
8688 temp2 = true;
8689 }
8690 if (obj2) {
8691 {
8692 arg3 = (bool)(SWIG_As_bool(obj2));
8693 if (SWIG_arg_fail(3)) SWIG_fail;
8694 }
8695 }
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8699
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_From_int((result));
8704 {
8705 if (temp2)
8706 delete arg2;
8707 }
8708 return resultobj;
8709 fail:
8710 {
8711 if (temp2)
8712 delete arg2;
8713 }
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 size_t result;
8721 char *kwnames[] = {
8722 NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8726 {
8727 PyThreadState* __tstate = wxPyBeginAllowThreads();
8728 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8729
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 size_t arg1 ;
8745 wxFontEncoding result;
8746 PyObject * obj0 = 0 ;
8747 char *kwnames[] = {
8748 (char *) "n", NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8752 {
8753 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 }
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8759
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 resultobj = SWIG_From_int((result));
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj;
8772 wxFontEncoding arg1 ;
8773 wxString result;
8774 PyObject * obj0 = 0 ;
8775 char *kwnames[] = {
8776 (char *) "encoding", NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8780 {
8781 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8782 if (SWIG_arg_fail(1)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 #if wxUSE_UNICODE
8793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8794 #else
8795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8796 #endif
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxFontEncoding arg1 ;
8807 wxString result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "encoding", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8814 {
8815 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 #if wxUSE_UNICODE
8827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8828 #else
8829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8830 #endif
8831 }
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxString *arg1 = 0 ;
8841 wxFontEncoding result;
8842 bool temp1 = false ;
8843 PyObject * obj0 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "name", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8849 {
8850 arg1 = wxString_in_helper(obj0);
8851 if (arg1 == NULL) SWIG_fail;
8852 temp1 = true;
8853 }
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_From_int((result));
8862 {
8863 if (temp1)
8864 delete arg1;
8865 }
8866 return resultobj;
8867 fail:
8868 {
8869 if (temp1)
8870 delete arg1;
8871 }
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8879 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "config", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(2)) SWIG_fail;
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 (arg1)->SetConfig(arg2);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 Py_INCREF(Py_None); resultobj = Py_None;
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj;
8907 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8908 wxString *arg2 = 0 ;
8909 bool temp2 = false ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "prefix", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 (arg1)->SetConfigPath((wxString const &)*arg2);
8927
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 Py_INCREF(Py_None); resultobj = Py_None;
8932 {
8933 if (temp2)
8934 delete arg2;
8935 }
8936 return resultobj;
8937 fail:
8938 {
8939 if (temp2)
8940 delete arg2;
8941 }
8942 return NULL;
8943 }
8944
8945
8946 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj;
8948 wxString result;
8949 char *kwnames[] = {
8950 NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 result = wxFontMapper::GetDefaultConfigPath();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 {
8962 #if wxUSE_UNICODE
8963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8964 #else
8965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8966 #endif
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8977 wxFontEncoding arg2 ;
8978 wxString const &arg3_defvalue = wxPyEmptyString ;
8979 wxString *arg3 = (wxString *) &arg3_defvalue ;
8980 bool arg4 = (bool) true ;
8981 PyObject *result;
8982 bool temp3 = false ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 PyObject * obj2 = 0 ;
8986 PyObject * obj3 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8993 if (SWIG_arg_fail(1)) SWIG_fail;
8994 {
8995 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 }
8998 if (obj2) {
8999 {
9000 arg3 = wxString_in_helper(obj2);
9001 if (arg3 == NULL) SWIG_fail;
9002 temp3 = true;
9003 }
9004 }
9005 if (obj3) {
9006 {
9007 arg4 = (bool)(SWIG_As_bool(obj3));
9008 if (SWIG_arg_fail(4)) SWIG_fail;
9009 }
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9014
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 resultobj = result;
9019 {
9020 if (temp3)
9021 delete arg3;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp3)
9027 delete arg3;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9036 wxFontEncoding arg2 ;
9037 wxString const &arg3_defvalue = wxPyEmptyString ;
9038 wxString *arg3 = (wxString *) &arg3_defvalue ;
9039 bool result;
9040 bool temp3 = false ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9050 if (SWIG_arg_fail(1)) SWIG_fail;
9051 {
9052 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9053 if (SWIG_arg_fail(2)) SWIG_fail;
9054 }
9055 if (obj2) {
9056 {
9057 arg3 = wxString_in_helper(obj2);
9058 if (arg3 == NULL) SWIG_fail;
9059 temp3 = true;
9060 }
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 {
9070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9071 }
9072 {
9073 if (temp3)
9074 delete arg3;
9075 }
9076 return resultobj;
9077 fail:
9078 {
9079 if (temp3)
9080 delete arg3;
9081 }
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9089 wxWindow *arg2 = (wxWindow *) 0 ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "self",(char *) "parent", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9100 if (SWIG_arg_fail(2)) SWIG_fail;
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->SetDialogParent(arg2);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 Py_INCREF(Py_None); resultobj = Py_None;
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9118 wxString *arg2 = 0 ;
9119 bool temp2 = false ;
9120 PyObject * obj0 = 0 ;
9121 PyObject * obj1 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "self",(char *) "title", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 {
9130 arg2 = wxString_in_helper(obj1);
9131 if (arg2 == NULL) SWIG_fail;
9132 temp2 = true;
9133 }
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 (arg1)->SetDialogTitle((wxString const &)*arg2);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return resultobj;
9147 fail:
9148 {
9149 if (temp2)
9150 delete arg2;
9151 }
9152 return NULL;
9153 }
9154
9155
9156 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9157 PyObject *obj;
9158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9159 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9160 Py_INCREF(obj);
9161 return Py_BuildValue((char *)"");
9162 }
9163 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 int arg1 ;
9166 int arg2 ;
9167 int arg3 ;
9168 int arg4 ;
9169 bool arg5 = (bool) false ;
9170 wxString const &arg6_defvalue = wxPyEmptyString ;
9171 wxString *arg6 = (wxString *) &arg6_defvalue ;
9172 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9173 wxFont *result;
9174 bool temp6 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 PyObject * obj2 = 0 ;
9178 PyObject * obj3 = 0 ;
9179 PyObject * obj4 = 0 ;
9180 PyObject * obj5 = 0 ;
9181 PyObject * obj6 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9187 {
9188 arg1 = (int)(SWIG_As_int(obj0));
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 }
9191 {
9192 arg2 = (int)(SWIG_As_int(obj1));
9193 if (SWIG_arg_fail(2)) SWIG_fail;
9194 }
9195 {
9196 arg3 = (int)(SWIG_As_int(obj2));
9197 if (SWIG_arg_fail(3)) SWIG_fail;
9198 }
9199 {
9200 arg4 = (int)(SWIG_As_int(obj3));
9201 if (SWIG_arg_fail(4)) SWIG_fail;
9202 }
9203 if (obj4) {
9204 {
9205 arg5 = (bool)(SWIG_As_bool(obj4));
9206 if (SWIG_arg_fail(5)) SWIG_fail;
9207 }
9208 }
9209 if (obj5) {
9210 {
9211 arg6 = wxString_in_helper(obj5);
9212 if (arg6 == NULL) SWIG_fail;
9213 temp6 = true;
9214 }
9215 }
9216 if (obj6) {
9217 {
9218 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9219 if (SWIG_arg_fail(7)) SWIG_fail;
9220 }
9221 }
9222 {
9223 if (!wxPyCheckForApp()) SWIG_fail;
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9226
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9231 {
9232 if (temp6)
9233 delete arg6;
9234 }
9235 return resultobj;
9236 fail:
9237 {
9238 if (temp6)
9239 delete arg6;
9240 }
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxFont *arg1 = (wxFont *) 0 ;
9248 PyObject * obj0 = 0 ;
9249 char *kwnames[] = {
9250 (char *) "self", NULL
9251 };
9252
9253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9255 if (SWIG_arg_fail(1)) SWIG_fail;
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 delete arg1;
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 Py_INCREF(Py_None); resultobj = Py_None;
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj;
9272 wxNativeFontInfo *arg1 = 0 ;
9273 wxFont *result;
9274 PyObject * obj0 = 0 ;
9275 char *kwnames[] = {
9276 (char *) "info", NULL
9277 };
9278
9279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9280 {
9281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9282 if (SWIG_arg_fail(1)) SWIG_fail;
9283 if (arg1 == NULL) {
9284 SWIG_null_ref("wxNativeFontInfo");
9285 }
9286 if (SWIG_arg_fail(1)) SWIG_fail;
9287 }
9288 {
9289 if (!wxPyCheckForApp()) SWIG_fail;
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj;
9305 wxString *arg1 = 0 ;
9306 wxFont *result;
9307 bool temp1 = false ;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "info", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9314 {
9315 arg1 = wxString_in_helper(obj0);
9316 if (arg1 == NULL) SWIG_fail;
9317 temp1 = true;
9318 }
9319 {
9320 if (!wxPyCheckForApp()) SWIG_fail;
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9328 {
9329 if (temp1)
9330 delete arg1;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp1)
9336 delete arg1;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 int arg1 ;
9345 wxFontFamily arg2 ;
9346 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9347 wxString const &arg4_defvalue = wxPyEmptyString ;
9348 wxString *arg4 = (wxString *) &arg4_defvalue ;
9349 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9350 wxFont *result;
9351 bool temp4 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 PyObject * obj2 = 0 ;
9355 PyObject * obj3 = 0 ;
9356 PyObject * obj4 = 0 ;
9357 char *kwnames[] = {
9358 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9362 {
9363 arg1 = (int)(SWIG_As_int(obj0));
9364 if (SWIG_arg_fail(1)) SWIG_fail;
9365 }
9366 {
9367 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9368 if (SWIG_arg_fail(2)) SWIG_fail;
9369 }
9370 if (obj2) {
9371 {
9372 arg3 = (int)(SWIG_As_int(obj2));
9373 if (SWIG_arg_fail(3)) SWIG_fail;
9374 }
9375 }
9376 if (obj3) {
9377 {
9378 arg4 = wxString_in_helper(obj3);
9379 if (arg4 == NULL) SWIG_fail;
9380 temp4 = true;
9381 }
9382 }
9383 if (obj4) {
9384 {
9385 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9386 if (SWIG_arg_fail(5)) SWIG_fail;
9387 }
9388 }
9389 {
9390 if (!wxPyCheckForApp()) SWIG_fail;
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9398 {
9399 if (temp4)
9400 delete arg4;
9401 }
9402 return resultobj;
9403 fail:
9404 {
9405 if (temp4)
9406 delete arg4;
9407 }
9408 return NULL;
9409 }
9410
9411
9412 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj;
9414 wxSize *arg1 = 0 ;
9415 int arg2 ;
9416 int arg3 ;
9417 int arg4 ;
9418 bool arg5 = (bool) false ;
9419 wxString const &arg6_defvalue = wxEmptyString ;
9420 wxString *arg6 = (wxString *) &arg6_defvalue ;
9421 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9422 wxFont *result;
9423 wxSize temp1 ;
9424 bool temp6 = false ;
9425 PyObject * obj0 = 0 ;
9426 PyObject * obj1 = 0 ;
9427 PyObject * obj2 = 0 ;
9428 PyObject * obj3 = 0 ;
9429 PyObject * obj4 = 0 ;
9430 PyObject * obj5 = 0 ;
9431 PyObject * obj6 = 0 ;
9432 char *kwnames[] = {
9433 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9437 {
9438 arg1 = &temp1;
9439 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9440 }
9441 {
9442 arg2 = (int)(SWIG_As_int(obj1));
9443 if (SWIG_arg_fail(2)) SWIG_fail;
9444 }
9445 {
9446 arg3 = (int)(SWIG_As_int(obj2));
9447 if (SWIG_arg_fail(3)) SWIG_fail;
9448 }
9449 {
9450 arg4 = (int)(SWIG_As_int(obj3));
9451 if (SWIG_arg_fail(4)) SWIG_fail;
9452 }
9453 if (obj4) {
9454 {
9455 arg5 = (bool)(SWIG_As_bool(obj4));
9456 if (SWIG_arg_fail(5)) SWIG_fail;
9457 }
9458 }
9459 if (obj5) {
9460 {
9461 arg6 = wxString_in_helper(obj5);
9462 if (arg6 == NULL) SWIG_fail;
9463 temp6 = true;
9464 }
9465 }
9466 if (obj6) {
9467 {
9468 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9469 if (SWIG_arg_fail(7)) SWIG_fail;
9470 }
9471 }
9472 {
9473 if (!wxPyCheckForApp()) SWIG_fail;
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9481 {
9482 if (temp6)
9483 delete arg6;
9484 }
9485 return resultobj;
9486 fail:
9487 {
9488 if (temp6)
9489 delete arg6;
9490 }
9491 return NULL;
9492 }
9493
9494
9495 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxFont *arg1 = (wxFont *) 0 ;
9498 bool result;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "self", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9506 if (SWIG_arg_fail(1)) SWIG_fail;
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (bool)((wxFont const *)arg1)->Ok();
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 {
9515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9516 }
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj;
9525 wxFont *arg1 = (wxFont *) 0 ;
9526 wxFont *arg2 = (wxFont *) 0 ;
9527 bool result;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 char *kwnames[] = {
9531 (char *) "self",(char *) "other", NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(1)) SWIG_fail;
9537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(2)) SWIG_fail;
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 {
9547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9548 }
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxFont *arg1 = (wxFont *) 0 ;
9558 wxFont *arg2 = (wxFont *) 0 ;
9559 bool result;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 char *kwnames[] = {
9563 (char *) "self",(char *) "other", NULL
9564 };
9565
9566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(1)) SWIG_fail;
9569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9570 if (SWIG_arg_fail(2)) SWIG_fail;
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9574
9575 wxPyEndAllowThreads(__tstate);
9576 if (PyErr_Occurred()) SWIG_fail;
9577 }
9578 {
9579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9580 }
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj;
9589 wxFont *arg1 = (wxFont *) 0 ;
9590 int result;
9591 PyObject * obj0 = 0 ;
9592 char *kwnames[] = {
9593 (char *) "self", NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9598 if (SWIG_arg_fail(1)) SWIG_fail;
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)((wxFont const *)arg1)->GetPointSize();
9602
9603 wxPyEndAllowThreads(__tstate);
9604 if (PyErr_Occurred()) SWIG_fail;
9605 }
9606 {
9607 resultobj = SWIG_From_int((int)(result));
9608 }
9609 return resultobj;
9610 fail:
9611 return NULL;
9612 }
9613
9614
9615 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxFont *arg1 = (wxFont *) 0 ;
9618 wxSize result;
9619 PyObject * obj0 = 0 ;
9620 char *kwnames[] = {
9621 (char *) "self", NULL
9622 };
9623
9624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9626 if (SWIG_arg_fail(1)) SWIG_fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = ((wxFont const *)arg1)->GetPixelSize();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 {
9635 wxSize * resultptr;
9636 resultptr = new wxSize((wxSize &)(result));
9637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9638 }
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxFont *arg1 = (wxFont *) 0 ;
9648 bool result;
9649 PyObject * obj0 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9660
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 {
9665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9666 }
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxFont *arg1 = (wxFont *) 0 ;
9676 int result;
9677 PyObject * obj0 = 0 ;
9678 char *kwnames[] = {
9679 (char *) "self", NULL
9680 };
9681
9682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9684 if (SWIG_arg_fail(1)) SWIG_fail;
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 result = (int)((wxFont const *)arg1)->GetFamily();
9688
9689 wxPyEndAllowThreads(__tstate);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 {
9693 resultobj = SWIG_From_int((int)(result));
9694 }
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj;
9703 wxFont *arg1 = (wxFont *) 0 ;
9704 int result;
9705 PyObject * obj0 = 0 ;
9706 char *kwnames[] = {
9707 (char *) "self", NULL
9708 };
9709
9710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9712 if (SWIG_arg_fail(1)) SWIG_fail;
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 result = (int)((wxFont const *)arg1)->GetStyle();
9716
9717 wxPyEndAllowThreads(__tstate);
9718 if (PyErr_Occurred()) SWIG_fail;
9719 }
9720 {
9721 resultobj = SWIG_From_int((int)(result));
9722 }
9723 return resultobj;
9724 fail:
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxFont *arg1 = (wxFont *) 0 ;
9732 int result;
9733 PyObject * obj0 = 0 ;
9734 char *kwnames[] = {
9735 (char *) "self", NULL
9736 };
9737
9738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9740 if (SWIG_arg_fail(1)) SWIG_fail;
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (int)((wxFont const *)arg1)->GetWeight();
9744
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 {
9749 resultobj = SWIG_From_int((int)(result));
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxFont *arg1 = (wxFont *) 0 ;
9760 bool result;
9761 PyObject * obj0 = 0 ;
9762 char *kwnames[] = {
9763 (char *) "self", NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9768 if (SWIG_arg_fail(1)) SWIG_fail;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9778 }
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxFont *arg1 = (wxFont *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = ((wxFont const *)arg1)->GetFaceName();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj;
9819 wxFont *arg1 = (wxFont *) 0 ;
9820 wxFontEncoding result;
9821 PyObject * obj0 = 0 ;
9822 char *kwnames[] = {
9823 (char *) "self", NULL
9824 };
9825
9826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9828 if (SWIG_arg_fail(1)) SWIG_fail;
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_From_int((result));
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxFont *arg1 = (wxFont *) 0 ;
9846 wxNativeFontInfo *result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxFont *arg1 = (wxFont *) 0 ;
9872 bool result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxFont *arg1 = (wxFont *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxFont *arg1 = (wxFont *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxFont *arg1 = (wxFont *) 0 ;
9964 int arg2 ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "self",(char *) "pointSize", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
9976 if (SWIG_arg_fail(2)) SWIG_fail;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 (arg1)->SetPointSize(arg2);
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 Py_INCREF(Py_None); resultobj = Py_None;
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxFont *arg1 = (wxFont *) 0 ;
9995 wxSize *arg2 = 0 ;
9996 wxSize temp2 ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "pixelSize", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = &temp2;
10008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 (arg1)->SetPixelSize((wxSize const &)*arg2);
10013
10014 wxPyEndAllowThreads(__tstate);
10015 if (PyErr_Occurred()) SWIG_fail;
10016 }
10017 Py_INCREF(Py_None); resultobj = Py_None;
10018 return resultobj;
10019 fail:
10020 return NULL;
10021 }
10022
10023
10024 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10025 PyObject *resultobj;
10026 wxFont *arg1 = (wxFont *) 0 ;
10027 int arg2 ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char *kwnames[] = {
10031 (char *) "self",(char *) "family", NULL
10032 };
10033
10034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10036 if (SWIG_arg_fail(1)) SWIG_fail;
10037 {
10038 arg2 = (int)(SWIG_As_int(obj1));
10039 if (SWIG_arg_fail(2)) SWIG_fail;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 (arg1)->SetFamily(arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 Py_INCREF(Py_None); resultobj = Py_None;
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxFont *arg1 = (wxFont *) 0 ;
10058 int arg2 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "self",(char *) "style", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10067 if (SWIG_arg_fail(1)) SWIG_fail;
10068 {
10069 arg2 = (int)(SWIG_As_int(obj1));
10070 if (SWIG_arg_fail(2)) SWIG_fail;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 (arg1)->SetStyle(arg2);
10075
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 Py_INCREF(Py_None); resultobj = Py_None;
10080 return resultobj;
10081 fail:
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxFont *arg1 = (wxFont *) 0 ;
10089 int arg2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "weight", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",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 = (int)(SWIG_As_int(obj1));
10101 if (SWIG_arg_fail(2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetWeight(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_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxFont *arg1 = (wxFont *) 0 ;
10120 wxString *arg2 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "self",(char *) "faceName", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10130 if (SWIG_arg_fail(1)) SWIG_fail;
10131 {
10132 arg2 = wxString_in_helper(obj1);
10133 if (arg2 == NULL) SWIG_fail;
10134 temp2 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 (arg1)->SetFaceName((wxString const &)*arg2);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxFont *arg1 = (wxFont *) 0 ;
10161 bool arg2 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "underlined", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = (bool)(SWIG_As_bool(obj1));
10173 if (SWIG_arg_fail(2)) SWIG_fail;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 (arg1)->SetUnderlined(arg2);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 return resultobj;
10184 fail:
10185 return NULL;
10186 }
10187
10188
10189 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10190 PyObject *resultobj;
10191 wxFont *arg1 = (wxFont *) 0 ;
10192 wxFontEncoding arg2 ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "self",(char *) "encoding", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10201 if (SWIG_arg_fail(1)) SWIG_fail;
10202 {
10203 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10204 if (SWIG_arg_fail(2)) SWIG_fail;
10205 }
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 (arg1)->SetEncoding((wxFontEncoding )arg2);
10209
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 Py_INCREF(Py_None); resultobj = Py_None;
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj;
10222 wxFont *arg1 = (wxFont *) 0 ;
10223 wxNativeFontInfo *arg2 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 PyObject * obj1 = 0 ;
10226 char *kwnames[] = {
10227 (char *) "self",(char *) "info", NULL
10228 };
10229
10230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10232 if (SWIG_arg_fail(1)) SWIG_fail;
10233 {
10234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10235 if (SWIG_arg_fail(2)) SWIG_fail;
10236 if (arg2 == NULL) {
10237 SWIG_null_ref("wxNativeFontInfo");
10238 }
10239 if (SWIG_arg_fail(2)) SWIG_fail;
10240 }
10241 {
10242 PyThreadState* __tstate = wxPyBeginAllowThreads();
10243 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10244
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 Py_INCREF(Py_None); resultobj = Py_None;
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10256 PyObject *resultobj;
10257 wxFont *arg1 = (wxFont *) 0 ;
10258 wxString *arg2 = 0 ;
10259 bool temp2 = false ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char *kwnames[] = {
10263 (char *) "self",(char *) "info", NULL
10264 };
10265
10266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10268 if (SWIG_arg_fail(1)) SWIG_fail;
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 Py_INCREF(Py_None); resultobj = Py_None;
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxFont *arg1 = (wxFont *) 0 ;
10299 wxString *arg2 = 0 ;
10300 bool temp2 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "info", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10318
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 Py_INCREF(Py_None); resultobj = Py_None;
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp2)
10331 delete arg2;
10332 }
10333 return NULL;
10334 }
10335
10336
10337 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj;
10339 wxFont *arg1 = (wxFont *) 0 ;
10340 wxString result;
10341 PyObject * obj0 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "self", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(1)) SWIG_fail;
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 result = ((wxFont const *)arg1)->GetFamilyString();
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 {
10357 #if wxUSE_UNICODE
10358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10359 #else
10360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10361 #endif
10362 }
10363 return resultobj;
10364 fail:
10365 return NULL;
10366 }
10367
10368
10369 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10370 PyObject *resultobj;
10371 wxFont *arg1 = (wxFont *) 0 ;
10372 wxString result;
10373 PyObject * obj0 = 0 ;
10374 char *kwnames[] = {
10375 (char *) "self", NULL
10376 };
10377
10378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10380 if (SWIG_arg_fail(1)) SWIG_fail;
10381 {
10382 PyThreadState* __tstate = wxPyBeginAllowThreads();
10383 result = ((wxFont const *)arg1)->GetStyleString();
10384
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 #if wxUSE_UNICODE
10390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10391 #else
10392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10393 #endif
10394 }
10395 return resultobj;
10396 fail:
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj;
10403 wxFont *arg1 = (wxFont *) 0 ;
10404 wxString result;
10405 PyObject * obj0 = 0 ;
10406 char *kwnames[] = {
10407 (char *) "self", NULL
10408 };
10409
10410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 {
10414 PyThreadState* __tstate = wxPyBeginAllowThreads();
10415 result = ((wxFont const *)arg1)->GetWeightString();
10416
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 {
10421 #if wxUSE_UNICODE
10422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10423 #else
10424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10425 #endif
10426 }
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj;
10435 wxFont *arg1 = (wxFont *) 0 ;
10436 bool arg2 = (bool) true ;
10437 PyObject * obj0 = 0 ;
10438 PyObject * obj1 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "self",(char *) "no", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10445 if (SWIG_arg_fail(1)) SWIG_fail;
10446 if (obj1) {
10447 {
10448 arg2 = (bool)(SWIG_As_bool(obj1));
10449 if (SWIG_arg_fail(2)) SWIG_fail;
10450 }
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->SetNoAntiAliasing(arg2);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj;
10468 wxFont *arg1 = (wxFont *) 0 ;
10469 bool result;
10470 PyObject * obj0 = 0 ;
10471 char *kwnames[] = {
10472 (char *) "self", NULL
10473 };
10474
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10477 if (SWIG_arg_fail(1)) SWIG_fail;
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10481
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj;
10496 wxFontEncoding result;
10497 char *kwnames[] = {
10498 NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10502 {
10503 if (!wxPyCheckForApp()) SWIG_fail;
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_From_int((result));
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10518 PyObject *resultobj;
10519 wxFontEncoding arg1 ;
10520 PyObject * obj0 = 0 ;
10521 char *kwnames[] = {
10522 (char *) "encoding", NULL
10523 };
10524
10525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10526 {
10527 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10528 if (SWIG_arg_fail(1)) SWIG_fail;
10529 }
10530 {
10531 if (!wxPyCheckForApp()) SWIG_fail;
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10534
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 Py_INCREF(Py_None); resultobj = Py_None;
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10546 PyObject *obj;
10547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10548 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10549 Py_INCREF(obj);
10550 return Py_BuildValue((char *)"");
10551 }
10552 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 wxPyFontEnumerator *result;
10555 char *kwnames[] = {
10556 NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10560 {
10561 if (!wxPyCheckForApp()) SWIG_fail;
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10564
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10578 PyObject * obj0 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "self", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10585 if (SWIG_arg_fail(1)) SWIG_fail;
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 delete arg1;
10589
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 Py_INCREF(Py_None); resultobj = Py_None;
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj;
10602 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10603 PyObject *arg2 = (PyObject *) 0 ;
10604 PyObject *arg3 = (PyObject *) 0 ;
10605 bool arg4 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 PyObject * obj3 = 0 ;
10610 char *kwnames[] = {
10611 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10612 };
10613
10614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 arg2 = obj1;
10618 arg3 = obj2;
10619 {
10620 arg4 = (bool)(SWIG_As_bool(obj3));
10621 if (SWIG_arg_fail(4)) SWIG_fail;
10622 }
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10626
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 Py_INCREF(Py_None); resultobj = Py_None;
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj;
10639 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10640 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10641 bool arg3 = (bool) false ;
10642 bool result;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char *kwnames[] = {
10647 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10648 };
10649
10650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10652 if (SWIG_arg_fail(1)) SWIG_fail;
10653 if (obj1) {
10654 {
10655 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (bool)(SWIG_As_bool(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 {
10673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10674 }
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10684 wxString const &arg2_defvalue = wxPyEmptyString ;
10685 wxString *arg2 = (wxString *) &arg2_defvalue ;
10686 bool result;
10687 bool temp2 = false ;
10688 PyObject * obj0 = 0 ;
10689 PyObject * obj1 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self",(char *) "facename", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 if (obj1) {
10698 {
10699 arg2 = wxString_in_helper(obj1);
10700 if (arg2 == NULL) SWIG_fail;
10701 temp2 = true;
10702 }
10703 }
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 {
10712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10713 }
10714 {
10715 if (temp2)
10716 delete arg2;
10717 }
10718 return resultobj;
10719 fail:
10720 {
10721 if (temp2)
10722 delete arg2;
10723 }
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10731 PyObject *result;
10732 PyObject * obj0 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "self", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10743
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 resultobj = result;
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj;
10756 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10757 PyObject *result;
10758 PyObject * obj0 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "self", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10765 if (SWIG_arg_fail(1)) SWIG_fail;
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = result;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10781 PyObject *obj;
10782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10783 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10784 Py_INCREF(obj);
10785 return Py_BuildValue((char *)"");
10786 }
10787 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj;
10789 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10790 int arg2 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self",(char *) "Language", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 {
10801 arg2 = (int)(SWIG_As_int(obj1));
10802 if (SWIG_arg_fail(2)) SWIG_fail;
10803 }
10804 if (arg1) (arg1)->Language = arg2;
10805
10806 Py_INCREF(Py_None); resultobj = Py_None;
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10816 int result;
10817 PyObject * obj0 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "self", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 result = (int) ((arg1)->Language);
10826
10827 {
10828 resultobj = SWIG_From_int((int)(result));
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10839 wxString *arg2 = (wxString *) 0 ;
10840 bool temp2 = false ;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "CanonicalName", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = wxString_in_helper(obj1);
10852 if (arg2 == NULL) SWIG_fail;
10853 temp2 = true;
10854 }
10855 if (arg1) (arg1)->CanonicalName = *arg2;
10856
10857 Py_INCREF(Py_None); resultobj = Py_None;
10858 {
10859 if (temp2)
10860 delete arg2;
10861 }
10862 return resultobj;
10863 fail:
10864 {
10865 if (temp2)
10866 delete arg2;
10867 }
10868 return NULL;
10869 }
10870
10871
10872 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj;
10874 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10875 wxString *result;
10876 PyObject * obj0 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "self", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10883 if (SWIG_arg_fail(1)) SWIG_fail;
10884 result = (wxString *)& ((arg1)->CanonicalName);
10885
10886 {
10887 #if wxUSE_UNICODE
10888 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10889 #else
10890 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10891 #endif
10892 }
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj;
10901 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10902 wxString *arg2 = (wxString *) 0 ;
10903 bool temp2 = false ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 char *kwnames[] = {
10907 (char *) "self",(char *) "Description", NULL
10908 };
10909
10910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10912 if (SWIG_arg_fail(1)) SWIG_fail;
10913 {
10914 arg2 = wxString_in_helper(obj1);
10915 if (arg2 == NULL) SWIG_fail;
10916 temp2 = true;
10917 }
10918 if (arg1) (arg1)->Description = *arg2;
10919
10920 Py_INCREF(Py_None); resultobj = Py_None;
10921 {
10922 if (temp2)
10923 delete arg2;
10924 }
10925 return resultobj;
10926 fail:
10927 {
10928 if (temp2)
10929 delete arg2;
10930 }
10931 return NULL;
10932 }
10933
10934
10935 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10936 PyObject *resultobj;
10937 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10938 wxString *result;
10939 PyObject * obj0 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 result = (wxString *)& ((arg1)->Description);
10948
10949 {
10950 #if wxUSE_UNICODE
10951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10952 #else
10953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10954 #endif
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10963 PyObject *obj;
10964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10965 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10966 Py_INCREF(obj);
10967 return Py_BuildValue((char *)"");
10968 }
10969 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 int arg1 = (int) -1 ;
10972 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10973 wxLocale *result;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "language",(char *) "flags", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10981 if (obj0) {
10982 {
10983 arg1 = (int)(SWIG_As_int(obj0));
10984 if (SWIG_arg_fail(1)) SWIG_fail;
10985 }
10986 }
10987 if (obj1) {
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 }
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (wxLocale *)new_wxLocale(arg1,arg2);
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxLocale *arg1 = (wxLocale *) 0 ;
11010 PyObject * obj0 = 0 ;
11011 char *kwnames[] = {
11012 (char *) "self", NULL
11013 };
11014
11015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11017 if (SWIG_arg_fail(1)) SWIG_fail;
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 delete arg1;
11021
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 Py_INCREF(Py_None); resultobj = Py_None;
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxLocale *arg1 = (wxLocale *) 0 ;
11035 wxString *arg2 = 0 ;
11036 wxString const &arg3_defvalue = wxPyEmptyString ;
11037 wxString *arg3 = (wxString *) &arg3_defvalue ;
11038 wxString const &arg4_defvalue = wxPyEmptyString ;
11039 wxString *arg4 = (wxString *) &arg4_defvalue ;
11040 bool arg5 = (bool) true ;
11041 bool arg6 = (bool) false ;
11042 bool result;
11043 bool temp2 = false ;
11044 bool temp3 = false ;
11045 bool temp4 = false ;
11046 PyObject * obj0 = 0 ;
11047 PyObject * obj1 = 0 ;
11048 PyObject * obj2 = 0 ;
11049 PyObject * obj3 = 0 ;
11050 PyObject * obj4 = 0 ;
11051 PyObject * obj5 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 arg2 = wxString_in_helper(obj1);
11061 if (arg2 == NULL) SWIG_fail;
11062 temp2 = true;
11063 }
11064 if (obj2) {
11065 {
11066 arg3 = wxString_in_helper(obj2);
11067 if (arg3 == NULL) SWIG_fail;
11068 temp3 = true;
11069 }
11070 }
11071 if (obj3) {
11072 {
11073 arg4 = wxString_in_helper(obj3);
11074 if (arg4 == NULL) SWIG_fail;
11075 temp4 = true;
11076 }
11077 }
11078 if (obj4) {
11079 {
11080 arg5 = (bool)(SWIG_As_bool(obj4));
11081 if (SWIG_arg_fail(5)) SWIG_fail;
11082 }
11083 }
11084 if (obj5) {
11085 {
11086 arg6 = (bool)(SWIG_As_bool(obj5));
11087 if (SWIG_arg_fail(6)) SWIG_fail;
11088 }
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11099 }
11100 {
11101 if (temp2)
11102 delete arg2;
11103 }
11104 {
11105 if (temp3)
11106 delete arg3;
11107 }
11108 {
11109 if (temp4)
11110 delete arg4;
11111 }
11112 return resultobj;
11113 fail:
11114 {
11115 if (temp2)
11116 delete arg2;
11117 }
11118 {
11119 if (temp3)
11120 delete arg3;
11121 }
11122 {
11123 if (temp4)
11124 delete arg4;
11125 }
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj;
11132 wxLocale *arg1 = (wxLocale *) 0 ;
11133 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11134 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11135 bool result;
11136 PyObject * obj0 = 0 ;
11137 PyObject * obj1 = 0 ;
11138 PyObject * obj2 = 0 ;
11139 char *kwnames[] = {
11140 (char *) "self",(char *) "language",(char *) "flags", NULL
11141 };
11142
11143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11145 if (SWIG_arg_fail(1)) SWIG_fail;
11146 if (obj1) {
11147 {
11148 arg2 = (int)(SWIG_As_int(obj1));
11149 if (SWIG_arg_fail(2)) SWIG_fail;
11150 }
11151 }
11152 if (obj2) {
11153 {
11154 arg3 = (int)(SWIG_As_int(obj2));
11155 if (SWIG_arg_fail(3)) SWIG_fail;
11156 }
11157 }
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 int result;
11177 char *kwnames[] = {
11178 NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (int)wxLocale::GetSystemLanguage();
11185
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = SWIG_From_int((int)(result));
11191 }
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj;
11200 wxFontEncoding result;
11201 char *kwnames[] = {
11202 NULL
11203 };
11204
11205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11209
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_From_int((result));
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxString result;
11223 char *kwnames[] = {
11224 NULL
11225 };
11226
11227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = wxLocale::GetSystemEncodingName();
11231
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 wxLocale *arg1 = (wxLocale *) 0 ;
11251 bool result;
11252 PyObject * obj0 = 0 ;
11253 char *kwnames[] = {
11254 (char *) "self", NULL
11255 };
11256
11257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11259 if (SWIG_arg_fail(1)) SWIG_fail;
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 result = (bool)((wxLocale const *)arg1)->IsOk();
11263
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 {
11268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11269 }
11270 return resultobj;
11271 fail:
11272 return NULL;
11273 }
11274
11275
11276 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11277 PyObject *resultobj;
11278 wxLocale *arg1 = (wxLocale *) 0 ;
11279 wxString result;
11280 PyObject * obj0 = 0 ;
11281 char *kwnames[] = {
11282 (char *) "self", NULL
11283 };
11284
11285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11287 if (SWIG_arg_fail(1)) SWIG_fail;
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = ((wxLocale const *)arg1)->GetLocale();
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 {
11296 #if wxUSE_UNICODE
11297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11298 #else
11299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11300 #endif
11301 }
11302 return resultobj;
11303 fail:
11304 return NULL;
11305 }
11306
11307
11308 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj;
11310 wxLocale *arg1 = (wxLocale *) 0 ;
11311 int result;
11312 PyObject * obj0 = 0 ;
11313 char *kwnames[] = {
11314 (char *) "self", NULL
11315 };
11316
11317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11319 if (SWIG_arg_fail(1)) SWIG_fail;
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (int)((wxLocale const *)arg1)->GetLanguage();
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 {
11328 resultobj = SWIG_From_int((int)(result));
11329 }
11330 return resultobj;
11331 fail:
11332 return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj;
11338 wxLocale *arg1 = (wxLocale *) 0 ;
11339 wxString result;
11340 PyObject * obj0 = 0 ;
11341 char *kwnames[] = {
11342 (char *) "self", NULL
11343 };
11344
11345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 result = ((wxLocale const *)arg1)->GetSysName();
11351
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 {
11356 #if wxUSE_UNICODE
11357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11358 #else
11359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11360 #endif
11361 }
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 wxLocale *arg1 = (wxLocale *) 0 ;
11371 wxString result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = ((wxLocale const *)arg1)->GetCanonicalName();
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 #if wxUSE_UNICODE
11389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11390 #else
11391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11392 #endif
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxString *arg1 = 0 ;
11403 bool temp1 = false ;
11404 PyObject * obj0 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "prefix", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11410 {
11411 arg1 = wxString_in_helper(obj0);
11412 if (arg1 == NULL) SWIG_fail;
11413 temp1 = true;
11414 }
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11418
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 Py_INCREF(Py_None); resultobj = Py_None;
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return resultobj;
11428 fail:
11429 {
11430 if (temp1)
11431 delete arg1;
11432 }
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj;
11439 wxLocale *arg1 = (wxLocale *) 0 ;
11440 wxString *arg2 = 0 ;
11441 bool result;
11442 bool temp2 = false ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "szDomain", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = wxString_in_helper(obj1);
11454 if (arg2 == NULL) SWIG_fail;
11455 temp2 = true;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11466 }
11467 {
11468 if (temp2)
11469 delete arg2;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp2)
11475 delete arg2;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxLocale *arg1 = (wxLocale *) 0 ;
11484 wxString *arg2 = 0 ;
11485 bool result;
11486 bool temp2 = false ;
11487 PyObject * obj0 = 0 ;
11488 PyObject * obj1 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "szDomain", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = wxString_in_helper(obj1);
11498 if (arg2 == NULL) SWIG_fail;
11499 temp2 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 {
11509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11510 }
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return resultobj;
11516 fail:
11517 {
11518 if (temp2)
11519 delete arg2;
11520 }
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 int arg1 ;
11528 wxLanguageInfo *result;
11529 PyObject * obj0 = 0 ;
11530 char *kwnames[] = {
11531 (char *) "lang", NULL
11532 };
11533
11534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11535 {
11536 arg1 = (int)(SWIG_As_int(obj0));
11537 if (SWIG_arg_fail(1)) SWIG_fail;
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj;
11555 int arg1 ;
11556 wxString result;
11557 PyObject * obj0 = 0 ;
11558 char *kwnames[] = {
11559 (char *) "lang", NULL
11560 };
11561
11562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11563 {
11564 arg1 = (int)(SWIG_As_int(obj0));
11565 if (SWIG_arg_fail(1)) SWIG_fail;
11566 }
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = wxLocale::GetLanguageName(arg1);
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 #if wxUSE_UNICODE
11576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11577 #else
11578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11579 #endif
11580 }
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj;
11589 wxString *arg1 = 0 ;
11590 wxLanguageInfo *result;
11591 bool temp1 = false ;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "locale", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11598 {
11599 arg1 = wxString_in_helper(obj0);
11600 if (arg1 == NULL) SWIG_fail;
11601 temp1 = true;
11602 }
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11606
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11611 {
11612 if (temp1)
11613 delete arg1;
11614 }
11615 return resultobj;
11616 fail:
11617 {
11618 if (temp1)
11619 delete arg1;
11620 }
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxLanguageInfo *arg1 = 0 ;
11628 PyObject * obj0 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "info", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11634 {
11635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11636 if (SWIG_arg_fail(1)) SWIG_fail;
11637 if (arg1 == NULL) {
11638 SWIG_null_ref("wxLanguageInfo");
11639 }
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 }
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 Py_INCREF(Py_None); resultobj = Py_None;
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11657 PyObject *resultobj;
11658 wxLocale *arg1 = (wxLocale *) 0 ;
11659 wxString *arg2 = 0 ;
11660 wxString const &arg3_defvalue = wxPyEmptyString ;
11661 wxString *arg3 = (wxString *) &arg3_defvalue ;
11662 wxString result;
11663 bool temp2 = false ;
11664 bool temp3 = false ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 {
11676 arg2 = wxString_in_helper(obj1);
11677 if (arg2 == NULL) SWIG_fail;
11678 temp2 = true;
11679 }
11680 if (obj2) {
11681 {
11682 arg3 = wxString_in_helper(obj2);
11683 if (arg3 == NULL) SWIG_fail;
11684 temp3 = true;
11685 }
11686 }
11687 {
11688 PyThreadState* __tstate = wxPyBeginAllowThreads();
11689 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11690
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 #if wxUSE_UNICODE
11696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11697 #else
11698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11699 #endif
11700 }
11701 {
11702 if (temp2)
11703 delete arg2;
11704 }
11705 {
11706 if (temp3)
11707 delete arg3;
11708 }
11709 return resultobj;
11710 fail:
11711 {
11712 if (temp2)
11713 delete arg2;
11714 }
11715 {
11716 if (temp3)
11717 delete arg3;
11718 }
11719 return NULL;
11720 }
11721
11722
11723 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11724 PyObject *resultobj;
11725 wxLocale *arg1 = (wxLocale *) 0 ;
11726 wxString *result;
11727 PyObject * obj0 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 {
11738 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11739 result = (wxString *) &_result_ref;
11740 }
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11759 PyObject *obj;
11760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11761 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11762 Py_INCREF(obj);
11763 return Py_BuildValue((char *)"");
11764 }
11765 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj;
11767 wxLocale *result;
11768 char *kwnames[] = {
11769 NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (wxLocale *)wxGetLocale();
11776
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11788 PyObject *resultobj;
11789 wxString *arg1 = 0 ;
11790 wxString result;
11791 bool temp1 = false ;
11792 PyObject * obj0 = 0 ;
11793
11794 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11795 {
11796 arg1 = wxString_in_helper(obj0);
11797 if (arg1 == NULL) SWIG_fail;
11798 temp1 = true;
11799 }
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 result = wxGetTranslation((wxString const &)*arg1);
11803
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 #if wxUSE_UNICODE
11809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11810 #else
11811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11812 #endif
11813 }
11814 {
11815 if (temp1)
11816 delete arg1;
11817 }
11818 return resultobj;
11819 fail:
11820 {
11821 if (temp1)
11822 delete arg1;
11823 }
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11829 PyObject *resultobj;
11830 wxString *arg1 = 0 ;
11831 wxString *arg2 = 0 ;
11832 size_t arg3 ;
11833 wxString result;
11834 bool temp1 = false ;
11835 bool temp2 = false ;
11836 PyObject * obj0 = 0 ;
11837 PyObject * obj1 = 0 ;
11838 PyObject * obj2 = 0 ;
11839
11840 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11841 {
11842 arg1 = wxString_in_helper(obj0);
11843 if (arg1 == NULL) SWIG_fail;
11844 temp1 = true;
11845 }
11846 {
11847 arg2 = wxString_in_helper(obj1);
11848 if (arg2 == NULL) SWIG_fail;
11849 temp2 = true;
11850 }
11851 {
11852 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11853 if (SWIG_arg_fail(3)) SWIG_fail;
11854 }
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 #if wxUSE_UNICODE
11864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11865 #else
11866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11867 #endif
11868 }
11869 {
11870 if (temp1)
11871 delete arg1;
11872 }
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 {
11884 if (temp2)
11885 delete arg2;
11886 }
11887 return NULL;
11888 }
11889
11890
11891 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11892 int argc;
11893 PyObject *argv[4];
11894 int ii;
11895
11896 argc = PyObject_Length(args);
11897 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11898 argv[ii] = PyTuple_GetItem(args,ii);
11899 }
11900 if (argc == 1) {
11901 int _v;
11902 {
11903 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11904 }
11905 if (_v) {
11906 return _wrap_GetTranslation__SWIG_0(self,args);
11907 }
11908 }
11909 if (argc == 3) {
11910 int _v;
11911 {
11912 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11913 }
11914 if (_v) {
11915 {
11916 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11917 }
11918 if (_v) {
11919 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11920 if (_v) {
11921 return _wrap_GetTranslation__SWIG_1(self,args);
11922 }
11923 }
11924 }
11925 }
11926
11927 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxEncodingConverter *result;
11935 char *kwnames[] = {
11936 NULL
11937 };
11938
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (wxEncodingConverter *)new wxEncodingConverter();
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11957 PyObject * obj0 = 0 ;
11958 char *kwnames[] = {
11959 (char *) "self", NULL
11960 };
11961
11962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11964 if (SWIG_arg_fail(1)) SWIG_fail;
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 delete arg1;
11968
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 Py_INCREF(Py_None); resultobj = Py_None;
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj;
11981 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11982 wxFontEncoding arg2 ;
11983 wxFontEncoding arg3 ;
11984 int arg4 = (int) wxCONVERT_STRICT ;
11985 bool result;
11986 PyObject * obj0 = 0 ;
11987 PyObject * obj1 = 0 ;
11988 PyObject * obj2 = 0 ;
11989 PyObject * obj3 = 0 ;
11990 char *kwnames[] = {
11991 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
11992 };
11993
11994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11996 if (SWIG_arg_fail(1)) SWIG_fail;
11997 {
11998 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11999 if (SWIG_arg_fail(2)) SWIG_fail;
12000 }
12001 {
12002 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12003 if (SWIG_arg_fail(3)) SWIG_fail;
12004 }
12005 if (obj3) {
12006 {
12007 arg4 = (int)(SWIG_As_int(obj3));
12008 if (SWIG_arg_fail(4)) SWIG_fail;
12009 }
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12030 wxString *arg2 = 0 ;
12031 wxString result;
12032 bool temp2 = false ;
12033 PyObject * obj0 = 0 ;
12034 PyObject * obj1 = 0 ;
12035 char *kwnames[] = {
12036 (char *) "self",(char *) "input", NULL
12037 };
12038
12039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12041 if (SWIG_arg_fail(1)) SWIG_fail;
12042 {
12043 arg2 = wxString_in_helper(obj1);
12044 if (arg2 == NULL) SWIG_fail;
12045 temp2 = true;
12046 }
12047 {
12048 PyThreadState* __tstate = wxPyBeginAllowThreads();
12049 result = (arg1)->Convert((wxString const &)*arg2);
12050
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 {
12055 #if wxUSE_UNICODE
12056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12057 #else
12058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12059 #endif
12060 }
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj;
12077 wxFontEncoding arg1 ;
12078 int arg2 = (int) wxPLATFORM_CURRENT ;
12079 wxFontEncodingArray result;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "enc",(char *) "platform", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12087 {
12088 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 }
12091 if (obj1) {
12092 {
12093 arg2 = (int)(SWIG_As_int(obj1));
12094 if (SWIG_arg_fail(2)) SWIG_fail;
12095 }
12096 }
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 {
12105 resultobj = PyList_New(0);
12106 for (size_t i=0; i < (&result)->GetCount(); i++) {
12107 PyObject* number = PyInt_FromLong((&result)->Item(i));
12108 PyList_Append(resultobj, number);
12109 Py_DECREF(number);
12110 }
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxFontEncoding arg1 ;
12121 wxFontEncodingArray result;
12122 PyObject * obj0 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "enc", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12128 {
12129 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 }
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12135
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 {
12140 resultobj = PyList_New(0);
12141 for (size_t i=0; i < (&result)->GetCount(); i++) {
12142 PyObject* number = PyInt_FromLong((&result)->Item(i));
12143 PyList_Append(resultobj, number);
12144 Py_DECREF(number);
12145 }
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxFontEncoding arg1 ;
12156 wxFontEncoding arg2 ;
12157 bool result;
12158 PyObject * obj0 = 0 ;
12159 PyObject * obj1 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "encIn",(char *) "encOut", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12165 {
12166 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 }
12169 {
12170 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12171 if (SWIG_arg_fail(2)) SWIG_fail;
12172 }
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12190 PyObject *obj;
12191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12192 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12193 Py_INCREF(obj);
12194 return Py_BuildValue((char *)"");
12195 }
12196 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12197 PyObject *resultobj;
12198 wxDC *arg1 = (wxDC *) 0 ;
12199 PyObject * obj0 = 0 ;
12200 char *kwnames[] = {
12201 (char *) "self", NULL
12202 };
12203
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12206 if (SWIG_arg_fail(1)) SWIG_fail;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 delete arg1;
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 Py_INCREF(Py_None); resultobj = Py_None;
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxDC *arg1 = (wxDC *) 0 ;
12224 PyObject * obj0 = 0 ;
12225 char *kwnames[] = {
12226 (char *) "self", NULL
12227 };
12228
12229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12231 if (SWIG_arg_fail(1)) SWIG_fail;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 (arg1)->BeginDrawing();
12235
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 Py_INCREF(Py_None); resultobj = Py_None;
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxDC *arg1 = (wxDC *) 0 ;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 (arg1)->EndDrawing();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxDC *arg1 = (wxDC *) 0 ;
12274 int arg2 ;
12275 int arg3 ;
12276 wxColour *arg4 = 0 ;
12277 int arg5 = (int) wxFLOOD_SURFACE ;
12278 bool result;
12279 wxColour temp4 ;
12280 PyObject * obj0 = 0 ;
12281 PyObject * obj1 = 0 ;
12282 PyObject * obj2 = 0 ;
12283 PyObject * obj3 = 0 ;
12284 PyObject * obj4 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 {
12293 arg2 = (int)(SWIG_As_int(obj1));
12294 if (SWIG_arg_fail(2)) SWIG_fail;
12295 }
12296 {
12297 arg3 = (int)(SWIG_As_int(obj2));
12298 if (SWIG_arg_fail(3)) SWIG_fail;
12299 }
12300 {
12301 arg4 = &temp4;
12302 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12303 }
12304 if (obj4) {
12305 {
12306 arg5 = (int)(SWIG_As_int(obj4));
12307 if (SWIG_arg_fail(5)) SWIG_fail;
12308 }
12309 }
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12313
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 {
12318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj;
12328 wxDC *arg1 = (wxDC *) 0 ;
12329 wxPoint *arg2 = 0 ;
12330 wxColour *arg3 = 0 ;
12331 int arg4 = (int) wxFLOOD_SURFACE ;
12332 bool result;
12333 wxPoint temp2 ;
12334 wxColour temp3 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 PyObject * obj2 = 0 ;
12338 PyObject * obj3 = 0 ;
12339 char *kwnames[] = {
12340 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12341 };
12342
12343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12345 if (SWIG_arg_fail(1)) SWIG_fail;
12346 {
12347 arg2 = &temp2;
12348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12349 }
12350 {
12351 arg3 = &temp3;
12352 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12353 }
12354 if (obj3) {
12355 {
12356 arg4 = (int)(SWIG_As_int(obj3));
12357 if (SWIG_arg_fail(4)) SWIG_fail;
12358 }
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxDC *arg1 = (wxDC *) 0 ;
12379 int arg2 ;
12380 int arg3 ;
12381 wxColour result;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 PyObject * obj2 = 0 ;
12385 char *kwnames[] = {
12386 (char *) "self",(char *) "x",(char *) "y", NULL
12387 };
12388
12389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12391 if (SWIG_arg_fail(1)) SWIG_fail;
12392 {
12393 arg2 = (int)(SWIG_As_int(obj1));
12394 if (SWIG_arg_fail(2)) SWIG_fail;
12395 }
12396 {
12397 arg3 = (int)(SWIG_As_int(obj2));
12398 if (SWIG_arg_fail(3)) SWIG_fail;
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = wxDC_GetPixel(arg1,arg2,arg3);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 wxColour * resultptr;
12409 resultptr = new wxColour((wxColour &)(result));
12410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12411 }
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxDC *arg1 = (wxDC *) 0 ;
12421 wxPoint *arg2 = 0 ;
12422 wxColour result;
12423 wxPoint temp2 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "pt", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = &temp2;
12435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12440
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 wxColour * resultptr;
12446 resultptr = new wxColour((wxColour &)(result));
12447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxDC *arg1 = (wxDC *) 0 ;
12458 int arg2 ;
12459 int arg3 ;
12460 int arg4 ;
12461 int arg5 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 PyObject * obj3 = 0 ;
12466 PyObject * obj4 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 arg2 = (int)(SWIG_As_int(obj1));
12476 if (SWIG_arg_fail(2)) SWIG_fail;
12477 }
12478 {
12479 arg3 = (int)(SWIG_As_int(obj2));
12480 if (SWIG_arg_fail(3)) SWIG_fail;
12481 }
12482 {
12483 arg4 = (int)(SWIG_As_int(obj3));
12484 if (SWIG_arg_fail(4)) SWIG_fail;
12485 }
12486 {
12487 arg5 = (int)(SWIG_As_int(obj4));
12488 if (SWIG_arg_fail(5)) SWIG_fail;
12489 }
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 Py_INCREF(Py_None); resultobj = Py_None;
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxDC *arg1 = (wxDC *) 0 ;
12507 wxPoint *arg2 = 0 ;
12508 wxPoint *arg3 = 0 ;
12509 wxPoint temp2 ;
12510 wxPoint temp3 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 PyObject * obj2 = 0 ;
12514 char *kwnames[] = {
12515 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12516 };
12517
12518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(1)) SWIG_fail;
12521 {
12522 arg2 = &temp2;
12523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12524 }
12525 {
12526 arg3 = &temp3;
12527 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 Py_INCREF(Py_None); resultobj = Py_None;
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxDC *arg1 = (wxDC *) 0 ;
12546 int arg2 ;
12547 int arg3 ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 PyObject * obj2 = 0 ;
12551 char *kwnames[] = {
12552 (char *) "self",(char *) "x",(char *) "y", NULL
12553 };
12554
12555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(1)) SWIG_fail;
12558 {
12559 arg2 = (int)(SWIG_As_int(obj1));
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 {
12563 arg3 = (int)(SWIG_As_int(obj2));
12564 if (SWIG_arg_fail(3)) SWIG_fail;
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 (arg1)->CrossHair(arg2,arg3);
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 Py_INCREF(Py_None); resultobj = Py_None;
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj;
12582 wxDC *arg1 = (wxDC *) 0 ;
12583 wxPoint *arg2 = 0 ;
12584 wxPoint temp2 ;
12585 PyObject * obj0 = 0 ;
12586 PyObject * obj1 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self",(char *) "pt", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 arg2 = &temp2;
12596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 (arg1)->CrossHair((wxPoint const &)*arg2);
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 Py_INCREF(Py_None); resultobj = Py_None;
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxDC *arg1 = (wxDC *) 0 ;
12615 int arg2 ;
12616 int arg3 ;
12617 int arg4 ;
12618 int arg5 ;
12619 int arg6 ;
12620 int arg7 ;
12621 PyObject * obj0 = 0 ;
12622 PyObject * obj1 = 0 ;
12623 PyObject * obj2 = 0 ;
12624 PyObject * obj3 = 0 ;
12625 PyObject * obj4 = 0 ;
12626 PyObject * obj5 = 0 ;
12627 PyObject * obj6 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 arg2 = (int)(SWIG_As_int(obj1));
12637 if (SWIG_arg_fail(2)) SWIG_fail;
12638 }
12639 {
12640 arg3 = (int)(SWIG_As_int(obj2));
12641 if (SWIG_arg_fail(3)) SWIG_fail;
12642 }
12643 {
12644 arg4 = (int)(SWIG_As_int(obj3));
12645 if (SWIG_arg_fail(4)) SWIG_fail;
12646 }
12647 {
12648 arg5 = (int)(SWIG_As_int(obj4));
12649 if (SWIG_arg_fail(5)) SWIG_fail;
12650 }
12651 {
12652 arg6 = (int)(SWIG_As_int(obj5));
12653 if (SWIG_arg_fail(6)) SWIG_fail;
12654 }
12655 {
12656 arg7 = (int)(SWIG_As_int(obj6));
12657 if (SWIG_arg_fail(7)) SWIG_fail;
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
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_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxDC *arg1 = (wxDC *) 0 ;
12676 wxPoint *arg2 = 0 ;
12677 wxPoint *arg3 = 0 ;
12678 wxPoint *arg4 = 0 ;
12679 wxPoint temp2 ;
12680 wxPoint temp3 ;
12681 wxPoint temp4 ;
12682 PyObject * obj0 = 0 ;
12683 PyObject * obj1 = 0 ;
12684 PyObject * obj2 = 0 ;
12685 PyObject * obj3 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 {
12694 arg2 = &temp2;
12695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12696 }
12697 {
12698 arg3 = &temp3;
12699 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12700 }
12701 {
12702 arg4 = &temp4;
12703 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12704 }
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 Py_INCREF(Py_None); resultobj = Py_None;
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12720 PyObject *resultobj;
12721 wxDC *arg1 = (wxDC *) 0 ;
12722 int arg2 ;
12723 int arg3 ;
12724 int arg4 ;
12725 int arg5 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 PyObject * obj3 = 0 ;
12730 PyObject * obj4 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 arg2 = (int)(SWIG_As_int(obj1));
12740 if (SWIG_arg_fail(2)) SWIG_fail;
12741 }
12742 {
12743 arg3 = (int)(SWIG_As_int(obj2));
12744 if (SWIG_arg_fail(3)) SWIG_fail;
12745 }
12746 {
12747 arg4 = (int)(SWIG_As_int(obj3));
12748 if (SWIG_arg_fail(4)) SWIG_fail;
12749 }
12750 {
12751 arg5 = (int)(SWIG_As_int(obj4));
12752 if (SWIG_arg_fail(5)) SWIG_fail;
12753 }
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12757
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 Py_INCREF(Py_None); resultobj = Py_None;
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxDC *arg1 = (wxDC *) 0 ;
12771 wxRect *arg2 = 0 ;
12772 wxRect temp2 ;
12773 PyObject * obj0 = 0 ;
12774 PyObject * obj1 = 0 ;
12775 char *kwnames[] = {
12776 (char *) "self",(char *) "rect", NULL
12777 };
12778
12779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12781 if (SWIG_arg_fail(1)) SWIG_fail;
12782 {
12783 arg2 = &temp2;
12784 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12785 }
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 Py_INCREF(Py_None); resultobj = Py_None;
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj;
12802 wxDC *arg1 = (wxDC *) 0 ;
12803 int arg2 ;
12804 int arg3 ;
12805 int arg4 ;
12806 int arg5 ;
12807 double arg6 ;
12808 double arg7 ;
12809 PyObject * obj0 = 0 ;
12810 PyObject * obj1 = 0 ;
12811 PyObject * obj2 = 0 ;
12812 PyObject * obj3 = 0 ;
12813 PyObject * obj4 = 0 ;
12814 PyObject * obj5 = 0 ;
12815 PyObject * obj6 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 {
12824 arg2 = (int)(SWIG_As_int(obj1));
12825 if (SWIG_arg_fail(2)) SWIG_fail;
12826 }
12827 {
12828 arg3 = (int)(SWIG_As_int(obj2));
12829 if (SWIG_arg_fail(3)) SWIG_fail;
12830 }
12831 {
12832 arg4 = (int)(SWIG_As_int(obj3));
12833 if (SWIG_arg_fail(4)) SWIG_fail;
12834 }
12835 {
12836 arg5 = (int)(SWIG_As_int(obj4));
12837 if (SWIG_arg_fail(5)) SWIG_fail;
12838 }
12839 {
12840 arg6 = (double)(SWIG_As_double(obj5));
12841 if (SWIG_arg_fail(6)) SWIG_fail;
12842 }
12843 {
12844 arg7 = (double)(SWIG_As_double(obj6));
12845 if (SWIG_arg_fail(7)) SWIG_fail;
12846 }
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
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_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxDC *arg1 = (wxDC *) 0 ;
12864 wxPoint *arg2 = 0 ;
12865 wxSize *arg3 = 0 ;
12866 double arg4 ;
12867 double arg5 ;
12868 wxPoint temp2 ;
12869 wxSize temp3 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 PyObject * obj3 = 0 ;
12874 PyObject * obj4 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = &temp2;
12884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12885 }
12886 {
12887 arg3 = &temp3;
12888 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12889 }
12890 {
12891 arg4 = (double)(SWIG_As_double(obj3));
12892 if (SWIG_arg_fail(4)) SWIG_fail;
12893 }
12894 {
12895 arg5 = (double)(SWIG_As_double(obj4));
12896 if (SWIG_arg_fail(5)) SWIG_fail;
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 Py_INCREF(Py_None); resultobj = Py_None;
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj;
12914 wxDC *arg1 = (wxDC *) 0 ;
12915 int arg2 ;
12916 int arg3 ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 PyObject * obj2 = 0 ;
12920 char *kwnames[] = {
12921 (char *) "self",(char *) "x",(char *) "y", NULL
12922 };
12923
12924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12926 if (SWIG_arg_fail(1)) SWIG_fail;
12927 {
12928 arg2 = (int)(SWIG_As_int(obj1));
12929 if (SWIG_arg_fail(2)) SWIG_fail;
12930 }
12931 {
12932 arg3 = (int)(SWIG_As_int(obj2));
12933 if (SWIG_arg_fail(3)) SWIG_fail;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 (arg1)->DrawPoint(arg2,arg3);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 Py_INCREF(Py_None); resultobj = Py_None;
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxDC *arg1 = (wxDC *) 0 ;
12952 wxPoint *arg2 = 0 ;
12953 wxPoint temp2 ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self",(char *) "pt", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 arg2 = &temp2;
12965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 (arg1)->DrawPoint((wxPoint const &)*arg2);
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 Py_INCREF(Py_None); resultobj = Py_None;
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxDC *arg1 = (wxDC *) 0 ;
12984 int arg2 ;
12985 int arg3 ;
12986 int arg4 ;
12987 int arg5 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 PyObject * obj3 = 0 ;
12992 PyObject * obj4 = 0 ;
12993 char *kwnames[] = {
12994 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12995 };
12996
12997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12999 if (SWIG_arg_fail(1)) SWIG_fail;
13000 {
13001 arg2 = (int)(SWIG_As_int(obj1));
13002 if (SWIG_arg_fail(2)) SWIG_fail;
13003 }
13004 {
13005 arg3 = (int)(SWIG_As_int(obj2));
13006 if (SWIG_arg_fail(3)) SWIG_fail;
13007 }
13008 {
13009 arg4 = (int)(SWIG_As_int(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 {
13013 arg5 = (int)(SWIG_As_int(obj4));
13014 if (SWIG_arg_fail(5)) SWIG_fail;
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 Py_INCREF(Py_None); resultobj = Py_None;
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxDC *arg1 = (wxDC *) 0 ;
13033 wxRect *arg2 = 0 ;
13034 wxRect temp2 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 char *kwnames[] = {
13038 (char *) "self",(char *) "rect", NULL
13039 };
13040
13041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(1)) SWIG_fail;
13044 {
13045 arg2 = &temp2;
13046 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 (arg1)->DrawRectangle((wxRect const &)*arg2);
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 Py_INCREF(Py_None); resultobj = Py_None;
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxDC *arg1 = (wxDC *) 0 ;
13065 wxPoint *arg2 = 0 ;
13066 wxSize *arg3 = 0 ;
13067 wxPoint temp2 ;
13068 wxSize temp3 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "pt",(char *) "sz", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 {
13080 arg2 = &temp2;
13081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13082 }
13083 {
13084 arg3 = &temp3;
13085 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 Py_INCREF(Py_None); resultobj = Py_None;
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxDC *arg1 = (wxDC *) 0 ;
13104 int arg2 ;
13105 int arg3 ;
13106 int arg4 ;
13107 int arg5 ;
13108 double arg6 ;
13109 PyObject * obj0 = 0 ;
13110 PyObject * obj1 = 0 ;
13111 PyObject * obj2 = 0 ;
13112 PyObject * obj3 = 0 ;
13113 PyObject * obj4 = 0 ;
13114 PyObject * obj5 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = (int)(SWIG_As_int(obj1));
13124 if (SWIG_arg_fail(2)) SWIG_fail;
13125 }
13126 {
13127 arg3 = (int)(SWIG_As_int(obj2));
13128 if (SWIG_arg_fail(3)) SWIG_fail;
13129 }
13130 {
13131 arg4 = (int)(SWIG_As_int(obj3));
13132 if (SWIG_arg_fail(4)) SWIG_fail;
13133 }
13134 {
13135 arg5 = (int)(SWIG_As_int(obj4));
13136 if (SWIG_arg_fail(5)) SWIG_fail;
13137 }
13138 {
13139 arg6 = (double)(SWIG_As_double(obj5));
13140 if (SWIG_arg_fail(6)) SWIG_fail;
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 Py_INCREF(Py_None); resultobj = Py_None;
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj;
13158 wxDC *arg1 = (wxDC *) 0 ;
13159 wxRect *arg2 = 0 ;
13160 double arg3 ;
13161 wxRect temp2 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "r",(char *) "radius", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",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 ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13175 }
13176 {
13177 arg3 = (double)(SWIG_As_double(obj2));
13178 if (SWIG_arg_fail(3)) SWIG_fail;
13179 }
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,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_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj;
13196 wxDC *arg1 = (wxDC *) 0 ;
13197 wxPoint *arg2 = 0 ;
13198 wxSize *arg3 = 0 ;
13199 double arg4 ;
13200 wxPoint temp2 ;
13201 wxSize temp3 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 PyObject * obj3 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 arg2 = &temp2;
13215 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13216 }
13217 {
13218 arg3 = &temp3;
13219 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13220 }
13221 {
13222 arg4 = (double)(SWIG_As_double(obj3));
13223 if (SWIG_arg_fail(4)) SWIG_fail;
13224 }
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 Py_INCREF(Py_None); resultobj = Py_None;
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj;
13241 wxDC *arg1 = (wxDC *) 0 ;
13242 int arg2 ;
13243 int arg3 ;
13244 int arg4 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 PyObject * obj3 = 0 ;
13249 char *kwnames[] = {
13250 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13251 };
13252
13253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13255 if (SWIG_arg_fail(1)) SWIG_fail;
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 {
13261 arg3 = (int)(SWIG_As_int(obj2));
13262 if (SWIG_arg_fail(3)) SWIG_fail;
13263 }
13264 {
13265 arg4 = (int)(SWIG_As_int(obj3));
13266 if (SWIG_arg_fail(4)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 (arg1)->DrawCircle(arg2,arg3,arg4);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 Py_INCREF(Py_None); resultobj = Py_None;
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxDC *arg1 = (wxDC *) 0 ;
13285 wxPoint *arg2 = 0 ;
13286 int arg3 ;
13287 wxPoint temp2 ;
13288 PyObject * obj0 = 0 ;
13289 PyObject * obj1 = 0 ;
13290 PyObject * obj2 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "pt",(char *) "radius", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = &temp2;
13300 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (int)(SWIG_As_int(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 Py_INCREF(Py_None); resultobj = Py_None;
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj;
13322 wxDC *arg1 = (wxDC *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 int arg4 ;
13326 int arg5 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 PyObject * obj3 = 0 ;
13331 PyObject * obj4 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 {
13340 arg2 = (int)(SWIG_As_int(obj1));
13341 if (SWIG_arg_fail(2)) SWIG_fail;
13342 }
13343 {
13344 arg3 = (int)(SWIG_As_int(obj2));
13345 if (SWIG_arg_fail(3)) SWIG_fail;
13346 }
13347 {
13348 arg4 = (int)(SWIG_As_int(obj3));
13349 if (SWIG_arg_fail(4)) SWIG_fail;
13350 }
13351 {
13352 arg5 = (int)(SWIG_As_int(obj4));
13353 if (SWIG_arg_fail(5)) SWIG_fail;
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 Py_INCREF(Py_None); resultobj = Py_None;
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 wxDC *arg1 = (wxDC *) 0 ;
13372 wxRect *arg2 = 0 ;
13373 wxRect temp2 ;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "rect", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 arg2 = &temp2;
13385 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13386 }
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 (arg1)->DrawEllipse((wxRect const &)*arg2);
13390
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 Py_INCREF(Py_None); resultobj = Py_None;
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj;
13403 wxDC *arg1 = (wxDC *) 0 ;
13404 wxPoint *arg2 = 0 ;
13405 wxSize *arg3 = 0 ;
13406 wxPoint temp2 ;
13407 wxSize temp3 ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 PyObject * obj2 = 0 ;
13411 char *kwnames[] = {
13412 (char *) "self",(char *) "pt",(char *) "sz", NULL
13413 };
13414
13415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13417 if (SWIG_arg_fail(1)) SWIG_fail;
13418 {
13419 arg2 = &temp2;
13420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13421 }
13422 {
13423 arg3 = &temp3;
13424 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13429
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 Py_INCREF(Py_None); resultobj = Py_None;
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj;
13442 wxDC *arg1 = (wxDC *) 0 ;
13443 wxIcon *arg2 = 0 ;
13444 int arg3 ;
13445 int arg4 ;
13446 PyObject * obj0 = 0 ;
13447 PyObject * obj1 = 0 ;
13448 PyObject * obj2 = 0 ;
13449 PyObject * obj3 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13456 if (SWIG_arg_fail(1)) SWIG_fail;
13457 {
13458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13459 if (SWIG_arg_fail(2)) SWIG_fail;
13460 if (arg2 == NULL) {
13461 SWIG_null_ref("wxIcon");
13462 }
13463 if (SWIG_arg_fail(2)) SWIG_fail;
13464 }
13465 {
13466 arg3 = (int)(SWIG_As_int(obj2));
13467 if (SWIG_arg_fail(3)) SWIG_fail;
13468 }
13469 {
13470 arg4 = (int)(SWIG_As_int(obj3));
13471 if (SWIG_arg_fail(4)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 Py_INCREF(Py_None); resultobj = Py_None;
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxDC *arg1 = (wxDC *) 0 ;
13490 wxIcon *arg2 = 0 ;
13491 wxPoint *arg3 = 0 ;
13492 wxPoint temp3 ;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 PyObject * obj2 = 0 ;
13496 char *kwnames[] = {
13497 (char *) "self",(char *) "icon",(char *) "pt", NULL
13498 };
13499
13500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13502 if (SWIG_arg_fail(1)) SWIG_fail;
13503 {
13504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13505 if (SWIG_arg_fail(2)) SWIG_fail;
13506 if (arg2 == NULL) {
13507 SWIG_null_ref("wxIcon");
13508 }
13509 if (SWIG_arg_fail(2)) SWIG_fail;
13510 }
13511 {
13512 arg3 = &temp3;
13513 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13518
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 Py_INCREF(Py_None); resultobj = Py_None;
13523 return resultobj;
13524 fail:
13525 return NULL;
13526 }
13527
13528
13529 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj;
13531 wxDC *arg1 = (wxDC *) 0 ;
13532 wxBitmap *arg2 = 0 ;
13533 int arg3 ;
13534 int arg4 ;
13535 bool arg5 = (bool) false ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 PyObject * obj2 = 0 ;
13539 PyObject * obj3 = 0 ;
13540 PyObject * obj4 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 {
13549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(2)) SWIG_fail;
13551 if (arg2 == NULL) {
13552 SWIG_null_ref("wxBitmap");
13553 }
13554 if (SWIG_arg_fail(2)) SWIG_fail;
13555 }
13556 {
13557 arg3 = (int)(SWIG_As_int(obj2));
13558 if (SWIG_arg_fail(3)) SWIG_fail;
13559 }
13560 {
13561 arg4 = (int)(SWIG_As_int(obj3));
13562 if (SWIG_arg_fail(4)) SWIG_fail;
13563 }
13564 if (obj4) {
13565 {
13566 arg5 = (bool)(SWIG_As_bool(obj4));
13567 if (SWIG_arg_fail(5)) SWIG_fail;
13568 }
13569 }
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 Py_INCREF(Py_None); resultobj = Py_None;
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 wxDC *arg1 = (wxDC *) 0 ;
13587 wxBitmap *arg2 = 0 ;
13588 wxPoint *arg3 = 0 ;
13589 bool arg4 = (bool) false ;
13590 wxPoint temp3 ;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 PyObject * obj2 = 0 ;
13594 PyObject * obj3 = 0 ;
13595 char *kwnames[] = {
13596 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13597 };
13598
13599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13601 if (SWIG_arg_fail(1)) SWIG_fail;
13602 {
13603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(2)) SWIG_fail;
13605 if (arg2 == NULL) {
13606 SWIG_null_ref("wxBitmap");
13607 }
13608 if (SWIG_arg_fail(2)) SWIG_fail;
13609 }
13610 {
13611 arg3 = &temp3;
13612 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13613 }
13614 if (obj3) {
13615 {
13616 arg4 = (bool)(SWIG_As_bool(obj3));
13617 if (SWIG_arg_fail(4)) SWIG_fail;
13618 }
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxDC *arg1 = (wxDC *) 0 ;
13637 wxString *arg2 = 0 ;
13638 int arg3 ;
13639 int arg4 ;
13640 bool temp2 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 PyObject * obj2 = 0 ;
13644 PyObject * obj3 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13651 if (SWIG_arg_fail(1)) SWIG_fail;
13652 {
13653 arg2 = wxString_in_helper(obj1);
13654 if (arg2 == NULL) SWIG_fail;
13655 temp2 = true;
13656 }
13657 {
13658 arg3 = (int)(SWIG_As_int(obj2));
13659 if (SWIG_arg_fail(3)) SWIG_fail;
13660 }
13661 {
13662 arg4 = (int)(SWIG_As_int(obj3));
13663 if (SWIG_arg_fail(4)) SWIG_fail;
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 Py_INCREF(Py_None); resultobj = Py_None;
13673 {
13674 if (temp2)
13675 delete arg2;
13676 }
13677 return resultobj;
13678 fail:
13679 {
13680 if (temp2)
13681 delete arg2;
13682 }
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxDC *arg1 = (wxDC *) 0 ;
13690 wxString *arg2 = 0 ;
13691 wxPoint *arg3 = 0 ;
13692 bool temp2 = false ;
13693 wxPoint temp3 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char *kwnames[] = {
13698 (char *) "self",(char *) "text",(char *) "pt", NULL
13699 };
13700
13701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13703 if (SWIG_arg_fail(1)) SWIG_fail;
13704 {
13705 arg2 = wxString_in_helper(obj1);
13706 if (arg2 == NULL) SWIG_fail;
13707 temp2 = true;
13708 }
13709 {
13710 arg3 = &temp3;
13711 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 Py_INCREF(Py_None); resultobj = Py_None;
13721 {
13722 if (temp2)
13723 delete arg2;
13724 }
13725 return resultobj;
13726 fail:
13727 {
13728 if (temp2)
13729 delete arg2;
13730 }
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxDC *arg1 = (wxDC *) 0 ;
13738 wxString *arg2 = 0 ;
13739 int arg3 ;
13740 int arg4 ;
13741 double arg5 ;
13742 bool temp2 = false ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 PyObject * obj3 = 0 ;
13747 PyObject * obj4 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = wxString_in_helper(obj1);
13757 if (arg2 == NULL) SWIG_fail;
13758 temp2 = true;
13759 }
13760 {
13761 arg3 = (int)(SWIG_As_int(obj2));
13762 if (SWIG_arg_fail(3)) SWIG_fail;
13763 }
13764 {
13765 arg4 = (int)(SWIG_As_int(obj3));
13766 if (SWIG_arg_fail(4)) SWIG_fail;
13767 }
13768 {
13769 arg5 = (double)(SWIG_As_double(obj4));
13770 if (SWIG_arg_fail(5)) SWIG_fail;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13775
13776 wxPyEndAllowThreads(__tstate);
13777 if (PyErr_Occurred()) SWIG_fail;
13778 }
13779 Py_INCREF(Py_None); resultobj = Py_None;
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp2)
13788 delete arg2;
13789 }
13790 return NULL;
13791 }
13792
13793
13794 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13795 PyObject *resultobj;
13796 wxDC *arg1 = (wxDC *) 0 ;
13797 wxString *arg2 = 0 ;
13798 wxPoint *arg3 = 0 ;
13799 double arg4 ;
13800 bool temp2 = false ;
13801 wxPoint temp3 ;
13802 PyObject * obj0 = 0 ;
13803 PyObject * obj1 = 0 ;
13804 PyObject * obj2 = 0 ;
13805 PyObject * obj3 = 0 ;
13806 char *kwnames[] = {
13807 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13808 };
13809
13810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13812 if (SWIG_arg_fail(1)) SWIG_fail;
13813 {
13814 arg2 = wxString_in_helper(obj1);
13815 if (arg2 == NULL) SWIG_fail;
13816 temp2 = true;
13817 }
13818 {
13819 arg3 = &temp3;
13820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13821 }
13822 {
13823 arg4 = (double)(SWIG_As_double(obj3));
13824 if (SWIG_arg_fail(4)) SWIG_fail;
13825 }
13826 {
13827 PyThreadState* __tstate = wxPyBeginAllowThreads();
13828 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13829
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 Py_INCREF(Py_None); resultobj = Py_None;
13834 {
13835 if (temp2)
13836 delete arg2;
13837 }
13838 return resultobj;
13839 fail:
13840 {
13841 if (temp2)
13842 delete arg2;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxDC *arg1 = (wxDC *) 0 ;
13851 int arg2 ;
13852 int arg3 ;
13853 int arg4 ;
13854 int arg5 ;
13855 wxDC *arg6 = (wxDC *) 0 ;
13856 int arg7 ;
13857 int arg8 ;
13858 int arg9 = (int) wxCOPY ;
13859 bool arg10 = (bool) false ;
13860 int arg11 = (int) -1 ;
13861 int arg12 = (int) -1 ;
13862 bool result;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 PyObject * obj3 = 0 ;
13867 PyObject * obj4 = 0 ;
13868 PyObject * obj5 = 0 ;
13869 PyObject * obj6 = 0 ;
13870 PyObject * obj7 = 0 ;
13871 PyObject * obj8 = 0 ;
13872 PyObject * obj9 = 0 ;
13873 PyObject * obj10 = 0 ;
13874 PyObject * obj11 = 0 ;
13875 char *kwnames[] = {
13876 (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
13877 };
13878
13879 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;
13880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13881 if (SWIG_arg_fail(1)) SWIG_fail;
13882 {
13883 arg2 = (int)(SWIG_As_int(obj1));
13884 if (SWIG_arg_fail(2)) SWIG_fail;
13885 }
13886 {
13887 arg3 = (int)(SWIG_As_int(obj2));
13888 if (SWIG_arg_fail(3)) SWIG_fail;
13889 }
13890 {
13891 arg4 = (int)(SWIG_As_int(obj3));
13892 if (SWIG_arg_fail(4)) SWIG_fail;
13893 }
13894 {
13895 arg5 = (int)(SWIG_As_int(obj4));
13896 if (SWIG_arg_fail(5)) SWIG_fail;
13897 }
13898 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(6)) SWIG_fail;
13900 {
13901 arg7 = (int)(SWIG_As_int(obj6));
13902 if (SWIG_arg_fail(7)) SWIG_fail;
13903 }
13904 {
13905 arg8 = (int)(SWIG_As_int(obj7));
13906 if (SWIG_arg_fail(8)) SWIG_fail;
13907 }
13908 if (obj8) {
13909 {
13910 arg9 = (int)(SWIG_As_int(obj8));
13911 if (SWIG_arg_fail(9)) SWIG_fail;
13912 }
13913 }
13914 if (obj9) {
13915 {
13916 arg10 = (bool)(SWIG_As_bool(obj9));
13917 if (SWIG_arg_fail(10)) SWIG_fail;
13918 }
13919 }
13920 if (obj10) {
13921 {
13922 arg11 = (int)(SWIG_As_int(obj10));
13923 if (SWIG_arg_fail(11)) SWIG_fail;
13924 }
13925 }
13926 if (obj11) {
13927 {
13928 arg12 = (int)(SWIG_As_int(obj11));
13929 if (SWIG_arg_fail(12)) SWIG_fail;
13930 }
13931 }
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 {
13940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13941 }
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj;
13950 wxDC *arg1 = (wxDC *) 0 ;
13951 wxPoint *arg2 = 0 ;
13952 wxSize *arg3 = 0 ;
13953 wxDC *arg4 = (wxDC *) 0 ;
13954 wxPoint *arg5 = 0 ;
13955 int arg6 = (int) wxCOPY ;
13956 bool arg7 = (bool) false ;
13957 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13958 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13959 bool result;
13960 wxPoint temp2 ;
13961 wxSize temp3 ;
13962 wxPoint temp5 ;
13963 wxPoint temp8 ;
13964 PyObject * obj0 = 0 ;
13965 PyObject * obj1 = 0 ;
13966 PyObject * obj2 = 0 ;
13967 PyObject * obj3 = 0 ;
13968 PyObject * obj4 = 0 ;
13969 PyObject * obj5 = 0 ;
13970 PyObject * obj6 = 0 ;
13971 PyObject * obj7 = 0 ;
13972 char *kwnames[] = {
13973 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 {
13980 arg2 = &temp2;
13981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13982 }
13983 {
13984 arg3 = &temp3;
13985 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13986 }
13987 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(4)) SWIG_fail;
13989 {
13990 arg5 = &temp5;
13991 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13992 }
13993 if (obj5) {
13994 {
13995 arg6 = (int)(SWIG_As_int(obj5));
13996 if (SWIG_arg_fail(6)) SWIG_fail;
13997 }
13998 }
13999 if (obj6) {
14000 {
14001 arg7 = (bool)(SWIG_As_bool(obj6));
14002 if (SWIG_arg_fail(7)) SWIG_fail;
14003 }
14004 }
14005 if (obj7) {
14006 {
14007 arg8 = &temp8;
14008 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14009 }
14010 }
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14014
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 {
14019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14020 }
14021 return resultobj;
14022 fail:
14023 return NULL;
14024 }
14025
14026
14027 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj;
14029 wxDC *arg1 = (wxDC *) 0 ;
14030 int arg2 ;
14031 int arg3 ;
14032 int arg4 ;
14033 int arg5 ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 PyObject * obj2 = 0 ;
14037 PyObject * obj3 = 0 ;
14038 PyObject * obj4 = 0 ;
14039 char *kwnames[] = {
14040 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14041 };
14042
14043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 {
14047 arg2 = (int)(SWIG_As_int(obj1));
14048 if (SWIG_arg_fail(2)) SWIG_fail;
14049 }
14050 {
14051 arg3 = (int)(SWIG_As_int(obj2));
14052 if (SWIG_arg_fail(3)) SWIG_fail;
14053 }
14054 {
14055 arg4 = (int)(SWIG_As_int(obj3));
14056 if (SWIG_arg_fail(4)) SWIG_fail;
14057 }
14058 {
14059 arg5 = (int)(SWIG_As_int(obj4));
14060 if (SWIG_arg_fail(5)) SWIG_fail;
14061 }
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14065
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 Py_INCREF(Py_None); resultobj = Py_None;
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj;
14078 wxDC *arg1 = (wxDC *) 0 ;
14079 wxPoint *arg2 = 0 ;
14080 wxSize *arg3 = 0 ;
14081 wxPoint temp2 ;
14082 wxSize temp3 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 PyObject * obj2 = 0 ;
14086 char *kwnames[] = {
14087 (char *) "self",(char *) "pt",(char *) "sz", NULL
14088 };
14089
14090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14092 if (SWIG_arg_fail(1)) SWIG_fail;
14093 {
14094 arg2 = &temp2;
14095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14096 }
14097 {
14098 arg3 = &temp3;
14099 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14100 }
14101 {
14102 PyThreadState* __tstate = wxPyBeginAllowThreads();
14103 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14104
14105 wxPyEndAllowThreads(__tstate);
14106 if (PyErr_Occurred()) SWIG_fail;
14107 }
14108 Py_INCREF(Py_None); resultobj = Py_None;
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxDC *arg1 = (wxDC *) 0 ;
14118 wxRegion *arg2 = 0 ;
14119 PyObject * obj0 = 0 ;
14120 PyObject * obj1 = 0 ;
14121 char *kwnames[] = {
14122 (char *) "self",(char *) "region", NULL
14123 };
14124
14125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14127 if (SWIG_arg_fail(1)) SWIG_fail;
14128 {
14129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14130 if (SWIG_arg_fail(2)) SWIG_fail;
14131 if (arg2 == NULL) {
14132 SWIG_null_ref("wxRegion");
14133 }
14134 if (SWIG_arg_fail(2)) SWIG_fail;
14135 }
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 Py_INCREF(Py_None); resultobj = Py_None;
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxDC *arg1 = (wxDC *) 0 ;
14153 wxRect *arg2 = 0 ;
14154 wxRect temp2 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self",(char *) "rect", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 {
14165 arg2 = &temp2;
14166 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14167 }
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 Py_INCREF(Py_None); resultobj = Py_None;
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14183 PyObject *resultobj;
14184 wxDC *arg1 = (wxDC *) 0 ;
14185 int arg2 ;
14186 wxPoint *arg3 = (wxPoint *) 0 ;
14187 int arg4 = (int) 0 ;
14188 int arg5 = (int) 0 ;
14189 PyObject * obj0 = 0 ;
14190 PyObject * obj1 = 0 ;
14191 PyObject * obj2 = 0 ;
14192 PyObject * obj3 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14202 if (arg3 == NULL) SWIG_fail;
14203 }
14204 if (obj2) {
14205 {
14206 arg4 = (int)(SWIG_As_int(obj2));
14207 if (SWIG_arg_fail(4)) SWIG_fail;
14208 }
14209 }
14210 if (obj3) {
14211 {
14212 arg5 = (int)(SWIG_As_int(obj3));
14213 if (SWIG_arg_fail(5)) SWIG_fail;
14214 }
14215 }
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14219
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 Py_INCREF(Py_None); resultobj = Py_None;
14224 {
14225 if (arg3) delete [] arg3;
14226 }
14227 return resultobj;
14228 fail:
14229 {
14230 if (arg3) delete [] arg3;
14231 }
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj;
14238 wxDC *arg1 = (wxDC *) 0 ;
14239 int arg2 ;
14240 wxPoint *arg3 = (wxPoint *) 0 ;
14241 int arg4 = (int) 0 ;
14242 int arg5 = (int) 0 ;
14243 int arg6 = (int) wxODDEVEN_RULE ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 PyObject * obj2 = 0 ;
14247 PyObject * obj3 = 0 ;
14248 PyObject * obj4 = 0 ;
14249 char *kwnames[] = {
14250 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14251 };
14252
14253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14255 if (SWIG_arg_fail(1)) SWIG_fail;
14256 {
14257 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14258 if (arg3 == NULL) SWIG_fail;
14259 }
14260 if (obj2) {
14261 {
14262 arg4 = (int)(SWIG_As_int(obj2));
14263 if (SWIG_arg_fail(4)) SWIG_fail;
14264 }
14265 }
14266 if (obj3) {
14267 {
14268 arg5 = (int)(SWIG_As_int(obj3));
14269 if (SWIG_arg_fail(5)) SWIG_fail;
14270 }
14271 }
14272 if (obj4) {
14273 {
14274 arg6 = (int)(SWIG_As_int(obj4));
14275 if (SWIG_arg_fail(6)) SWIG_fail;
14276 }
14277 }
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 Py_INCREF(Py_None); resultobj = Py_None;
14286 {
14287 if (arg3) delete [] arg3;
14288 }
14289 return resultobj;
14290 fail:
14291 {
14292 if (arg3) delete [] arg3;
14293 }
14294 return NULL;
14295 }
14296
14297
14298 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj;
14300 wxDC *arg1 = (wxDC *) 0 ;
14301 wxString *arg2 = 0 ;
14302 wxRect *arg3 = 0 ;
14303 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14304 int arg5 = (int) -1 ;
14305 bool temp2 = false ;
14306 wxRect temp3 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 PyObject * obj2 = 0 ;
14310 PyObject * obj3 = 0 ;
14311 PyObject * obj4 = 0 ;
14312 char *kwnames[] = {
14313 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14314 };
14315
14316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 {
14320 arg2 = wxString_in_helper(obj1);
14321 if (arg2 == NULL) SWIG_fail;
14322 temp2 = true;
14323 }
14324 {
14325 arg3 = &temp3;
14326 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14327 }
14328 if (obj3) {
14329 {
14330 arg4 = (int)(SWIG_As_int(obj3));
14331 if (SWIG_arg_fail(4)) SWIG_fail;
14332 }
14333 }
14334 if (obj4) {
14335 {
14336 arg5 = (int)(SWIG_As_int(obj4));
14337 if (SWIG_arg_fail(5)) SWIG_fail;
14338 }
14339 }
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 Py_INCREF(Py_None); resultobj = Py_None;
14348 {
14349 if (temp2)
14350 delete arg2;
14351 }
14352 return resultobj;
14353 fail:
14354 {
14355 if (temp2)
14356 delete arg2;
14357 }
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxDC *arg1 = (wxDC *) 0 ;
14365 wxString *arg2 = 0 ;
14366 wxBitmap *arg3 = 0 ;
14367 wxRect *arg4 = 0 ;
14368 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14369 int arg6 = (int) -1 ;
14370 wxRect result;
14371 bool temp2 = false ;
14372 wxRect temp4 ;
14373 PyObject * obj0 = 0 ;
14374 PyObject * obj1 = 0 ;
14375 PyObject * obj2 = 0 ;
14376 PyObject * obj3 = 0 ;
14377 PyObject * obj4 = 0 ;
14378 PyObject * obj5 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 arg2 = wxString_in_helper(obj1);
14388 if (arg2 == NULL) SWIG_fail;
14389 temp2 = true;
14390 }
14391 {
14392 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14393 if (SWIG_arg_fail(3)) SWIG_fail;
14394 if (arg3 == NULL) {
14395 SWIG_null_ref("wxBitmap");
14396 }
14397 if (SWIG_arg_fail(3)) SWIG_fail;
14398 }
14399 {
14400 arg4 = &temp4;
14401 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14402 }
14403 if (obj4) {
14404 {
14405 arg5 = (int)(SWIG_As_int(obj4));
14406 if (SWIG_arg_fail(5)) SWIG_fail;
14407 }
14408 }
14409 if (obj5) {
14410 {
14411 arg6 = (int)(SWIG_As_int(obj5));
14412 if (SWIG_arg_fail(6)) SWIG_fail;
14413 }
14414 }
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 {
14423 wxRect * resultptr;
14424 resultptr = new wxRect((wxRect &)(result));
14425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14426 }
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return resultobj;
14432 fail:
14433 {
14434 if (temp2)
14435 delete arg2;
14436 }
14437 return NULL;
14438 }
14439
14440
14441 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxDC *arg1 = (wxDC *) 0 ;
14444 int arg2 ;
14445 wxPoint *arg3 = (wxPoint *) 0 ;
14446 PyObject * obj0 = 0 ;
14447 PyObject * obj1 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self",(char *) "points", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14457 if (arg3 == NULL) SWIG_fail;
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 (arg1)->DrawSpline(arg2,arg3);
14462
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 Py_INCREF(Py_None); resultobj = Py_None;
14467 {
14468 if (arg3) delete [] arg3;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (arg3) delete [] arg3;
14474 }
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxDC *arg1 = (wxDC *) 0 ;
14482 PyObject * obj0 = 0 ;
14483 char *kwnames[] = {
14484 (char *) "self", NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14489 if (SWIG_arg_fail(1)) SWIG_fail;
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 (arg1)->Clear();
14493
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 Py_INCREF(Py_None); resultobj = Py_None;
14498 return resultobj;
14499 fail:
14500 return NULL;
14501 }
14502
14503
14504 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14505 PyObject *resultobj;
14506 wxDC *arg1 = (wxDC *) 0 ;
14507 wxString *arg2 = 0 ;
14508 bool result;
14509 bool temp2 = false ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "message", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 arg2 = wxString_in_helper(obj1);
14521 if (arg2 == NULL) SWIG_fail;
14522 temp2 = true;
14523 }
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14527
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 {
14532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14533 }
14534 {
14535 if (temp2)
14536 delete arg2;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (temp2)
14542 delete arg2;
14543 }
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxDC *arg1 = (wxDC *) 0 ;
14551 PyObject * obj0 = 0 ;
14552 char *kwnames[] = {
14553 (char *) "self", NULL
14554 };
14555
14556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14558 if (SWIG_arg_fail(1)) SWIG_fail;
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 (arg1)->EndDoc();
14562
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 Py_INCREF(Py_None); resultobj = Py_None;
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj;
14575 wxDC *arg1 = (wxDC *) 0 ;
14576 PyObject * obj0 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 (arg1)->StartPage();
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 Py_INCREF(Py_None); resultobj = Py_None;
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj;
14600 wxDC *arg1 = (wxDC *) 0 ;
14601 PyObject * obj0 = 0 ;
14602 char *kwnames[] = {
14603 (char *) "self", NULL
14604 };
14605
14606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14608 if (SWIG_arg_fail(1)) SWIG_fail;
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 (arg1)->EndPage();
14612
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 Py_INCREF(Py_None); resultobj = Py_None;
14617 return resultobj;
14618 fail:
14619 return NULL;
14620 }
14621
14622
14623 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj;
14625 wxDC *arg1 = (wxDC *) 0 ;
14626 wxFont *arg2 = 0 ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char *kwnames[] = {
14630 (char *) "self",(char *) "font", NULL
14631 };
14632
14633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(1)) SWIG_fail;
14636 {
14637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14638 if (SWIG_arg_fail(2)) SWIG_fail;
14639 if (arg2 == NULL) {
14640 SWIG_null_ref("wxFont");
14641 }
14642 if (SWIG_arg_fail(2)) SWIG_fail;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetFont((wxFont const &)*arg2);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 Py_INCREF(Py_None); resultobj = Py_None;
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14659 PyObject *resultobj;
14660 wxDC *arg1 = (wxDC *) 0 ;
14661 wxPen *arg2 = 0 ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "pen", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 {
14672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14673 if (SWIG_arg_fail(2)) SWIG_fail;
14674 if (arg2 == NULL) {
14675 SWIG_null_ref("wxPen");
14676 }
14677 if (SWIG_arg_fail(2)) SWIG_fail;
14678 }
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 (arg1)->SetPen((wxPen const &)*arg2);
14682
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 Py_INCREF(Py_None); resultobj = Py_None;
14687 return resultobj;
14688 fail:
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxDC *arg1 = (wxDC *) 0 ;
14696 wxBrush *arg2 = 0 ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char *kwnames[] = {
14700 (char *) "self",(char *) "brush", NULL
14701 };
14702
14703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14705 if (SWIG_arg_fail(1)) SWIG_fail;
14706 {
14707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(2)) SWIG_fail;
14709 if (arg2 == NULL) {
14710 SWIG_null_ref("wxBrush");
14711 }
14712 if (SWIG_arg_fail(2)) SWIG_fail;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetBrush((wxBrush const &)*arg2);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 Py_INCREF(Py_None); resultobj = Py_None;
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxDC *arg1 = (wxDC *) 0 ;
14731 wxBrush *arg2 = 0 ;
14732 PyObject * obj0 = 0 ;
14733 PyObject * obj1 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self",(char *) "brush", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(2)) SWIG_fail;
14744 if (arg2 == NULL) {
14745 SWIG_null_ref("wxBrush");
14746 }
14747 if (SWIG_arg_fail(2)) SWIG_fail;
14748 }
14749 {
14750 PyThreadState* __tstate = wxPyBeginAllowThreads();
14751 (arg1)->SetBackground((wxBrush const &)*arg2);
14752
14753 wxPyEndAllowThreads(__tstate);
14754 if (PyErr_Occurred()) SWIG_fail;
14755 }
14756 Py_INCREF(Py_None); resultobj = Py_None;
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14764 PyObject *resultobj;
14765 wxDC *arg1 = (wxDC *) 0 ;
14766 int arg2 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char *kwnames[] = {
14770 (char *) "self",(char *) "mode", NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14775 if (SWIG_arg_fail(1)) SWIG_fail;
14776 {
14777 arg2 = (int)(SWIG_As_int(obj1));
14778 if (SWIG_arg_fail(2)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 (arg1)->SetBackgroundMode(arg2);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 Py_INCREF(Py_None); resultobj = Py_None;
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxDC *arg1 = (wxDC *) 0 ;
14797 wxPalette *arg2 = 0 ;
14798 PyObject * obj0 = 0 ;
14799 PyObject * obj1 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self",(char *) "palette", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(2)) SWIG_fail;
14810 if (arg2 == NULL) {
14811 SWIG_null_ref("wxPalette");
14812 }
14813 if (SWIG_arg_fail(2)) SWIG_fail;
14814 }
14815 {
14816 PyThreadState* __tstate = wxPyBeginAllowThreads();
14817 (arg1)->SetPalette((wxPalette const &)*arg2);
14818
14819 wxPyEndAllowThreads(__tstate);
14820 if (PyErr_Occurred()) SWIG_fail;
14821 }
14822 Py_INCREF(Py_None); resultobj = Py_None;
14823 return resultobj;
14824 fail:
14825 return NULL;
14826 }
14827
14828
14829 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj;
14831 wxDC *arg1 = (wxDC *) 0 ;
14832 PyObject * obj0 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "self", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14839 if (SWIG_arg_fail(1)) SWIG_fail;
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 (arg1)->DestroyClippingRegion();
14843
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 Py_INCREF(Py_None); resultobj = Py_None;
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj;
14856 wxDC *arg1 = (wxDC *) 0 ;
14857 int *arg2 = (int *) 0 ;
14858 int *arg3 = (int *) 0 ;
14859 int *arg4 = (int *) 0 ;
14860 int *arg5 = (int *) 0 ;
14861 int temp2 ;
14862 int res2 = 0 ;
14863 int temp3 ;
14864 int res3 = 0 ;
14865 int temp4 ;
14866 int res4 = 0 ;
14867 int temp5 ;
14868 int res5 = 0 ;
14869 PyObject * obj0 = 0 ;
14870 char *kwnames[] = {
14871 (char *) "self", NULL
14872 };
14873
14874 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14875 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14876 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14877 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14880 if (SWIG_arg_fail(1)) SWIG_fail;
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14884
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 Py_INCREF(Py_None); resultobj = Py_None;
14889 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14890 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14891 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14892 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14893 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14894 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14895 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14896 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14897 return resultobj;
14898 fail:
14899 return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj;
14905 wxDC *arg1 = (wxDC *) 0 ;
14906 wxRect result;
14907 PyObject * obj0 = 0 ;
14908 char *kwnames[] = {
14909 (char *) "self", NULL
14910 };
14911
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14914 if (SWIG_arg_fail(1)) SWIG_fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = wxDC_GetClippingRect(arg1);
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 wxRect * resultptr;
14924 resultptr = new wxRect((wxRect &)(result));
14925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj;
14935 wxDC *arg1 = (wxDC *) 0 ;
14936 int result;
14937 PyObject * obj0 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (int)((wxDC const *)arg1)->GetCharHeight();
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 {
14953 resultobj = SWIG_From_int((int)(result));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxDC *arg1 = (wxDC *) 0 ;
14964 int result;
14965 PyObject * obj0 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (int)((wxDC const *)arg1)->GetCharWidth();
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 {
14981 resultobj = SWIG_From_int((int)(result));
14982 }
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj;
14991 wxDC *arg1 = (wxDC *) 0 ;
14992 wxString *arg2 = 0 ;
14993 int *arg3 = (int *) 0 ;
14994 int *arg4 = (int *) 0 ;
14995 bool temp2 = false ;
14996 int temp3 ;
14997 int res3 = 0 ;
14998 int temp4 ;
14999 int res4 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self",(char *) "string", NULL
15004 };
15005
15006 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15007 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 arg2 = wxString_in_helper(obj1);
15013 if (arg2 == NULL) SWIG_fail;
15014 temp2 = true;
15015 }
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15019
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 Py_INCREF(Py_None); resultobj = Py_None;
15024 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15025 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15026 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15027 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15028 {
15029 if (temp2)
15030 delete arg2;
15031 }
15032 return resultobj;
15033 fail:
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15043 PyObject *resultobj;
15044 wxDC *arg1 = (wxDC *) 0 ;
15045 wxString *arg2 = 0 ;
15046 int *arg3 = (int *) 0 ;
15047 int *arg4 = (int *) 0 ;
15048 int *arg5 = (int *) 0 ;
15049 int *arg6 = (int *) 0 ;
15050 wxFont *arg7 = (wxFont *) NULL ;
15051 bool temp2 = false ;
15052 int temp3 ;
15053 int res3 = 0 ;
15054 int temp4 ;
15055 int res4 = 0 ;
15056 int temp5 ;
15057 int res5 = 0 ;
15058 int temp6 ;
15059 int res6 = 0 ;
15060 PyObject * obj0 = 0 ;
15061 PyObject * obj1 = 0 ;
15062 PyObject * obj2 = 0 ;
15063 char *kwnames[] = {
15064 (char *) "self",(char *) "string",(char *) "font", NULL
15065 };
15066
15067 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15068 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15069 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15070 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 {
15075 arg2 = wxString_in_helper(obj1);
15076 if (arg2 == NULL) SWIG_fail;
15077 temp2 = true;
15078 }
15079 if (obj2) {
15080 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(7)) SWIG_fail;
15082 }
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15086
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 Py_INCREF(Py_None); resultobj = Py_None;
15091 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15092 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15093 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15094 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15095 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15096 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15097 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15098 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15099 {
15100 if (temp2)
15101 delete arg2;
15102 }
15103 return resultobj;
15104 fail:
15105 {
15106 if (temp2)
15107 delete arg2;
15108 }
15109 return NULL;
15110 }
15111
15112
15113 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj;
15115 wxDC *arg1 = (wxDC *) 0 ;
15116 wxString *arg2 = 0 ;
15117 int *arg3 = (int *) 0 ;
15118 int *arg4 = (int *) 0 ;
15119 int *arg5 = (int *) 0 ;
15120 wxFont *arg6 = (wxFont *) NULL ;
15121 bool temp2 = false ;
15122 int temp3 ;
15123 int res3 = 0 ;
15124 int temp4 ;
15125 int res4 = 0 ;
15126 int temp5 ;
15127 int res5 = 0 ;
15128 PyObject * obj0 = 0 ;
15129 PyObject * obj1 = 0 ;
15130 PyObject * obj2 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "self",(char *) "text",(char *) "font", NULL
15133 };
15134
15135 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15136 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15137 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15140 if (SWIG_arg_fail(1)) SWIG_fail;
15141 {
15142 arg2 = wxString_in_helper(obj1);
15143 if (arg2 == NULL) SWIG_fail;
15144 temp2 = true;
15145 }
15146 if (obj2) {
15147 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15148 if (SWIG_arg_fail(6)) SWIG_fail;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 Py_INCREF(Py_None); resultobj = Py_None;
15158 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15159 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15160 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15161 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15162 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15163 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15164 {
15165 if (temp2)
15166 delete arg2;
15167 }
15168 return resultobj;
15169 fail:
15170 {
15171 if (temp2)
15172 delete arg2;
15173 }
15174 return NULL;
15175 }
15176
15177
15178 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj;
15180 wxDC *arg1 = (wxDC *) 0 ;
15181 wxString *arg2 = 0 ;
15182 wxArrayInt result;
15183 bool temp2 = false ;
15184 PyObject * obj0 = 0 ;
15185 PyObject * obj1 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self",(char *) "text", NULL
15188 };
15189
15190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(1)) SWIG_fail;
15193 {
15194 arg2 = wxString_in_helper(obj1);
15195 if (arg2 == NULL) SWIG_fail;
15196 temp2 = true;
15197 }
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = PyList_New(0);
15207 size_t idx;
15208 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15209 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15210 PyList_Append(resultobj, val);
15211 Py_DECREF(val);
15212 }
15213 }
15214 {
15215 if (temp2)
15216 delete arg2;
15217 }
15218 return resultobj;
15219 fail:
15220 {
15221 if (temp2)
15222 delete arg2;
15223 }
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxDC *arg1 = (wxDC *) 0 ;
15231 wxSize result;
15232 PyObject * obj0 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (arg1)->GetSize();
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 {
15248 wxSize * resultptr;
15249 resultptr = new wxSize((wxSize &)(result));
15250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15251 }
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxDC *arg1 = (wxDC *) 0 ;
15261 int *arg2 = (int *) 0 ;
15262 int *arg3 = (int *) 0 ;
15263 int temp2 ;
15264 int res2 = 0 ;
15265 int temp3 ;
15266 int res3 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self", NULL
15270 };
15271
15272 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15276 if (SWIG_arg_fail(1)) SWIG_fail;
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->GetSize(arg2,arg3);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 Py_INCREF(Py_None); resultobj = Py_None;
15285 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15286 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15287 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15288 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj;
15297 wxDC *arg1 = (wxDC *) 0 ;
15298 wxSize result;
15299 PyObject * obj0 = 0 ;
15300 char *kwnames[] = {
15301 (char *) "self", NULL
15302 };
15303
15304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(1)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = ((wxDC const *)arg1)->GetSizeMM();
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 wxSize * resultptr;
15316 resultptr = new wxSize((wxSize &)(result));
15317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15318 }
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj;
15327 wxDC *arg1 = (wxDC *) 0 ;
15328 int *arg2 = (int *) 0 ;
15329 int *arg3 = (int *) 0 ;
15330 int temp2 ;
15331 int res2 = 0 ;
15332 int temp3 ;
15333 int res3 = 0 ;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15340 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 Py_INCREF(Py_None); resultobj = Py_None;
15352 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15353 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15354 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15355 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxDC *arg1 = (wxDC *) 0 ;
15365 int arg2 ;
15366 int result;
15367 PyObject * obj0 = 0 ;
15368 PyObject * obj1 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self",(char *) "x", NULL
15371 };
15372
15373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15375 if (SWIG_arg_fail(1)) SWIG_fail;
15376 {
15377 arg2 = (int)(SWIG_As_int(obj1));
15378 if (SWIG_arg_fail(2)) SWIG_fail;
15379 }
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 {
15388 resultobj = SWIG_From_int((int)(result));
15389 }
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15397 PyObject *resultobj;
15398 wxDC *arg1 = (wxDC *) 0 ;
15399 int arg2 ;
15400 int result;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self",(char *) "y", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 arg2 = (int)(SWIG_As_int(obj1));
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 }
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxDC *arg1 = (wxDC *) 0 ;
15433 int arg2 ;
15434 int result;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "x", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = (int)(SWIG_As_int(obj1));
15446 if (SWIG_arg_fail(2)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 {
15456 resultobj = SWIG_From_int((int)(result));
15457 }
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj;
15466 wxDC *arg1 = (wxDC *) 0 ;
15467 int arg2 ;
15468 int result;
15469 PyObject * obj0 = 0 ;
15470 PyObject * obj1 = 0 ;
15471 char *kwnames[] = {
15472 (char *) "self",(char *) "y", NULL
15473 };
15474
15475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 {
15479 arg2 = (int)(SWIG_As_int(obj1));
15480 if (SWIG_arg_fail(2)) SWIG_fail;
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 {
15490 resultobj = SWIG_From_int((int)(result));
15491 }
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxDC *arg1 = (wxDC *) 0 ;
15501 int arg2 ;
15502 int result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "x", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 arg2 = (int)(SWIG_As_int(obj1));
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15519
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 {
15524 resultobj = SWIG_From_int((int)(result));
15525 }
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj;
15534 wxDC *arg1 = (wxDC *) 0 ;
15535 int arg2 ;
15536 int result;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self",(char *) "y", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 arg2 = (int)(SWIG_As_int(obj1));
15548 if (SWIG_arg_fail(2)) SWIG_fail;
15549 }
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15553
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 {
15558 resultobj = SWIG_From_int((int)(result));
15559 }
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxDC *arg1 = (wxDC *) 0 ;
15569 int arg2 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char *kwnames[] = {
15574 (char *) "self",(char *) "x", NULL
15575 };
15576
15577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15579 if (SWIG_arg_fail(1)) SWIG_fail;
15580 {
15581 arg2 = (int)(SWIG_As_int(obj1));
15582 if (SWIG_arg_fail(2)) SWIG_fail;
15583 }
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15587
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = SWIG_From_int((int)(result));
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj;
15602 wxDC *arg1 = (wxDC *) 0 ;
15603 int arg2 ;
15604 int result;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self",(char *) "y", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 {
15626 resultobj = SWIG_From_int((int)(result));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxDC *arg1 = (wxDC *) 0 ;
15637 bool result;
15638 PyObject * obj0 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15649
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 {
15654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15655 }
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15663 PyObject *resultobj;
15664 wxDC *arg1 = (wxDC *) 0 ;
15665 bool result;
15666 PyObject * obj0 = 0 ;
15667 char *kwnames[] = {
15668 (char *) "self", NULL
15669 };
15670
15671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15673 if (SWIG_arg_fail(1)) SWIG_fail;
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15677
15678 wxPyEndAllowThreads(__tstate);
15679 if (PyErr_Occurred()) SWIG_fail;
15680 }
15681 {
15682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15683 }
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxDC *arg1 = (wxDC *) 0 ;
15693 int result;
15694 PyObject * obj0 = 0 ;
15695 char *kwnames[] = {
15696 (char *) "self", NULL
15697 };
15698
15699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15701 if (SWIG_arg_fail(1)) SWIG_fail;
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 result = (int)((wxDC const *)arg1)->GetDepth();
15705
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 {
15710 resultobj = SWIG_From_int((int)(result));
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj;
15720 wxDC *arg1 = (wxDC *) 0 ;
15721 wxSize result;
15722 PyObject * obj0 = 0 ;
15723 char *kwnames[] = {
15724 (char *) "self", NULL
15725 };
15726
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 {
15731 PyThreadState* __tstate = wxPyBeginAllowThreads();
15732 result = ((wxDC const *)arg1)->GetPPI();
15733
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 {
15738 wxSize * resultptr;
15739 resultptr = new wxSize((wxSize &)(result));
15740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxDC *arg1 = (wxDC *) 0 ;
15751 bool result;
15752 PyObject * obj0 = 0 ;
15753 char *kwnames[] = {
15754 (char *) "self", NULL
15755 };
15756
15757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15759 if (SWIG_arg_fail(1)) SWIG_fail;
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (bool)((wxDC const *)arg1)->Ok();
15763
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 {
15768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15769 }
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxDC *arg1 = (wxDC *) 0 ;
15779 int result;
15780 PyObject * obj0 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15791
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 {
15796 resultobj = SWIG_From_int((int)(result));
15797 }
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxDC *arg1 = (wxDC *) 0 ;
15807 wxBrush *result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 {
15819 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15820 result = (wxBrush *) &_result_ref;
15821 }
15822
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 {
15827 wxBrush* resultptr = new wxBrush(*result);
15828 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxDC *arg1 = (wxDC *) 0 ;
15839 wxBrush *result;
15840 PyObject * obj0 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self", NULL
15843 };
15844
15845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15847 if (SWIG_arg_fail(1)) SWIG_fail;
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 {
15851 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15852 result = (wxBrush *) &_result_ref;
15853 }
15854
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 wxBrush* resultptr = new wxBrush(*result);
15860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15861 }
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15869 PyObject *resultobj;
15870 wxDC *arg1 = (wxDC *) 0 ;
15871 wxFont *result;
15872 PyObject * obj0 = 0 ;
15873 char *kwnames[] = {
15874 (char *) "self", NULL
15875 };
15876
15877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15879 if (SWIG_arg_fail(1)) SWIG_fail;
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 {
15883 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15884 result = (wxFont *) &_result_ref;
15885 }
15886
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 {
15891 wxFont* resultptr = new wxFont(*result);
15892 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj;
15902 wxDC *arg1 = (wxDC *) 0 ;
15903 wxPen *result;
15904 PyObject * obj0 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "self", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(1)) SWIG_fail;
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 {
15915 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15916 result = (wxPen *) &_result_ref;
15917 }
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 {
15923 wxPen* resultptr = new wxPen(*result);
15924 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15925 }
15926 return resultobj;
15927 fail:
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj;
15934 wxDC *arg1 = (wxDC *) 0 ;
15935 wxColour *result;
15936 PyObject * obj0 = 0 ;
15937 char *kwnames[] = {
15938 (char *) "self", NULL
15939 };
15940
15941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 {
15947 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15948 result = (wxColour *) &_result_ref;
15949 }
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj;
15963 wxDC *arg1 = (wxDC *) 0 ;
15964 wxColour *result;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",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 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15977 result = (wxColour *) &_result_ref;
15978 }
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj;
15992 wxDC *arg1 = (wxDC *) 0 ;
15993 wxColour *arg2 = 0 ;
15994 wxColour temp2 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char *kwnames[] = {
15998 (char *) "self",(char *) "colour", NULL
15999 };
16000
16001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16003 if (SWIG_arg_fail(1)) SWIG_fail;
16004 {
16005 arg2 = &temp2;
16006 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->SetTextForeground((wxColour const &)*arg2);
16011
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 Py_INCREF(Py_None); resultobj = Py_None;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj;
16024 wxDC *arg1 = (wxDC *) 0 ;
16025 wxColour *arg2 = 0 ;
16026 wxColour temp2 ;
16027 PyObject * obj0 = 0 ;
16028 PyObject * obj1 = 0 ;
16029 char *kwnames[] = {
16030 (char *) "self",(char *) "colour", NULL
16031 };
16032
16033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16035 if (SWIG_arg_fail(1)) SWIG_fail;
16036 {
16037 arg2 = &temp2;
16038 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->SetTextBackground((wxColour const &)*arg2);
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 Py_INCREF(Py_None); resultobj = Py_None;
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj;
16056 wxDC *arg1 = (wxDC *) 0 ;
16057 int result;
16058 PyObject * obj0 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",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 result = (int)((wxDC const *)arg1)->GetMapMode();
16069
16070 wxPyEndAllowThreads(__tstate);
16071 if (PyErr_Occurred()) SWIG_fail;
16072 }
16073 {
16074 resultobj = SWIG_From_int((int)(result));
16075 }
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16083 PyObject *resultobj;
16084 wxDC *arg1 = (wxDC *) 0 ;
16085 int arg2 ;
16086 PyObject * obj0 = 0 ;
16087 PyObject * obj1 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self",(char *) "mode", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 arg2 = (int)(SWIG_As_int(obj1));
16097 if (SWIG_arg_fail(2)) SWIG_fail;
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 (arg1)->SetMapMode(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 Py_INCREF(Py_None); resultobj = Py_None;
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxDC *arg1 = (wxDC *) 0 ;
16116 double *arg2 = (double *) 0 ;
16117 double *arg3 = (double *) 0 ;
16118 double temp2 ;
16119 int res2 = 0 ;
16120 double temp3 ;
16121 int res3 = 0 ;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16128 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16135
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 Py_INCREF(Py_None); resultobj = Py_None;
16140 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16141 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16142 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16143 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj;
16152 wxDC *arg1 = (wxDC *) 0 ;
16153 double arg2 ;
16154 double arg3 ;
16155 PyObject * obj0 = 0 ;
16156 PyObject * obj1 = 0 ;
16157 PyObject * obj2 = 0 ;
16158 char *kwnames[] = {
16159 (char *) "self",(char *) "x",(char *) "y", NULL
16160 };
16161
16162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16164 if (SWIG_arg_fail(1)) SWIG_fail;
16165 {
16166 arg2 = (double)(SWIG_As_double(obj1));
16167 if (SWIG_arg_fail(2)) SWIG_fail;
16168 }
16169 {
16170 arg3 = (double)(SWIG_As_double(obj2));
16171 if (SWIG_arg_fail(3)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetUserScale(arg2,arg3);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 double *arg2 = (double *) 0 ;
16191 double *arg3 = (double *) 0 ;
16192 double temp2 ;
16193 int res2 = 0 ;
16194 double temp3 ;
16195 int res3 = 0 ;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "self", NULL
16199 };
16200
16201 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16202 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16205 if (SWIG_arg_fail(1)) SWIG_fail;
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 (arg1)->GetLogicalScale(arg2,arg3);
16209
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 Py_INCREF(Py_None); resultobj = Py_None;
16214 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16215 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16216 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16217 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj;
16226 wxDC *arg1 = (wxDC *) 0 ;
16227 double arg2 ;
16228 double arg3 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self",(char *) "x",(char *) "y", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 arg2 = (double)(SWIG_As_double(obj1));
16241 if (SWIG_arg_fail(2)) SWIG_fail;
16242 }
16243 {
16244 arg3 = (double)(SWIG_As_double(obj2));
16245 if (SWIG_arg_fail(3)) SWIG_fail;
16246 }
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 (arg1)->SetLogicalScale(arg2,arg3);
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 Py_INCREF(Py_None); resultobj = Py_None;
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxDC *arg1 = (wxDC *) 0 ;
16264 wxPoint result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 wxPoint * resultptr;
16282 resultptr = new wxPoint((wxPoint &)(result));
16283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16284 }
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj;
16293 wxDC *arg1 = (wxDC *) 0 ;
16294 int *arg2 = (int *) 0 ;
16295 int *arg3 = (int *) 0 ;
16296 int temp2 ;
16297 int res2 = 0 ;
16298 int temp3 ;
16299 int res3 = 0 ;
16300 PyObject * obj0 = 0 ;
16301 char *kwnames[] = {
16302 (char *) "self", NULL
16303 };
16304
16305 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16306 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16309 if (SWIG_arg_fail(1)) SWIG_fail;
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16313
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 Py_INCREF(Py_None); resultobj = Py_None;
16318 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16319 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxDC *arg1 = (wxDC *) 0 ;
16331 int arg2 ;
16332 int arg3 ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 PyObject * obj2 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self",(char *) "x",(char *) "y", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 arg2 = (int)(SWIG_As_int(obj1));
16345 if (SWIG_arg_fail(2)) SWIG_fail;
16346 }
16347 {
16348 arg3 = (int)(SWIG_As_int(obj2));
16349 if (SWIG_arg_fail(3)) SWIG_fail;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetLogicalOrigin(arg2,arg3);
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 Py_INCREF(Py_None); resultobj = Py_None;
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxDC *arg1 = (wxDC *) 0 ;
16368 wxPoint *arg2 = 0 ;
16369 wxPoint temp2 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self",(char *) "point", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 arg2 = &temp2;
16381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16382 }
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 Py_INCREF(Py_None); resultobj = Py_None;
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxDC *arg1 = (wxDC *) 0 ;
16400 wxPoint result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 wxPoint * resultptr;
16418 resultptr = new wxPoint((wxPoint &)(result));
16419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16420 }
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj;
16429 wxDC *arg1 = (wxDC *) 0 ;
16430 int *arg2 = (int *) 0 ;
16431 int *arg3 = (int *) 0 ;
16432 int temp2 ;
16433 int res2 = 0 ;
16434 int temp3 ;
16435 int res3 = 0 ;
16436 PyObject * obj0 = 0 ;
16437 char *kwnames[] = {
16438 (char *) "self", NULL
16439 };
16440
16441 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16442 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 Py_INCREF(Py_None); resultobj = Py_None;
16454 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16455 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16456 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16457 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16458 return resultobj;
16459 fail:
16460 return NULL;
16461 }
16462
16463
16464 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj;
16466 wxDC *arg1 = (wxDC *) 0 ;
16467 int arg2 ;
16468 int arg3 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 PyObject * obj2 = 0 ;
16472 char *kwnames[] = {
16473 (char *) "self",(char *) "x",(char *) "y", NULL
16474 };
16475
16476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16478 if (SWIG_arg_fail(1)) SWIG_fail;
16479 {
16480 arg2 = (int)(SWIG_As_int(obj1));
16481 if (SWIG_arg_fail(2)) SWIG_fail;
16482 }
16483 {
16484 arg3 = (int)(SWIG_As_int(obj2));
16485 if (SWIG_arg_fail(3)) SWIG_fail;
16486 }
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 (arg1)->SetDeviceOrigin(arg2,arg3);
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 Py_INCREF(Py_None); resultobj = Py_None;
16495 return resultobj;
16496 fail:
16497 return NULL;
16498 }
16499
16500
16501 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16502 PyObject *resultobj;
16503 wxDC *arg1 = (wxDC *) 0 ;
16504 wxPoint *arg2 = 0 ;
16505 wxPoint temp2 ;
16506 PyObject * obj0 = 0 ;
16507 PyObject * obj1 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self",(char *) "point", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 arg2 = &temp2;
16517 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16518 }
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 Py_INCREF(Py_None); resultobj = Py_None;
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxDC *arg1 = (wxDC *) 0 ;
16536 bool arg2 ;
16537 bool arg3 ;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 PyObject * obj2 = 0 ;
16541 char *kwnames[] = {
16542 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16543 };
16544
16545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16547 if (SWIG_arg_fail(1)) SWIG_fail;
16548 {
16549 arg2 = (bool)(SWIG_As_bool(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 {
16553 arg3 = (bool)(SWIG_As_bool(obj2));
16554 if (SWIG_arg_fail(3)) SWIG_fail;
16555 }
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 (arg1)->SetAxisOrientation(arg2,arg3);
16559
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 Py_INCREF(Py_None); resultobj = Py_None;
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxDC *arg1 = (wxDC *) 0 ;
16573 int result;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = SWIG_From_int((int)(result));
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxDC *arg1 = (wxDC *) 0 ;
16601 int arg2 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self",(char *) "function", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 arg2 = (int)(SWIG_As_int(obj1));
16613 if (SWIG_arg_fail(2)) SWIG_fail;
16614 }
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 (arg1)->SetLogicalFunction(arg2);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 Py_INCREF(Py_None); resultobj = Py_None;
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj;
16631 wxDC *arg1 = (wxDC *) 0 ;
16632 PyObject * obj0 = 0 ;
16633 char *kwnames[] = {
16634 (char *) "self", NULL
16635 };
16636
16637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16639 if (SWIG_arg_fail(1)) SWIG_fail;
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 (arg1)->ComputeScaleAndOrigin();
16643
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 Py_INCREF(Py_None); resultobj = Py_None;
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16655 PyObject *resultobj;
16656 wxDC *arg1 = (wxDC *) 0 ;
16657 int arg2 ;
16658 int arg3 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 PyObject * obj2 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "self",(char *) "x",(char *) "y", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 arg2 = (int)(SWIG_As_int(obj1));
16671 if (SWIG_arg_fail(2)) SWIG_fail;
16672 }
16673 {
16674 arg3 = (int)(SWIG_As_int(obj2));
16675 if (SWIG_arg_fail(3)) SWIG_fail;
16676 }
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 (arg1)->CalcBoundingBox(arg2,arg3);
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 Py_INCREF(Py_None); resultobj = Py_None;
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj;
16693 wxDC *arg1 = (wxDC *) 0 ;
16694 wxPoint *arg2 = 0 ;
16695 wxPoint temp2 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self",(char *) "point", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 arg2 = &temp2;
16707 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16708 }
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16712
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 Py_INCREF(Py_None); resultobj = Py_None;
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxDC *arg1 = (wxDC *) 0 ;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->ResetBoundingBox();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 Py_INCREF(Py_None); resultobj = Py_None;
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj;
16750 wxDC *arg1 = (wxDC *) 0 ;
16751 int result;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = (int)((wxDC const *)arg1)->MinX();
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 resultobj = SWIG_From_int((int)(result));
16769 }
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj;
16778 wxDC *arg1 = (wxDC *) 0 ;
16779 int result;
16780 PyObject * obj0 = 0 ;
16781 char *kwnames[] = {
16782 (char *) "self", NULL
16783 };
16784
16785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16787 if (SWIG_arg_fail(1)) SWIG_fail;
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 result = (int)((wxDC const *)arg1)->MaxX();
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 {
16796 resultobj = SWIG_From_int((int)(result));
16797 }
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16805 PyObject *resultobj;
16806 wxDC *arg1 = (wxDC *) 0 ;
16807 int result;
16808 PyObject * obj0 = 0 ;
16809 char *kwnames[] = {
16810 (char *) "self", NULL
16811 };
16812
16813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16815 if (SWIG_arg_fail(1)) SWIG_fail;
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 result = (int)((wxDC const *)arg1)->MinY();
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 {
16824 resultobj = SWIG_From_int((int)(result));
16825 }
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxDC *arg1 = (wxDC *) 0 ;
16835 int result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = (int)((wxDC const *)arg1)->MaxY();
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = SWIG_From_int((int)(result));
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxDC *arg1 = (wxDC *) 0 ;
16863 int *arg2 = (int *) 0 ;
16864 int *arg3 = (int *) 0 ;
16865 int *arg4 = (int *) 0 ;
16866 int *arg5 = (int *) 0 ;
16867 int temp2 ;
16868 int res2 = 0 ;
16869 int temp3 ;
16870 int res3 = 0 ;
16871 int temp4 ;
16872 int res4 = 0 ;
16873 int temp5 ;
16874 int res5 = 0 ;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16881 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16882 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16883 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16890
16891 wxPyEndAllowThreads(__tstate);
16892 if (PyErr_Occurred()) SWIG_fail;
16893 }
16894 Py_INCREF(Py_None); resultobj = Py_None;
16895 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16896 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16897 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16898 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16899 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16900 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16901 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16902 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxDC *arg1 = (wxDC *) 0 ;
16912 PyObject *arg2 = (PyObject *) 0 ;
16913 PyObject *arg3 = (PyObject *) 0 ;
16914 PyObject *arg4 = (PyObject *) 0 ;
16915 PyObject *result;
16916 PyObject * obj0 = 0 ;
16917 PyObject * obj1 = 0 ;
16918 PyObject * obj2 = 0 ;
16919 PyObject * obj3 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 arg2 = obj1;
16928 arg3 = obj2;
16929 arg4 = obj3;
16930 {
16931 PyThreadState* __tstate = wxPyBeginAllowThreads();
16932 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16933
16934 wxPyEndAllowThreads(__tstate);
16935 if (PyErr_Occurred()) SWIG_fail;
16936 }
16937 resultobj = result;
16938 return resultobj;
16939 fail:
16940 return NULL;
16941 }
16942
16943
16944 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj;
16946 wxDC *arg1 = (wxDC *) 0 ;
16947 PyObject *arg2 = (PyObject *) 0 ;
16948 PyObject *arg3 = (PyObject *) 0 ;
16949 PyObject *arg4 = (PyObject *) 0 ;
16950 PyObject *result;
16951 PyObject * obj0 = 0 ;
16952 PyObject * obj1 = 0 ;
16953 PyObject * obj2 = 0 ;
16954 PyObject * obj3 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 arg2 = obj1;
16963 arg3 = obj2;
16964 arg4 = obj3;
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16968
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 resultobj = result;
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj;
16981 wxDC *arg1 = (wxDC *) 0 ;
16982 PyObject *arg2 = (PyObject *) 0 ;
16983 PyObject *arg3 = (PyObject *) 0 ;
16984 PyObject *arg4 = (PyObject *) 0 ;
16985 PyObject *result;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 PyObject * obj2 = 0 ;
16989 PyObject * obj3 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 arg2 = obj1;
16998 arg3 = obj2;
16999 arg4 = obj3;
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17003
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 resultobj = result;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxDC *arg1 = (wxDC *) 0 ;
17017 PyObject *arg2 = (PyObject *) 0 ;
17018 PyObject *arg3 = (PyObject *) 0 ;
17019 PyObject *arg4 = (PyObject *) 0 ;
17020 PyObject *result;
17021 PyObject * obj0 = 0 ;
17022 PyObject * obj1 = 0 ;
17023 PyObject * obj2 = 0 ;
17024 PyObject * obj3 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 arg2 = obj1;
17033 arg3 = obj2;
17034 arg4 = obj3;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 resultobj = result;
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj;
17051 wxDC *arg1 = (wxDC *) 0 ;
17052 PyObject *arg2 = (PyObject *) 0 ;
17053 PyObject *arg3 = (PyObject *) 0 ;
17054 PyObject *arg4 = (PyObject *) 0 ;
17055 PyObject *result;
17056 PyObject * obj0 = 0 ;
17057 PyObject * obj1 = 0 ;
17058 PyObject * obj2 = 0 ;
17059 PyObject * obj3 = 0 ;
17060 char *kwnames[] = {
17061 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17062 };
17063
17064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17066 if (SWIG_arg_fail(1)) SWIG_fail;
17067 arg2 = obj1;
17068 arg3 = obj2;
17069 arg4 = obj3;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 resultobj = result;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxDC *arg1 = (wxDC *) 0 ;
17087 PyObject *arg2 = (PyObject *) 0 ;
17088 PyObject *arg3 = (PyObject *) 0 ;
17089 PyObject *arg4 = (PyObject *) 0 ;
17090 PyObject *arg5 = (PyObject *) 0 ;
17091 PyObject *result;
17092 PyObject * obj0 = 0 ;
17093 PyObject * obj1 = 0 ;
17094 PyObject * obj2 = 0 ;
17095 PyObject * obj3 = 0 ;
17096 PyObject * obj4 = 0 ;
17097 char *kwnames[] = {
17098 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17099 };
17100
17101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17103 if (SWIG_arg_fail(1)) SWIG_fail;
17104 arg2 = obj1;
17105 arg3 = obj2;
17106 arg4 = obj3;
17107 arg5 = obj4;
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17111
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = result;
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17123 PyObject *obj;
17124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17125 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17126 Py_INCREF(obj);
17127 return Py_BuildValue((char *)"");
17128 }
17129 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj;
17131 wxMemoryDC *result;
17132 char *kwnames[] = {
17133 NULL
17134 };
17135
17136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17137 {
17138 if (!wxPyCheckForApp()) SWIG_fail;
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (wxMemoryDC *)new wxMemoryDC();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxDC *arg1 = (wxDC *) 0 ;
17155 wxMemoryDC *result;
17156 PyObject * obj0 = 0 ;
17157 char *kwnames[] = {
17158 (char *) "oldDC", NULL
17159 };
17160
17161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 {
17165 if (!wxPyCheckForApp()) SWIG_fail;
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17182 wxBitmap *arg2 = 0 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "bitmap", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 if (arg2 == NULL) {
17196 SWIG_null_ref("wxBitmap");
17197 }
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 (arg1)->SelectObject((wxBitmap const &)*arg2);
17203
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 Py_INCREF(Py_None); resultobj = Py_None;
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17215 PyObject *obj;
17216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17217 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17218 Py_INCREF(obj);
17219 return Py_BuildValue((char *)"");
17220 }
17221 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17222 PyObject *resultobj;
17223 wxDC *arg1 = (wxDC *) 0 ;
17224 wxBitmap *arg2 = 0 ;
17225 wxBufferedDC *result;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228
17229 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17231 if (SWIG_arg_fail(1)) SWIG_fail;
17232 {
17233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(2)) SWIG_fail;
17235 if (arg2 == NULL) {
17236 SWIG_null_ref("wxBitmap");
17237 }
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 {
17241 if (!wxPyCheckForApp()) SWIG_fail;
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17256 PyObject *resultobj;
17257 wxDC *arg1 = (wxDC *) 0 ;
17258 wxSize *arg2 = 0 ;
17259 wxBufferedDC *result;
17260 wxSize temp2 ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263
17264 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = &temp2;
17269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17270 }
17271 {
17272 if (!wxPyCheckForApp()) SWIG_fail;
17273 PyThreadState* __tstate = wxPyBeginAllowThreads();
17274 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17275
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17287 int argc;
17288 PyObject *argv[3];
17289 int ii;
17290
17291 argc = PyObject_Length(args);
17292 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17293 argv[ii] = PyTuple_GetItem(args,ii);
17294 }
17295 if (argc == 2) {
17296 int _v;
17297 {
17298 void *ptr;
17299 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17300 _v = 0;
17301 PyErr_Clear();
17302 } else {
17303 _v = 1;
17304 }
17305 }
17306 if (_v) {
17307 {
17308 void *ptr = 0;
17309 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17310 _v = 0;
17311 PyErr_Clear();
17312 } else {
17313 _v = (ptr != 0);
17314 }
17315 }
17316 if (_v) {
17317 return _wrap_new_BufferedDC__SWIG_0(self,args);
17318 }
17319 }
17320 }
17321 if (argc == 2) {
17322 int _v;
17323 {
17324 void *ptr;
17325 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17326 _v = 0;
17327 PyErr_Clear();
17328 } else {
17329 _v = 1;
17330 }
17331 }
17332 if (_v) {
17333 {
17334 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17335 }
17336 if (_v) {
17337 return _wrap_new_BufferedDC__SWIG_1(self,args);
17338 }
17339 }
17340 }
17341
17342 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj;
17349 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17350 PyObject * obj0 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 delete arg1;
17361
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 Py_INCREF(Py_None); resultobj = Py_None;
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj;
17374 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17375 PyObject * obj0 = 0 ;
17376 char *kwnames[] = {
17377 (char *) "self", NULL
17378 };
17379
17380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17382 if (SWIG_arg_fail(1)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 (arg1)->UnMask();
17386
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 Py_INCREF(Py_None); resultobj = Py_None;
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17398 PyObject *obj;
17399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17400 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17401 Py_INCREF(obj);
17402 return Py_BuildValue((char *)"");
17403 }
17404 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj;
17406 wxWindow *arg1 = (wxWindow *) 0 ;
17407 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17408 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17409 wxBufferedPaintDC *result;
17410 PyObject * obj0 = 0 ;
17411 PyObject * obj1 = 0 ;
17412 char *kwnames[] = {
17413 (char *) "window",(char *) "buffer", NULL
17414 };
17415
17416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
17417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17418 if (SWIG_arg_fail(1)) SWIG_fail;
17419 if (obj1) {
17420 {
17421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17422 if (SWIG_arg_fail(2)) SWIG_fail;
17423 if (arg2 == NULL) {
17424 SWIG_null_ref("wxBitmap");
17425 }
17426 if (SWIG_arg_fail(2)) SWIG_fail;
17427 }
17428 }
17429 {
17430 if (!wxPyCheckForApp()) SWIG_fail;
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
17433
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17445 PyObject *obj;
17446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17447 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17448 Py_INCREF(obj);
17449 return Py_BuildValue((char *)"");
17450 }
17451 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxScreenDC *result;
17454 char *kwnames[] = {
17455 NULL
17456 };
17457
17458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17459 {
17460 if (!wxPyCheckForApp()) SWIG_fail;
17461 PyThreadState* __tstate = wxPyBeginAllowThreads();
17462 result = (wxScreenDC *)new wxScreenDC();
17463
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17475 PyObject *resultobj;
17476 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17477 wxWindow *arg2 = (wxWindow *) 0 ;
17478 bool result;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 char *kwnames[] = {
17482 (char *) "self",(char *) "window", NULL
17483 };
17484
17485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17487 if (SWIG_arg_fail(1)) SWIG_fail;
17488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17489 if (SWIG_arg_fail(2)) SWIG_fail;
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17493
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17509 wxRect *arg2 = (wxRect *) NULL ;
17510 bool result;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "rect", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 if (obj1) {
17521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17522 if (SWIG_arg_fail(2)) SWIG_fail;
17523 }
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17527
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 {
17532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17533 }
17534 return resultobj;
17535 fail:
17536 return NULL;
17537 }
17538
17539
17540 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17541 PyObject *resultobj;
17542 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17543 bool result;
17544 PyObject * obj0 = 0 ;
17545 char *kwnames[] = {
17546 (char *) "self", NULL
17547 };
17548
17549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(1)) SWIG_fail;
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)(arg1)->EndDrawingOnTop();
17555
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 {
17560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17561 }
17562 return resultobj;
17563 fail:
17564 return NULL;
17565 }
17566
17567
17568 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17569 PyObject *obj;
17570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17571 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17572 Py_INCREF(obj);
17573 return Py_BuildValue((char *)"");
17574 }
17575 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj;
17577 wxWindow *arg1 = (wxWindow *) 0 ;
17578 wxClientDC *result;
17579 PyObject * obj0 = 0 ;
17580 char *kwnames[] = {
17581 (char *) "win", NULL
17582 };
17583
17584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17586 if (SWIG_arg_fail(1)) SWIG_fail;
17587 {
17588 if (!wxPyCheckForApp()) SWIG_fail;
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxClientDC *)new wxClientDC(arg1);
17591
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17596 return resultobj;
17597 fail:
17598 return NULL;
17599 }
17600
17601
17602 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17603 PyObject *obj;
17604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17605 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17606 Py_INCREF(obj);
17607 return Py_BuildValue((char *)"");
17608 }
17609 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17610 PyObject *resultobj;
17611 wxWindow *arg1 = (wxWindow *) 0 ;
17612 wxPaintDC *result;
17613 PyObject * obj0 = 0 ;
17614 char *kwnames[] = {
17615 (char *) "win", NULL
17616 };
17617
17618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17620 if (SWIG_arg_fail(1)) SWIG_fail;
17621 {
17622 if (!wxPyCheckForApp()) SWIG_fail;
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (wxPaintDC *)new wxPaintDC(arg1);
17625
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17637 PyObject *obj;
17638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17639 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17640 Py_INCREF(obj);
17641 return Py_BuildValue((char *)"");
17642 }
17643 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17644 PyObject *resultobj;
17645 wxWindow *arg1 = (wxWindow *) 0 ;
17646 wxWindowDC *result;
17647 PyObject * obj0 = 0 ;
17648 char *kwnames[] = {
17649 (char *) "win", NULL
17650 };
17651
17652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(1)) SWIG_fail;
17655 {
17656 if (!wxPyCheckForApp()) SWIG_fail;
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (wxWindowDC *)new wxWindowDC(arg1);
17659
17660 wxPyEndAllowThreads(__tstate);
17661 if (PyErr_Occurred()) SWIG_fail;
17662 }
17663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17664 return resultobj;
17665 fail:
17666 return NULL;
17667 }
17668
17669
17670 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17671 PyObject *obj;
17672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17673 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17674 Py_INCREF(obj);
17675 return Py_BuildValue((char *)"");
17676 }
17677 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj;
17679 wxDC *arg1 = 0 ;
17680 bool arg2 ;
17681 wxMirrorDC *result;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "dc",(char *) "mirror", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17689 {
17690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17691 if (SWIG_arg_fail(1)) SWIG_fail;
17692 if (arg1 == NULL) {
17693 SWIG_null_ref("wxDC");
17694 }
17695 if (SWIG_arg_fail(1)) SWIG_fail;
17696 }
17697 {
17698 arg2 = (bool)(SWIG_As_bool(obj1));
17699 if (SWIG_arg_fail(2)) SWIG_fail;
17700 }
17701 {
17702 if (!wxPyCheckForApp()) SWIG_fail;
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17717 PyObject *obj;
17718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17719 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17720 Py_INCREF(obj);
17721 return Py_BuildValue((char *)"");
17722 }
17723 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxPrintData *arg1 = 0 ;
17726 wxPostScriptDC *result;
17727 PyObject * obj0 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "printData", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17733 {
17734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17735 if (SWIG_arg_fail(1)) SWIG_fail;
17736 if (arg1 == NULL) {
17737 SWIG_null_ref("wxPrintData");
17738 }
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 }
17741 {
17742 if (!wxPyCheckForApp()) SWIG_fail;
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj;
17758 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17759 wxPrintData *result;
17760 PyObject * obj0 = 0 ;
17761 char *kwnames[] = {
17762 (char *) "self", NULL
17763 };
17764
17765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 {
17771 wxPrintData &_result_ref = (arg1)->GetPrintData();
17772 result = (wxPrintData *) &_result_ref;
17773 }
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17779 return resultobj;
17780 fail:
17781 return NULL;
17782 }
17783
17784
17785 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17786 PyObject *resultobj;
17787 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17788 wxPrintData *arg2 = 0 ;
17789 PyObject * obj0 = 0 ;
17790 PyObject * obj1 = 0 ;
17791 char *kwnames[] = {
17792 (char *) "self",(char *) "data", NULL
17793 };
17794
17795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17797 if (SWIG_arg_fail(1)) SWIG_fail;
17798 {
17799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(2)) SWIG_fail;
17801 if (arg2 == NULL) {
17802 SWIG_null_ref("wxPrintData");
17803 }
17804 if (SWIG_arg_fail(2)) SWIG_fail;
17805 }
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17809
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 Py_INCREF(Py_None); resultobj = Py_None;
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17821 PyObject *resultobj;
17822 int arg1 ;
17823 PyObject * obj0 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "ppi", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17829 {
17830 arg1 = (int)(SWIG_As_int(obj0));
17831 if (SWIG_arg_fail(1)) SWIG_fail;
17832 }
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 wxPostScriptDC::SetResolution(arg1);
17836
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 Py_INCREF(Py_None); resultobj = Py_None;
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj;
17849 int result;
17850 char *kwnames[] = {
17851 NULL
17852 };
17853
17854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (int)wxPostScriptDC::GetResolution();
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 resultobj = SWIG_From_int((int)(result));
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17872 PyObject *obj;
17873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17874 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17875 Py_INCREF(obj);
17876 return Py_BuildValue((char *)"");
17877 }
17878 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17879 PyObject *resultobj;
17880 wxString const &arg1_defvalue = wxPyEmptyString ;
17881 wxString *arg1 = (wxString *) &arg1_defvalue ;
17882 wxMetaFile *result;
17883 bool temp1 = false ;
17884 PyObject * obj0 = 0 ;
17885 char *kwnames[] = {
17886 (char *) "filename", NULL
17887 };
17888
17889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17890 if (obj0) {
17891 {
17892 arg1 = wxString_in_helper(obj0);
17893 if (arg1 == NULL) SWIG_fail;
17894 temp1 = true;
17895 }
17896 }
17897 {
17898 if (!wxPyCheckForApp()) SWIG_fail;
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17901
17902 wxPyEndAllowThreads(__tstate);
17903 if (PyErr_Occurred()) SWIG_fail;
17904 }
17905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17906 {
17907 if (temp1)
17908 delete arg1;
17909 }
17910 return resultobj;
17911 fail:
17912 {
17913 if (temp1)
17914 delete arg1;
17915 }
17916 return NULL;
17917 }
17918
17919
17920 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17921 PyObject *obj;
17922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17923 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
17924 Py_INCREF(obj);
17925 return Py_BuildValue((char *)"");
17926 }
17927 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
17928 PyObject *resultobj;
17929 wxString const &arg1_defvalue = wxPyEmptyString ;
17930 wxString *arg1 = (wxString *) &arg1_defvalue ;
17931 int arg2 = (int) 0 ;
17932 int arg3 = (int) 0 ;
17933 wxString const &arg4_defvalue = wxPyEmptyString ;
17934 wxString *arg4 = (wxString *) &arg4_defvalue ;
17935 wxMetaFileDC *result;
17936 bool temp1 = false ;
17937 bool temp4 = false ;
17938 PyObject * obj0 = 0 ;
17939 PyObject * obj1 = 0 ;
17940 PyObject * obj2 = 0 ;
17941 PyObject * obj3 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17947 if (obj0) {
17948 {
17949 arg1 = wxString_in_helper(obj0);
17950 if (arg1 == NULL) SWIG_fail;
17951 temp1 = true;
17952 }
17953 }
17954 if (obj1) {
17955 {
17956 arg2 = (int)(SWIG_As_int(obj1));
17957 if (SWIG_arg_fail(2)) SWIG_fail;
17958 }
17959 }
17960 if (obj2) {
17961 {
17962 arg3 = (int)(SWIG_As_int(obj2));
17963 if (SWIG_arg_fail(3)) SWIG_fail;
17964 }
17965 }
17966 if (obj3) {
17967 {
17968 arg4 = wxString_in_helper(obj3);
17969 if (arg4 == NULL) SWIG_fail;
17970 temp4 = true;
17971 }
17972 }
17973 {
17974 if (!wxPyCheckForApp()) SWIG_fail;
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
17977
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
17982 {
17983 if (temp1)
17984 delete arg1;
17985 }
17986 {
17987 if (temp4)
17988 delete arg4;
17989 }
17990 return resultobj;
17991 fail:
17992 {
17993 if (temp1)
17994 delete arg1;
17995 }
17996 {
17997 if (temp4)
17998 delete arg4;
17999 }
18000 return NULL;
18001 }
18002
18003
18004 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18005 PyObject *obj;
18006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18007 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18008 Py_INCREF(obj);
18009 return Py_BuildValue((char *)"");
18010 }
18011 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18012 PyObject *resultobj;
18013 wxPrintData *arg1 = 0 ;
18014 wxPrinterDC *result;
18015 PyObject * obj0 = 0 ;
18016 char *kwnames[] = {
18017 (char *) "printData", NULL
18018 };
18019
18020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18021 {
18022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18023 if (SWIG_arg_fail(1)) SWIG_fail;
18024 if (arg1 == NULL) {
18025 SWIG_null_ref("wxPrintData");
18026 }
18027 if (SWIG_arg_fail(1)) SWIG_fail;
18028 }
18029 {
18030 if (!wxPyCheckForApp()) SWIG_fail;
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18033
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18045 PyObject *obj;
18046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18047 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18048 Py_INCREF(obj);
18049 return Py_BuildValue((char *)"");
18050 }
18051 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 int arg1 ;
18054 int arg2 ;
18055 int arg3 = (int) true ;
18056 int arg4 = (int) 1 ;
18057 wxImageList *result;
18058 PyObject * obj0 = 0 ;
18059 PyObject * obj1 = 0 ;
18060 PyObject * obj2 = 0 ;
18061 PyObject * obj3 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18067 {
18068 arg1 = (int)(SWIG_As_int(obj0));
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 }
18071 {
18072 arg2 = (int)(SWIG_As_int(obj1));
18073 if (SWIG_arg_fail(2)) SWIG_fail;
18074 }
18075 if (obj2) {
18076 {
18077 arg3 = (int)(SWIG_As_int(obj2));
18078 if (SWIG_arg_fail(3)) SWIG_fail;
18079 }
18080 }
18081 if (obj3) {
18082 {
18083 arg4 = (int)(SWIG_As_int(obj3));
18084 if (SWIG_arg_fail(4)) SWIG_fail;
18085 }
18086 }
18087 {
18088 if (!wxPyCheckForApp()) SWIG_fail;
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18091
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 {
18096 resultobj = wxPyMake_wxObject(result, 1);
18097 }
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18105 PyObject *resultobj;
18106 wxImageList *arg1 = (wxImageList *) 0 ;
18107 PyObject * obj0 = 0 ;
18108 char *kwnames[] = {
18109 (char *) "self", NULL
18110 };
18111
18112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 delete arg1;
18118
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 Py_INCREF(Py_None); resultobj = Py_None;
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj;
18131 wxImageList *arg1 = (wxImageList *) 0 ;
18132 wxBitmap *arg2 = 0 ;
18133 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18134 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18135 int result;
18136 PyObject * obj0 = 0 ;
18137 PyObject * obj1 = 0 ;
18138 PyObject * obj2 = 0 ;
18139 char *kwnames[] = {
18140 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18141 };
18142
18143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18145 if (SWIG_arg_fail(1)) SWIG_fail;
18146 {
18147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(2)) SWIG_fail;
18149 if (arg2 == NULL) {
18150 SWIG_null_ref("wxBitmap");
18151 }
18152 if (SWIG_arg_fail(2)) SWIG_fail;
18153 }
18154 if (obj2) {
18155 {
18156 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(3)) SWIG_fail;
18158 if (arg3 == NULL) {
18159 SWIG_null_ref("wxBitmap");
18160 }
18161 if (SWIG_arg_fail(3)) SWIG_fail;
18162 }
18163 }
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = SWIG_From_int((int)(result));
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj;
18182 wxImageList *arg1 = (wxImageList *) 0 ;
18183 wxBitmap *arg2 = 0 ;
18184 wxColour *arg3 = 0 ;
18185 int result;
18186 wxColour temp3 ;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 PyObject * obj2 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(2)) SWIG_fail;
18200 if (arg2 == NULL) {
18201 SWIG_null_ref("wxBitmap");
18202 }
18203 if (SWIG_arg_fail(2)) SWIG_fail;
18204 }
18205 {
18206 arg3 = &temp3;
18207 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18208 }
18209 {
18210 PyThreadState* __tstate = wxPyBeginAllowThreads();
18211 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18212
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 {
18217 resultobj = SWIG_From_int((int)(result));
18218 }
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj;
18227 wxImageList *arg1 = (wxImageList *) 0 ;
18228 wxIcon *arg2 = 0 ;
18229 int result;
18230 PyObject * obj0 = 0 ;
18231 PyObject * obj1 = 0 ;
18232 char *kwnames[] = {
18233 (char *) "self",(char *) "icon", NULL
18234 };
18235
18236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18238 if (SWIG_arg_fail(1)) SWIG_fail;
18239 {
18240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18241 if (SWIG_arg_fail(2)) SWIG_fail;
18242 if (arg2 == NULL) {
18243 SWIG_null_ref("wxIcon");
18244 }
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 }
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18250
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 {
18255 resultobj = SWIG_From_int((int)(result));
18256 }
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj;
18265 wxImageList *arg1 = (wxImageList *) 0 ;
18266 int arg2 ;
18267 wxBitmap *arg3 = 0 ;
18268 bool result;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 PyObject * obj2 = 0 ;
18272 char *kwnames[] = {
18273 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18274 };
18275
18276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 {
18280 arg2 = (int)(SWIG_As_int(obj1));
18281 if (SWIG_arg_fail(2)) SWIG_fail;
18282 }
18283 {
18284 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18285 if (SWIG_arg_fail(3)) SWIG_fail;
18286 if (arg3 == NULL) {
18287 SWIG_null_ref("wxBitmap");
18288 }
18289 if (SWIG_arg_fail(3)) SWIG_fail;
18290 }
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18294
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 {
18299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj;
18309 wxImageList *arg1 = (wxImageList *) 0 ;
18310 int arg2 ;
18311 wxDC *arg3 = 0 ;
18312 int arg4 ;
18313 int arg5 ;
18314 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18315 bool arg7 = (bool) (bool)false ;
18316 bool result;
18317 PyObject * obj0 = 0 ;
18318 PyObject * obj1 = 0 ;
18319 PyObject * obj2 = 0 ;
18320 PyObject * obj3 = 0 ;
18321 PyObject * obj4 = 0 ;
18322 PyObject * obj5 = 0 ;
18323 PyObject * obj6 = 0 ;
18324 char *kwnames[] = {
18325 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18326 };
18327
18328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18330 if (SWIG_arg_fail(1)) SWIG_fail;
18331 {
18332 arg2 = (int)(SWIG_As_int(obj1));
18333 if (SWIG_arg_fail(2)) SWIG_fail;
18334 }
18335 {
18336 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18337 if (SWIG_arg_fail(3)) SWIG_fail;
18338 if (arg3 == NULL) {
18339 SWIG_null_ref("wxDC");
18340 }
18341 if (SWIG_arg_fail(3)) SWIG_fail;
18342 }
18343 {
18344 arg4 = (int)(SWIG_As_int(obj3));
18345 if (SWIG_arg_fail(4)) SWIG_fail;
18346 }
18347 {
18348 arg5 = (int)(SWIG_As_int(obj4));
18349 if (SWIG_arg_fail(5)) SWIG_fail;
18350 }
18351 if (obj5) {
18352 {
18353 arg6 = (int)(SWIG_As_int(obj5));
18354 if (SWIG_arg_fail(6)) SWIG_fail;
18355 }
18356 }
18357 if (obj6) {
18358 {
18359 arg7 = (bool const)(SWIG_As_bool(obj6));
18360 if (SWIG_arg_fail(7)) SWIG_fail;
18361 }
18362 }
18363 {
18364 PyThreadState* __tstate = wxPyBeginAllowThreads();
18365 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18366
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 {
18371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18372 }
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18380 PyObject *resultobj;
18381 wxImageList *arg1 = (wxImageList *) 0 ;
18382 int result;
18383 PyObject * obj0 = 0 ;
18384 char *kwnames[] = {
18385 (char *) "self", NULL
18386 };
18387
18388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18390 if (SWIG_arg_fail(1)) SWIG_fail;
18391 {
18392 PyThreadState* __tstate = wxPyBeginAllowThreads();
18393 result = (int)(arg1)->GetImageCount();
18394
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 {
18399 resultobj = SWIG_From_int((int)(result));
18400 }
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj;
18409 wxImageList *arg1 = (wxImageList *) 0 ;
18410 int arg2 ;
18411 bool result;
18412 PyObject * obj0 = 0 ;
18413 PyObject * obj1 = 0 ;
18414 char *kwnames[] = {
18415 (char *) "self",(char *) "index", NULL
18416 };
18417
18418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18420 if (SWIG_arg_fail(1)) SWIG_fail;
18421 {
18422 arg2 = (int)(SWIG_As_int(obj1));
18423 if (SWIG_arg_fail(2)) SWIG_fail;
18424 }
18425 {
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (bool)(arg1)->Remove(arg2);
18428
18429 wxPyEndAllowThreads(__tstate);
18430 if (PyErr_Occurred()) SWIG_fail;
18431 }
18432 {
18433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18434 }
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj;
18443 wxImageList *arg1 = (wxImageList *) 0 ;
18444 bool result;
18445 PyObject * obj0 = 0 ;
18446 char *kwnames[] = {
18447 (char *) "self", NULL
18448 };
18449
18450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18452 if (SWIG_arg_fail(1)) SWIG_fail;
18453 {
18454 PyThreadState* __tstate = wxPyBeginAllowThreads();
18455 result = (bool)(arg1)->RemoveAll();
18456
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 {
18461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18462 }
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18470 PyObject *resultobj;
18471 wxImageList *arg1 = (wxImageList *) 0 ;
18472 int arg2 ;
18473 int *arg3 = 0 ;
18474 int *arg4 = 0 ;
18475 int temp3 ;
18476 int res3 = 0 ;
18477 int temp4 ;
18478 int res4 = 0 ;
18479 PyObject * obj0 = 0 ;
18480 PyObject * obj1 = 0 ;
18481 char *kwnames[] = {
18482 (char *) "self",(char *) "index", NULL
18483 };
18484
18485 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18486 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 {
18491 arg2 = (int)(SWIG_As_int(obj1));
18492 if (SWIG_arg_fail(2)) SWIG_fail;
18493 }
18494 {
18495 PyThreadState* __tstate = wxPyBeginAllowThreads();
18496 (arg1)->GetSize(arg2,*arg3,*arg4);
18497
18498 wxPyEndAllowThreads(__tstate);
18499 if (PyErr_Occurred()) SWIG_fail;
18500 }
18501 Py_INCREF(Py_None); resultobj = Py_None;
18502 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18503 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18504 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18505 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18513 PyObject *obj;
18514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18515 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18516 Py_INCREF(obj);
18517 return Py_BuildValue((char *)"");
18518 }
18519 static int _wrap_NORMAL_FONT_set(PyObject *) {
18520 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18521 return 1;
18522 }
18523
18524
18525 static PyObject *_wrap_NORMAL_FONT_get(void) {
18526 PyObject *pyobj;
18527
18528 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18529 return pyobj;
18530 }
18531
18532
18533 static int _wrap_SMALL_FONT_set(PyObject *) {
18534 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18535 return 1;
18536 }
18537
18538
18539 static PyObject *_wrap_SMALL_FONT_get(void) {
18540 PyObject *pyobj;
18541
18542 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18543 return pyobj;
18544 }
18545
18546
18547 static int _wrap_ITALIC_FONT_set(PyObject *) {
18548 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18549 return 1;
18550 }
18551
18552
18553 static PyObject *_wrap_ITALIC_FONT_get(void) {
18554 PyObject *pyobj;
18555
18556 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18557 return pyobj;
18558 }
18559
18560
18561 static int _wrap_SWISS_FONT_set(PyObject *) {
18562 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18563 return 1;
18564 }
18565
18566
18567 static PyObject *_wrap_SWISS_FONT_get(void) {
18568 PyObject *pyobj;
18569
18570 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18571 return pyobj;
18572 }
18573
18574
18575 static int _wrap_RED_PEN_set(PyObject *) {
18576 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18577 return 1;
18578 }
18579
18580
18581 static PyObject *_wrap_RED_PEN_get(void) {
18582 PyObject *pyobj;
18583
18584 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18585 return pyobj;
18586 }
18587
18588
18589 static int _wrap_CYAN_PEN_set(PyObject *) {
18590 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18591 return 1;
18592 }
18593
18594
18595 static PyObject *_wrap_CYAN_PEN_get(void) {
18596 PyObject *pyobj;
18597
18598 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18599 return pyobj;
18600 }
18601
18602
18603 static int _wrap_GREEN_PEN_set(PyObject *) {
18604 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18605 return 1;
18606 }
18607
18608
18609 static PyObject *_wrap_GREEN_PEN_get(void) {
18610 PyObject *pyobj;
18611
18612 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18613 return pyobj;
18614 }
18615
18616
18617 static int _wrap_BLACK_PEN_set(PyObject *) {
18618 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18619 return 1;
18620 }
18621
18622
18623 static PyObject *_wrap_BLACK_PEN_get(void) {
18624 PyObject *pyobj;
18625
18626 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18627 return pyobj;
18628 }
18629
18630
18631 static int _wrap_WHITE_PEN_set(PyObject *) {
18632 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18633 return 1;
18634 }
18635
18636
18637 static PyObject *_wrap_WHITE_PEN_get(void) {
18638 PyObject *pyobj;
18639
18640 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18641 return pyobj;
18642 }
18643
18644
18645 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18646 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18647 return 1;
18648 }
18649
18650
18651 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18652 PyObject *pyobj;
18653
18654 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18655 return pyobj;
18656 }
18657
18658
18659 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18660 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18661 return 1;
18662 }
18663
18664
18665 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18666 PyObject *pyobj;
18667
18668 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18669 return pyobj;
18670 }
18671
18672
18673 static int _wrap_GREY_PEN_set(PyObject *) {
18674 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18675 return 1;
18676 }
18677
18678
18679 static PyObject *_wrap_GREY_PEN_get(void) {
18680 PyObject *pyobj;
18681
18682 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18683 return pyobj;
18684 }
18685
18686
18687 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18688 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18689 return 1;
18690 }
18691
18692
18693 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18694 PyObject *pyobj;
18695
18696 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18697 return pyobj;
18698 }
18699
18700
18701 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18702 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18703 return 1;
18704 }
18705
18706
18707 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18708 PyObject *pyobj;
18709
18710 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18711 return pyobj;
18712 }
18713
18714
18715 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18716 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18717 return 1;
18718 }
18719
18720
18721 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18722 PyObject *pyobj;
18723
18724 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18725 return pyobj;
18726 }
18727
18728
18729 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18730 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18731 return 1;
18732 }
18733
18734
18735 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18736 PyObject *pyobj;
18737
18738 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18739 return pyobj;
18740 }
18741
18742
18743 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18744 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18745 return 1;
18746 }
18747
18748
18749 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18750 PyObject *pyobj;
18751
18752 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18753 return pyobj;
18754 }
18755
18756
18757 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18758 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18759 return 1;
18760 }
18761
18762
18763 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18764 PyObject *pyobj;
18765
18766 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18767 return pyobj;
18768 }
18769
18770
18771 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18772 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18773 return 1;
18774 }
18775
18776
18777 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18778 PyObject *pyobj;
18779
18780 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18781 return pyobj;
18782 }
18783
18784
18785 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18786 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18787 return 1;
18788 }
18789
18790
18791 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18792 PyObject *pyobj;
18793
18794 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18795 return pyobj;
18796 }
18797
18798
18799 static int _wrap_RED_BRUSH_set(PyObject *) {
18800 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18801 return 1;
18802 }
18803
18804
18805 static PyObject *_wrap_RED_BRUSH_get(void) {
18806 PyObject *pyobj;
18807
18808 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18809 return pyobj;
18810 }
18811
18812
18813 static int _wrap_GREY_BRUSH_set(PyObject *) {
18814 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18815 return 1;
18816 }
18817
18818
18819 static PyObject *_wrap_GREY_BRUSH_get(void) {
18820 PyObject *pyobj;
18821
18822 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18823 return pyobj;
18824 }
18825
18826
18827 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18828 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18829 return 1;
18830 }
18831
18832
18833 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18834 PyObject *pyobj;
18835
18836 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18837 return pyobj;
18838 }
18839
18840
18841 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18842 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18843 return 1;
18844 }
18845
18846
18847 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18848 PyObject *pyobj;
18849
18850 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18851 return pyobj;
18852 }
18853
18854
18855 static int _wrap_BLACK_set(PyObject *) {
18856 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
18857 return 1;
18858 }
18859
18860
18861 static PyObject *_wrap_BLACK_get(void) {
18862 PyObject *pyobj;
18863
18864 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
18865 return pyobj;
18866 }
18867
18868
18869 static int _wrap_WHITE_set(PyObject *) {
18870 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
18871 return 1;
18872 }
18873
18874
18875 static PyObject *_wrap_WHITE_get(void) {
18876 PyObject *pyobj;
18877
18878 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
18879 return pyobj;
18880 }
18881
18882
18883 static int _wrap_RED_set(PyObject *) {
18884 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
18885 return 1;
18886 }
18887
18888
18889 static PyObject *_wrap_RED_get(void) {
18890 PyObject *pyobj;
18891
18892 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
18893 return pyobj;
18894 }
18895
18896
18897 static int _wrap_BLUE_set(PyObject *) {
18898 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
18899 return 1;
18900 }
18901
18902
18903 static PyObject *_wrap_BLUE_get(void) {
18904 PyObject *pyobj;
18905
18906 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
18907 return pyobj;
18908 }
18909
18910
18911 static int _wrap_GREEN_set(PyObject *) {
18912 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
18913 return 1;
18914 }
18915
18916
18917 static PyObject *_wrap_GREEN_get(void) {
18918 PyObject *pyobj;
18919
18920 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
18921 return pyobj;
18922 }
18923
18924
18925 static int _wrap_CYAN_set(PyObject *) {
18926 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
18927 return 1;
18928 }
18929
18930
18931 static PyObject *_wrap_CYAN_get(void) {
18932 PyObject *pyobj;
18933
18934 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
18935 return pyobj;
18936 }
18937
18938
18939 static int _wrap_LIGHT_GREY_set(PyObject *) {
18940 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
18941 return 1;
18942 }
18943
18944
18945 static PyObject *_wrap_LIGHT_GREY_get(void) {
18946 PyObject *pyobj;
18947
18948 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
18949 return pyobj;
18950 }
18951
18952
18953 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
18954 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
18955 return 1;
18956 }
18957
18958
18959 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
18960 PyObject *pyobj;
18961
18962 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
18963 return pyobj;
18964 }
18965
18966
18967 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
18968 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
18969 return 1;
18970 }
18971
18972
18973 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
18974 PyObject *pyobj;
18975
18976 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
18977 return pyobj;
18978 }
18979
18980
18981 static int _wrap_CROSS_CURSOR_set(PyObject *) {
18982 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
18983 return 1;
18984 }
18985
18986
18987 static PyObject *_wrap_CROSS_CURSOR_get(void) {
18988 PyObject *pyobj;
18989
18990 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
18991 return pyobj;
18992 }
18993
18994
18995 static int _wrap_NullBitmap_set(PyObject *) {
18996 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
18997 return 1;
18998 }
18999
19000
19001 static PyObject *_wrap_NullBitmap_get(void) {
19002 PyObject *pyobj;
19003
19004 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19005 return pyobj;
19006 }
19007
19008
19009 static int _wrap_NullIcon_set(PyObject *) {
19010 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19011 return 1;
19012 }
19013
19014
19015 static PyObject *_wrap_NullIcon_get(void) {
19016 PyObject *pyobj;
19017
19018 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19019 return pyobj;
19020 }
19021
19022
19023 static int _wrap_NullCursor_set(PyObject *) {
19024 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19025 return 1;
19026 }
19027
19028
19029 static PyObject *_wrap_NullCursor_get(void) {
19030 PyObject *pyobj;
19031
19032 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19033 return pyobj;
19034 }
19035
19036
19037 static int _wrap_NullPen_set(PyObject *) {
19038 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19039 return 1;
19040 }
19041
19042
19043 static PyObject *_wrap_NullPen_get(void) {
19044 PyObject *pyobj;
19045
19046 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19047 return pyobj;
19048 }
19049
19050
19051 static int _wrap_NullBrush_set(PyObject *) {
19052 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19053 return 1;
19054 }
19055
19056
19057 static PyObject *_wrap_NullBrush_get(void) {
19058 PyObject *pyobj;
19059
19060 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19061 return pyobj;
19062 }
19063
19064
19065 static int _wrap_NullPalette_set(PyObject *) {
19066 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19067 return 1;
19068 }
19069
19070
19071 static PyObject *_wrap_NullPalette_get(void) {
19072 PyObject *pyobj;
19073
19074 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19075 return pyobj;
19076 }
19077
19078
19079 static int _wrap_NullFont_set(PyObject *) {
19080 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19081 return 1;
19082 }
19083
19084
19085 static PyObject *_wrap_NullFont_get(void) {
19086 PyObject *pyobj;
19087
19088 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19089 return pyobj;
19090 }
19091
19092
19093 static int _wrap_NullColour_set(PyObject *) {
19094 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19095 return 1;
19096 }
19097
19098
19099 static PyObject *_wrap_NullColour_get(void) {
19100 PyObject *pyobj;
19101
19102 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19103 return pyobj;
19104 }
19105
19106
19107 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj;
19109 wxPenList *arg1 = (wxPenList *) 0 ;
19110 wxPen *arg2 = (wxPen *) 0 ;
19111 PyObject * obj0 = 0 ;
19112 PyObject * obj1 = 0 ;
19113 char *kwnames[] = {
19114 (char *) "self",(char *) "pen", NULL
19115 };
19116
19117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19119 if (SWIG_arg_fail(1)) SWIG_fail;
19120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19121 if (SWIG_arg_fail(2)) SWIG_fail;
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->AddPen(arg2);
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 Py_INCREF(Py_None); resultobj = Py_None;
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj;
19138 wxPenList *arg1 = (wxPenList *) 0 ;
19139 wxColour *arg2 = 0 ;
19140 int arg3 ;
19141 int arg4 ;
19142 wxPen *result;
19143 wxColour temp2 ;
19144 PyObject * obj0 = 0 ;
19145 PyObject * obj1 = 0 ;
19146 PyObject * obj2 = 0 ;
19147 PyObject * obj3 = 0 ;
19148 char *kwnames[] = {
19149 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19150 };
19151
19152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19154 if (SWIG_arg_fail(1)) SWIG_fail;
19155 {
19156 arg2 = &temp2;
19157 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19158 }
19159 {
19160 arg3 = (int)(SWIG_As_int(obj2));
19161 if (SWIG_arg_fail(3)) SWIG_fail;
19162 }
19163 {
19164 arg4 = (int)(SWIG_As_int(obj3));
19165 if (SWIG_arg_fail(4)) SWIG_fail;
19166 }
19167 {
19168 PyThreadState* __tstate = wxPyBeginAllowThreads();
19169 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19170
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj;
19183 wxPenList *arg1 = (wxPenList *) 0 ;
19184 wxPen *arg2 = (wxPen *) 0 ;
19185 PyObject * obj0 = 0 ;
19186 PyObject * obj1 = 0 ;
19187 char *kwnames[] = {
19188 (char *) "self",(char *) "pen", NULL
19189 };
19190
19191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(1)) SWIG_fail;
19194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(2)) SWIG_fail;
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 (arg1)->RemovePen(arg2);
19199
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 Py_INCREF(Py_None); resultobj = Py_None;
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj;
19212 wxPenList *arg1 = (wxPenList *) 0 ;
19213 int result;
19214 PyObject * obj0 = 0 ;
19215 char *kwnames[] = {
19216 (char *) "self", NULL
19217 };
19218
19219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)(arg1)->GetCount();
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = SWIG_From_int((int)(result));
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19239 PyObject *obj;
19240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19241 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19242 Py_INCREF(obj);
19243 return Py_BuildValue((char *)"");
19244 }
19245 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 wxBrushList *arg1 = (wxBrushList *) 0 ;
19248 wxBrush *arg2 = (wxBrush *) 0 ;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "self",(char *) "brush", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19257 if (SWIG_arg_fail(1)) SWIG_fail;
19258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19259 if (SWIG_arg_fail(2)) SWIG_fail;
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 (arg1)->AddBrush(arg2);
19263
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 Py_INCREF(Py_None); resultobj = Py_None;
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19275 PyObject *resultobj;
19276 wxBrushList *arg1 = (wxBrushList *) 0 ;
19277 wxColour *arg2 = 0 ;
19278 int arg3 ;
19279 wxBrush *result;
19280 wxColour temp2 ;
19281 PyObject * obj0 = 0 ;
19282 PyObject * obj1 = 0 ;
19283 PyObject * obj2 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "self",(char *) "colour",(char *) "style", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19290 if (SWIG_arg_fail(1)) SWIG_fail;
19291 {
19292 arg2 = &temp2;
19293 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19294 }
19295 {
19296 arg3 = (int)(SWIG_As_int(obj2));
19297 if (SWIG_arg_fail(3)) SWIG_fail;
19298 }
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19302
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 wxBrushList *arg1 = (wxBrushList *) 0 ;
19316 wxBrush *arg2 = (wxBrush *) 0 ;
19317 PyObject * obj0 = 0 ;
19318 PyObject * obj1 = 0 ;
19319 char *kwnames[] = {
19320 (char *) "self",(char *) "brush", NULL
19321 };
19322
19323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19327 if (SWIG_arg_fail(2)) SWIG_fail;
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 (arg1)->RemoveBrush(arg2);
19331
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 Py_INCREF(Py_None); resultobj = Py_None;
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj;
19344 wxBrushList *arg1 = (wxBrushList *) 0 ;
19345 int result;
19346 PyObject * obj0 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "self", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19353 if (SWIG_arg_fail(1)) SWIG_fail;
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = (int)(arg1)->GetCount();
19357
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 resultobj = SWIG_From_int((int)(result));
19363 }
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19371 PyObject *obj;
19372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19373 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19374 Py_INCREF(obj);
19375 return Py_BuildValue((char *)"");
19376 }
19377 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19378 PyObject *resultobj;
19379 wxColourDatabase *result;
19380 char *kwnames[] = {
19381 NULL
19382 };
19383
19384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19385 {
19386 if (!wxPyCheckForApp()) SWIG_fail;
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 result = (wxColourDatabase *)new wxColourDatabase();
19389
19390 wxPyEndAllowThreads(__tstate);
19391 if (PyErr_Occurred()) SWIG_fail;
19392 }
19393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19401 PyObject *resultobj;
19402 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19403 PyObject * obj0 = 0 ;
19404 char *kwnames[] = {
19405 (char *) "self", NULL
19406 };
19407
19408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19410 if (SWIG_arg_fail(1)) SWIG_fail;
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 delete arg1;
19414
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 Py_INCREF(Py_None); resultobj = Py_None;
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19426 PyObject *resultobj;
19427 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19428 wxString *arg2 = 0 ;
19429 wxColour result;
19430 bool temp2 = false ;
19431 PyObject * obj0 = 0 ;
19432 PyObject * obj1 = 0 ;
19433 char *kwnames[] = {
19434 (char *) "self",(char *) "name", NULL
19435 };
19436
19437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19439 if (SWIG_arg_fail(1)) SWIG_fail;
19440 {
19441 arg2 = wxString_in_helper(obj1);
19442 if (arg2 == NULL) SWIG_fail;
19443 temp2 = true;
19444 }
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19448
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 {
19453 wxColour * resultptr;
19454 resultptr = new wxColour((wxColour &)(result));
19455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19456 }
19457 {
19458 if (temp2)
19459 delete arg2;
19460 }
19461 return resultobj;
19462 fail:
19463 {
19464 if (temp2)
19465 delete arg2;
19466 }
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj;
19473 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19474 wxColour *arg2 = 0 ;
19475 wxString result;
19476 wxColour temp2 ;
19477 PyObject * obj0 = 0 ;
19478 PyObject * obj1 = 0 ;
19479 char *kwnames[] = {
19480 (char *) "self",(char *) "colour", NULL
19481 };
19482
19483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19485 if (SWIG_arg_fail(1)) SWIG_fail;
19486 {
19487 arg2 = &temp2;
19488 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19493
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 #if wxUSE_UNICODE
19499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19500 #else
19501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19502 #endif
19503 }
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj;
19512 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19513 wxString *arg2 = 0 ;
19514 wxColour *arg3 = 0 ;
19515 bool temp2 = false ;
19516 wxColour temp3 ;
19517 PyObject * obj0 = 0 ;
19518 PyObject * obj1 = 0 ;
19519 PyObject * obj2 = 0 ;
19520 char *kwnames[] = {
19521 (char *) "self",(char *) "name",(char *) "colour", NULL
19522 };
19523
19524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 {
19528 arg2 = wxString_in_helper(obj1);
19529 if (arg2 == NULL) SWIG_fail;
19530 temp2 = true;
19531 }
19532 {
19533 arg3 = &temp3;
19534 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19535 }
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19539
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 Py_INCREF(Py_None); resultobj = Py_None;
19544 {
19545 if (temp2)
19546 delete arg2;
19547 }
19548 return resultobj;
19549 fail:
19550 {
19551 if (temp2)
19552 delete arg2;
19553 }
19554 return NULL;
19555 }
19556
19557
19558 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj;
19560 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19561 wxString *arg2 = 0 ;
19562 int arg3 ;
19563 int arg4 ;
19564 int arg5 ;
19565 bool temp2 = false ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 PyObject * obj2 = 0 ;
19569 PyObject * obj3 = 0 ;
19570 PyObject * obj4 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 arg2 = wxString_in_helper(obj1);
19580 if (arg2 == NULL) SWIG_fail;
19581 temp2 = true;
19582 }
19583 {
19584 arg3 = (int)(SWIG_As_int(obj2));
19585 if (SWIG_arg_fail(3)) SWIG_fail;
19586 }
19587 {
19588 arg4 = (int)(SWIG_As_int(obj3));
19589 if (SWIG_arg_fail(4)) SWIG_fail;
19590 }
19591 {
19592 arg5 = (int)(SWIG_As_int(obj4));
19593 if (SWIG_arg_fail(5)) SWIG_fail;
19594 }
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 Py_INCREF(Py_None); resultobj = Py_None;
19603 {
19604 if (temp2)
19605 delete arg2;
19606 }
19607 return resultobj;
19608 fail:
19609 {
19610 if (temp2)
19611 delete arg2;
19612 }
19613 return NULL;
19614 }
19615
19616
19617 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19618 PyObject *obj;
19619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19620 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19621 Py_INCREF(obj);
19622 return Py_BuildValue((char *)"");
19623 }
19624 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj;
19626 wxFontList *arg1 = (wxFontList *) 0 ;
19627 wxFont *arg2 = (wxFont *) 0 ;
19628 PyObject * obj0 = 0 ;
19629 PyObject * obj1 = 0 ;
19630 char *kwnames[] = {
19631 (char *) "self",(char *) "font", NULL
19632 };
19633
19634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19636 if (SWIG_arg_fail(1)) SWIG_fail;
19637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19638 if (SWIG_arg_fail(2)) SWIG_fail;
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 (arg1)->AddFont(arg2);
19642
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 Py_INCREF(Py_None); resultobj = Py_None;
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj;
19655 wxFontList *arg1 = (wxFontList *) 0 ;
19656 int arg2 ;
19657 int arg3 ;
19658 int arg4 ;
19659 int arg5 ;
19660 bool arg6 = (bool) false ;
19661 wxString const &arg7_defvalue = wxPyEmptyString ;
19662 wxString *arg7 = (wxString *) &arg7_defvalue ;
19663 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19664 wxFont *result;
19665 bool temp7 = false ;
19666 PyObject * obj0 = 0 ;
19667 PyObject * obj1 = 0 ;
19668 PyObject * obj2 = 0 ;
19669 PyObject * obj3 = 0 ;
19670 PyObject * obj4 = 0 ;
19671 PyObject * obj5 = 0 ;
19672 PyObject * obj6 = 0 ;
19673 PyObject * obj7 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19680 if (SWIG_arg_fail(1)) SWIG_fail;
19681 {
19682 arg2 = (int)(SWIG_As_int(obj1));
19683 if (SWIG_arg_fail(2)) SWIG_fail;
19684 }
19685 {
19686 arg3 = (int)(SWIG_As_int(obj2));
19687 if (SWIG_arg_fail(3)) SWIG_fail;
19688 }
19689 {
19690 arg4 = (int)(SWIG_As_int(obj3));
19691 if (SWIG_arg_fail(4)) SWIG_fail;
19692 }
19693 {
19694 arg5 = (int)(SWIG_As_int(obj4));
19695 if (SWIG_arg_fail(5)) SWIG_fail;
19696 }
19697 if (obj5) {
19698 {
19699 arg6 = (bool)(SWIG_As_bool(obj5));
19700 if (SWIG_arg_fail(6)) SWIG_fail;
19701 }
19702 }
19703 if (obj6) {
19704 {
19705 arg7 = wxString_in_helper(obj6);
19706 if (arg7 == NULL) SWIG_fail;
19707 temp7 = true;
19708 }
19709 }
19710 if (obj7) {
19711 {
19712 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19713 if (SWIG_arg_fail(8)) SWIG_fail;
19714 }
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19719
19720 wxPyEndAllowThreads(__tstate);
19721 if (PyErr_Occurred()) SWIG_fail;
19722 }
19723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19724 {
19725 if (temp7)
19726 delete arg7;
19727 }
19728 return resultobj;
19729 fail:
19730 {
19731 if (temp7)
19732 delete arg7;
19733 }
19734 return NULL;
19735 }
19736
19737
19738 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj;
19740 wxFontList *arg1 = (wxFontList *) 0 ;
19741 wxFont *arg2 = (wxFont *) 0 ;
19742 PyObject * obj0 = 0 ;
19743 PyObject * obj1 = 0 ;
19744 char *kwnames[] = {
19745 (char *) "self",(char *) "font", NULL
19746 };
19747
19748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19750 if (SWIG_arg_fail(1)) SWIG_fail;
19751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19752 if (SWIG_arg_fail(2)) SWIG_fail;
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 (arg1)->RemoveFont(arg2);
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 Py_INCREF(Py_None); resultobj = Py_None;
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj;
19769 wxFontList *arg1 = (wxFontList *) 0 ;
19770 int result;
19771 PyObject * obj0 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "self", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19778 if (SWIG_arg_fail(1)) SWIG_fail;
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 result = (int)(arg1)->GetCount();
19782
19783 wxPyEndAllowThreads(__tstate);
19784 if (PyErr_Occurred()) SWIG_fail;
19785 }
19786 {
19787 resultobj = SWIG_From_int((int)(result));
19788 }
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19796 PyObject *obj;
19797 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19798 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19799 Py_INCREF(obj);
19800 return Py_BuildValue((char *)"");
19801 }
19802 static int _wrap_TheFontList_set(PyObject *) {
19803 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19804 return 1;
19805 }
19806
19807
19808 static PyObject *_wrap_TheFontList_get(void) {
19809 PyObject *pyobj;
19810
19811 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19812 return pyobj;
19813 }
19814
19815
19816 static int _wrap_ThePenList_set(PyObject *) {
19817 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19818 return 1;
19819 }
19820
19821
19822 static PyObject *_wrap_ThePenList_get(void) {
19823 PyObject *pyobj;
19824
19825 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19826 return pyobj;
19827 }
19828
19829
19830 static int _wrap_TheBrushList_set(PyObject *) {
19831 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19832 return 1;
19833 }
19834
19835
19836 static PyObject *_wrap_TheBrushList_get(void) {
19837 PyObject *pyobj;
19838
19839 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19840 return pyobj;
19841 }
19842
19843
19844 static int _wrap_TheColourDatabase_set(PyObject *) {
19845 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19846 return 1;
19847 }
19848
19849
19850 static PyObject *_wrap_TheColourDatabase_get(void) {
19851 PyObject *pyobj;
19852
19853 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
19854 return pyobj;
19855 }
19856
19857
19858 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
19859 PyObject *resultobj;
19860 wxEffects *result;
19861 char *kwnames[] = {
19862 NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
19866 {
19867 PyThreadState* __tstate = wxPyBeginAllowThreads();
19868 result = (wxEffects *)new wxEffects();
19869
19870 wxPyEndAllowThreads(__tstate);
19871 if (PyErr_Occurred()) SWIG_fail;
19872 }
19873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
19874 return resultobj;
19875 fail:
19876 return NULL;
19877 }
19878
19879
19880 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
19881 PyObject *resultobj;
19882 wxEffects *arg1 = (wxEffects *) 0 ;
19883 wxColour result;
19884 PyObject * obj0 = 0 ;
19885 char *kwnames[] = {
19886 (char *) "self", NULL
19887 };
19888
19889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
19890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19891 if (SWIG_arg_fail(1)) SWIG_fail;
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 result = ((wxEffects const *)arg1)->GetHighlightColour();
19895
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 {
19900 wxColour * resultptr;
19901 resultptr = new wxColour((wxColour &)(result));
19902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19903 }
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj;
19912 wxEffects *arg1 = (wxEffects *) 0 ;
19913 wxColour result;
19914 PyObject * obj0 = 0 ;
19915 char *kwnames[] = {
19916 (char *) "self", NULL
19917 };
19918
19919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
19920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19921 if (SWIG_arg_fail(1)) SWIG_fail;
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 result = ((wxEffects const *)arg1)->GetLightShadow();
19925
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 {
19930 wxColour * resultptr;
19931 resultptr = new wxColour((wxColour &)(result));
19932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19933 }
19934 return resultobj;
19935 fail:
19936 return NULL;
19937 }
19938
19939
19940 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
19941 PyObject *resultobj;
19942 wxEffects *arg1 = (wxEffects *) 0 ;
19943 wxColour result;
19944 PyObject * obj0 = 0 ;
19945 char *kwnames[] = {
19946 (char *) "self", NULL
19947 };
19948
19949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
19950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19951 if (SWIG_arg_fail(1)) SWIG_fail;
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = ((wxEffects const *)arg1)->GetFaceColour();
19955
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 {
19960 wxColour * resultptr;
19961 resultptr = new wxColour((wxColour &)(result));
19962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19963 }
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19971 PyObject *resultobj;
19972 wxEffects *arg1 = (wxEffects *) 0 ;
19973 wxColour result;
19974 PyObject * obj0 = 0 ;
19975 char *kwnames[] = {
19976 (char *) "self", NULL
19977 };
19978
19979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
19980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19981 if (SWIG_arg_fail(1)) SWIG_fail;
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = ((wxEffects const *)arg1)->GetMediumShadow();
19985
19986 wxPyEndAllowThreads(__tstate);
19987 if (PyErr_Occurred()) SWIG_fail;
19988 }
19989 {
19990 wxColour * resultptr;
19991 resultptr = new wxColour((wxColour &)(result));
19992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19993 }
19994 return resultobj;
19995 fail:
19996 return NULL;
19997 }
19998
19999
20000 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20001 PyObject *resultobj;
20002 wxEffects *arg1 = (wxEffects *) 0 ;
20003 wxColour result;
20004 PyObject * obj0 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "self", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20011 if (SWIG_arg_fail(1)) SWIG_fail;
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = ((wxEffects const *)arg1)->GetDarkShadow();
20015
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 {
20020 wxColour * resultptr;
20021 resultptr = new wxColour((wxColour &)(result));
20022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20023 }
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxEffects *arg1 = (wxEffects *) 0 ;
20033 wxColour *arg2 = 0 ;
20034 wxColour temp2 ;
20035 PyObject * obj0 = 0 ;
20036 PyObject * obj1 = 0 ;
20037 char *kwnames[] = {
20038 (char *) "self",(char *) "c", NULL
20039 };
20040
20041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20043 if (SWIG_arg_fail(1)) SWIG_fail;
20044 {
20045 arg2 = &temp2;
20046 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20051
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 Py_INCREF(Py_None); resultobj = Py_None;
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxEffects *arg1 = (wxEffects *) 0 ;
20065 wxColour *arg2 = 0 ;
20066 wxColour temp2 ;
20067 PyObject * obj0 = 0 ;
20068 PyObject * obj1 = 0 ;
20069 char *kwnames[] = {
20070 (char *) "self",(char *) "c", NULL
20071 };
20072
20073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20075 if (SWIG_arg_fail(1)) SWIG_fail;
20076 {
20077 arg2 = &temp2;
20078 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20079 }
20080 {
20081 PyThreadState* __tstate = wxPyBeginAllowThreads();
20082 (arg1)->SetLightShadow((wxColour const &)*arg2);
20083
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 Py_INCREF(Py_None); resultobj = Py_None;
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj;
20096 wxEffects *arg1 = (wxEffects *) 0 ;
20097 wxColour *arg2 = 0 ;
20098 wxColour temp2 ;
20099 PyObject * obj0 = 0 ;
20100 PyObject * obj1 = 0 ;
20101 char *kwnames[] = {
20102 (char *) "self",(char *) "c", NULL
20103 };
20104
20105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20107 if (SWIG_arg_fail(1)) SWIG_fail;
20108 {
20109 arg2 = &temp2;
20110 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20111 }
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 (arg1)->SetFaceColour((wxColour const &)*arg2);
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 Py_INCREF(Py_None); resultobj = Py_None;
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20127 PyObject *resultobj;
20128 wxEffects *arg1 = (wxEffects *) 0 ;
20129 wxColour *arg2 = 0 ;
20130 wxColour temp2 ;
20131 PyObject * obj0 = 0 ;
20132 PyObject * obj1 = 0 ;
20133 char *kwnames[] = {
20134 (char *) "self",(char *) "c", NULL
20135 };
20136
20137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20139 if (SWIG_arg_fail(1)) SWIG_fail;
20140 {
20141 arg2 = &temp2;
20142 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 Py_INCREF(Py_None); resultobj = Py_None;
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20159 PyObject *resultobj;
20160 wxEffects *arg1 = (wxEffects *) 0 ;
20161 wxColour *arg2 = 0 ;
20162 wxColour temp2 ;
20163 PyObject * obj0 = 0 ;
20164 PyObject * obj1 = 0 ;
20165 char *kwnames[] = {
20166 (char *) "self",(char *) "c", NULL
20167 };
20168
20169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20171 if (SWIG_arg_fail(1)) SWIG_fail;
20172 {
20173 arg2 = &temp2;
20174 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20175 }
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20179
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 Py_INCREF(Py_None); resultobj = Py_None;
20184 return resultobj;
20185 fail:
20186 return NULL;
20187 }
20188
20189
20190 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20191 PyObject *resultobj;
20192 wxEffects *arg1 = (wxEffects *) 0 ;
20193 wxColour *arg2 = 0 ;
20194 wxColour *arg3 = 0 ;
20195 wxColour *arg4 = 0 ;
20196 wxColour *arg5 = 0 ;
20197 wxColour *arg6 = 0 ;
20198 wxColour temp2 ;
20199 wxColour temp3 ;
20200 wxColour temp4 ;
20201 wxColour temp5 ;
20202 wxColour temp6 ;
20203 PyObject * obj0 = 0 ;
20204 PyObject * obj1 = 0 ;
20205 PyObject * obj2 = 0 ;
20206 PyObject * obj3 = 0 ;
20207 PyObject * obj4 = 0 ;
20208 PyObject * obj5 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 arg2 = &temp2;
20218 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20219 }
20220 {
20221 arg3 = &temp3;
20222 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20223 }
20224 {
20225 arg4 = &temp4;
20226 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20227 }
20228 {
20229 arg5 = &temp5;
20230 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20231 }
20232 {
20233 arg6 = &temp6;
20234 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20235 }
20236 {
20237 PyThreadState* __tstate = wxPyBeginAllowThreads();
20238 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20239
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 Py_INCREF(Py_None); resultobj = Py_None;
20244 return resultobj;
20245 fail:
20246 return NULL;
20247 }
20248
20249
20250 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj;
20252 wxEffects *arg1 = (wxEffects *) 0 ;
20253 wxDC *arg2 = 0 ;
20254 wxRect *arg3 = 0 ;
20255 int arg4 = (int) 1 ;
20256 wxRect temp3 ;
20257 PyObject * obj0 = 0 ;
20258 PyObject * obj1 = 0 ;
20259 PyObject * obj2 = 0 ;
20260 PyObject * obj3 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20267 if (SWIG_arg_fail(1)) SWIG_fail;
20268 {
20269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20270 if (SWIG_arg_fail(2)) SWIG_fail;
20271 if (arg2 == NULL) {
20272 SWIG_null_ref("wxDC");
20273 }
20274 if (SWIG_arg_fail(2)) SWIG_fail;
20275 }
20276 {
20277 arg3 = &temp3;
20278 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20279 }
20280 if (obj3) {
20281 {
20282 arg4 = (int)(SWIG_As_int(obj3));
20283 if (SWIG_arg_fail(4)) SWIG_fail;
20284 }
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20289
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 Py_INCREF(Py_None); resultobj = Py_None;
20294 return resultobj;
20295 fail:
20296 return NULL;
20297 }
20298
20299
20300 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20301 PyObject *resultobj;
20302 wxEffects *arg1 = (wxEffects *) 0 ;
20303 wxRect *arg2 = 0 ;
20304 wxDC *arg3 = 0 ;
20305 wxBitmap *arg4 = 0 ;
20306 bool result;
20307 wxRect temp2 ;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 PyObject * obj2 = 0 ;
20311 PyObject * obj3 = 0 ;
20312 char *kwnames[] = {
20313 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20314 };
20315
20316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20318 if (SWIG_arg_fail(1)) SWIG_fail;
20319 {
20320 arg2 = &temp2;
20321 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20322 }
20323 {
20324 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20325 if (SWIG_arg_fail(3)) SWIG_fail;
20326 if (arg3 == NULL) {
20327 SWIG_null_ref("wxDC");
20328 }
20329 if (SWIG_arg_fail(3)) SWIG_fail;
20330 }
20331 {
20332 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20333 if (SWIG_arg_fail(4)) SWIG_fail;
20334 if (arg4 == NULL) {
20335 SWIG_null_ref("wxBitmap");
20336 }
20337 if (SWIG_arg_fail(4)) SWIG_fail;
20338 }
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20342
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20348 }
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20356 PyObject *obj;
20357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20358 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20359 Py_INCREF(obj);
20360 return Py_BuildValue((char *)"");
20361 }
20362 static PyMethodDef SwigMethods[] = {
20363 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20364 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20365 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20366 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20367 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20368 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20369 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20370 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20373 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20374 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20375 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20376 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20377 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20381 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20384 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20385 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20386 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20393 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20402 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20403 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20404 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20405 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20406 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20407 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20408 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20409 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20413 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20424 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20440 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20441 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20442 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20443 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20447 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20448 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20452 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20453 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20454 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20458 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20462 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20470 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20473 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20478 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20486 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20492 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20503 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20521 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20535 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20559 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20568 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20588 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20629 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20637 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20644 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20666 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20668 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20676 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20804 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20808 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20809 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20812 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20814 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20819 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20821 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20823 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20825 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20827 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20833 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20835 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20837 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20839 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
20851 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
20856 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
20861 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
20868 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
20873 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
20888 { NULL, NULL, 0, NULL }
20889 };
20890
20891
20892 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20893
20894 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
20895 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
20896 }
20897 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
20898 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
20899 }
20900 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
20901 return (void *)((wxGDIObject *) ((wxIcon *) x));
20902 }
20903 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
20904 return (void *)((wxGDIObject *) ((wxPalette *) x));
20905 }
20906 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
20907 return (void *)((wxGDIObject *) ((wxPen *) x));
20908 }
20909 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
20910 return (void *)((wxGDIObject *) ((wxFont *) x));
20911 }
20912 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
20913 return (void *)((wxGDIObject *) ((wxCursor *) x));
20914 }
20915 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
20916 return (void *)((wxGDIObject *) ((wxBitmap *) x));
20917 }
20918 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
20919 return (void *)((wxGDIObject *) ((wxRegion *) x));
20920 }
20921 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
20922 return (void *)((wxGDIObject *) ((wxBrush *) x));
20923 }
20924 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
20925 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
20926 }
20927 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
20928 return (void *)((wxDC *) ((wxScreenDC *) x));
20929 }
20930 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
20931 return (void *)((wxDC *) ((wxMirrorDC *) x));
20932 }
20933 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
20934 return (void *)((wxDC *) ((wxMemoryDC *) x));
20935 }
20936 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
20937 return (void *)((wxDC *) ((wxWindowDC *) x));
20938 }
20939 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
20940 return (void *)((wxDC *) ((wxMetaFileDC *) x));
20941 }
20942 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
20943 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
20944 }
20945 static void *_p_wxClientDCTo_p_wxDC(void *x) {
20946 return (void *)((wxDC *) ((wxClientDC *) x));
20947 }
20948 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
20949 return (void *)((wxDC *) ((wxPaintDC *) x));
20950 }
20951 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
20952 return (void *)((wxDC *) ((wxPostScriptDC *) x));
20953 }
20954 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
20955 return (void *)((wxDC *) ((wxPrinterDC *) x));
20956 }
20957 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
20958 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
20959 }
20960 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
20961 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
20962 }
20963 static void *_p_wxPenTo_p_wxObject(void *x) {
20964 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
20965 }
20966 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
20967 return (void *)((wxObject *) ((wxRegionIterator *) x));
20968 }
20969 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
20970 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
20971 }
20972 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
20973 return (void *)((wxObject *) ((wxSizerItem *) x));
20974 }
20975 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
20976 return (void *)((wxObject *) ((wxColourDatabase *) x));
20977 }
20978 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
20979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
20980 }
20981 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
20982 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
20983 }
20984 static void *_p_wxIconTo_p_wxObject(void *x) {
20985 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
20986 }
20987 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
20988 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
20989 }
20990 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
20991 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
20992 }
20993 static void *_p_wxSizerTo_p_wxObject(void *x) {
20994 return (void *)((wxObject *) ((wxSizer *) x));
20995 }
20996 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
20997 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
20998 }
20999 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21000 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21001 }
21002 static void *_p_wxPenListTo_p_wxObject(void *x) {
21003 return (void *)((wxObject *) ((wxPenList *) x));
21004 }
21005 static void *_p_wxEventTo_p_wxObject(void *x) {
21006 return (void *)((wxObject *) ((wxEvent *) x));
21007 }
21008 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21009 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21010 }
21011 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21012 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21013 }
21014 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21015 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21016 }
21017 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21018 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21019 }
21020 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21021 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21022 }
21023 static void *_p_wxDCTo_p_wxObject(void *x) {
21024 return (void *)((wxObject *) ((wxDC *) x));
21025 }
21026 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21027 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21028 }
21029 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21030 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21031 }
21032 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21033 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21034 }
21035 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21036 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21037 }
21038 static void *_p_wxControlTo_p_wxObject(void *x) {
21039 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21040 }
21041 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21042 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21043 }
21044 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21045 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21046 }
21047 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21048 return (void *)((wxObject *) ((wxFSFile *) x));
21049 }
21050 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21051 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21052 }
21053 static void *_p_wxRegionTo_p_wxObject(void *x) {
21054 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21055 }
21056 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21057 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21058 }
21059 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21060 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21061 }
21062 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21063 return (void *)((wxObject *) ((wxGDIObject *) x));
21064 }
21065 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21066 return (void *)((wxObject *) ((wxEffects *) x));
21067 }
21068 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21069 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21070 }
21071 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21072 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21073 }
21074 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21075 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21076 }
21077 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21078 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21079 }
21080 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21081 return (void *)((wxObject *) ((wxMenuItem *) x));
21082 }
21083 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21084 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21085 }
21086 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21087 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21088 }
21089 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21090 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21091 }
21092 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21093 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21094 }
21095 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21096 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21097 }
21098 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21099 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21100 }
21101 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21102 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21103 }
21104 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21105 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21106 }
21107 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21108 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21109 }
21110 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21111 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21112 }
21113 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21114 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21115 }
21116 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21117 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21118 }
21119 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21120 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21121 }
21122 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21123 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21124 }
21125 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21126 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21127 }
21128 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21129 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21130 }
21131 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21132 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21133 }
21134 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21135 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21136 }
21137 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21138 return (void *)((wxObject *) ((wxImageHandler *) x));
21139 }
21140 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21141 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21142 }
21143 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21144 return (void *)((wxObject *) ((wxEvtHandler *) x));
21145 }
21146 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21147 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21148 }
21149 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21150 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21151 }
21152 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21153 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21154 }
21155 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21156 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21157 }
21158 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21159 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21160 }
21161 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21162 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21163 }
21164 static void *_p_wxImageTo_p_wxObject(void *x) {
21165 return (void *)((wxObject *) ((wxImage *) x));
21166 }
21167 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21168 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21169 }
21170 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21171 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21172 }
21173 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21174 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21175 }
21176 static void *_p_wxImageListTo_p_wxObject(void *x) {
21177 return (void *)((wxObject *) ((wxImageList *) x));
21178 }
21179 static void *_p_wxCursorTo_p_wxObject(void *x) {
21180 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21181 }
21182 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21183 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21184 }
21185 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21186 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21187 }
21188 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21189 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21190 }
21191 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21192 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21193 }
21194 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21195 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21196 }
21197 static void *_p_wxWindowTo_p_wxObject(void *x) {
21198 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21199 }
21200 static void *_p_wxMenuTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21202 }
21203 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21205 }
21206 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21208 }
21209 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) ((wxBrushList *) x));
21211 }
21212 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) ((wxFileSystem *) x));
21214 }
21215 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21217 }
21218 static void *_p_wxMaskTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) ((wxMask *) x));
21220 }
21221 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21223 }
21224 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21226 }
21227 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21229 }
21230 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21232 }
21233 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21235 }
21236 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21238 }
21239 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21241 }
21242 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21244 }
21245 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21247 }
21248 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21250 }
21251 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21253 }
21254 static void *_p_wxFontTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21256 }
21257 static void *_p_wxBrushTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21259 }
21260 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) ((wxMetaFile *) x));
21262 }
21263 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21265 }
21266 static void *_p_wxColourTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) ((wxColour *) x));
21268 }
21269 static void *_p_wxFontListTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) ((wxFontList *) x));
21271 }
21272 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21274 }
21275 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21277 }
21278 static void *_p_wxControlTo_p_wxWindow(void *x) {
21279 return (void *)((wxWindow *) ((wxControl *) x));
21280 }
21281 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21282 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21283 }
21284 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21285 return (void *)((wxWindow *) ((wxMenuBar *) x));
21286 }
21287 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}};
21288 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}};
21289 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}};
21290 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}};
21291 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}};
21292 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}};
21293 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}};
21294 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}};
21295 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}};
21296 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}};
21297 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}};
21298 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}};
21299 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}};
21300 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}};
21301 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}};
21302 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}};
21303 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}};
21304 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}};
21305 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}};
21306 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}};
21307 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}};
21308 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}};
21309 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}};
21310 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_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_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintDC", _p_wxPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedPaintDC", _p_wxBufferedPaintDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPrinterDC", _p_wxPrinterDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScreenDC", _p_wxScreenDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBufferedDC", _p_wxBufferedDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPalette", _p_wxPaletteTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageList", _p_wxImageListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCursor", _p_wxCursorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxMirrorDC", _p_wxMirrorDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEncodingConverter", _p_wxEncodingConverterTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFileDC", _p_wxMetaFileDCTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrushList", _p_wxBrushListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBitmap", _p_wxBitmapTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBrush", _p_wxBrushTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMetaFile", _p_wxMetaFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxColour", _p_wxColourTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFontList", _p_wxFontListTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
21311 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}};
21312 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}};
21313 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}};
21314 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}};
21315 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}};
21316 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}};
21317 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}};
21318 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}};
21319 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}};
21320 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}};
21321 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}};
21322 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}};
21323 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}};
21324 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}};
21325 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}};
21326 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}};
21327 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}};
21328 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}};
21329 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}};
21330 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}};
21331 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}};
21332 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}};
21333 static swig_type_info _swigt__p_wxConfigBase[] = {{"_p_wxConfigBase", 0, "wxConfigBase *", 0, 0, 0, 0},{"_p_wxConfigBase", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
21334 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}};
21335 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}};
21336 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}};
21337 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}};
21338 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}};
21339 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}};
21340 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}};
21341 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}};
21342 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}};
21343 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}};
21344 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}};
21345 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}};
21346 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}};
21347 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}};
21348 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}};
21349
21350 static swig_type_info *swig_types_initial[] = {
21351 _swigt__p_wxPostScriptDC,
21352 _swigt__p_wxBrush,
21353 _swigt__p_wxColour,
21354 _swigt__p_wxDC,
21355 _swigt__p_wxMirrorDC,
21356 _swigt__p_form_ops_t,
21357 _swigt__p_wxDuplexMode,
21358 _swigt__p_wxPyFontEnumerator,
21359 _swigt__p_char,
21360 _swigt__p_wxIconLocation,
21361 _swigt__p_wxImage,
21362 _swigt__p_wxMetaFileDC,
21363 _swigt__p_wxMask,
21364 _swigt__p_wxSize,
21365 _swigt__p_wxFont,
21366 _swigt__p_wxWindow,
21367 _swigt__p_double,
21368 _swigt__p_wxMemoryDC,
21369 _swigt__p_wxFontMapper,
21370 _swigt__p_wxEffects,
21371 _swigt__p_wxNativeEncodingInfo,
21372 _swigt__p_wxPalette,
21373 _swigt__p_wxBitmap,
21374 _swigt__p_wxObject,
21375 _swigt__p_wxRegionIterator,
21376 _swigt__p_wxRect,
21377 _swigt__p_wxPaperSize,
21378 _swigt__p_wxString,
21379 _swigt__unsigned_int,
21380 _swigt__p_unsigned_int,
21381 _swigt__p_wxPrinterDC,
21382 _swigt__p_wxIconBundle,
21383 _swigt__p_wxPoint,
21384 _swigt__p_wxDash,
21385 _swigt__p_wxScreenDC,
21386 _swigt__p_wxCursor,
21387 _swigt__p_wxClientDC,
21388 _swigt__p_wxBufferedDC,
21389 _swigt__p_wxImageList,
21390 _swigt__p_unsigned_char,
21391 _swigt__p_wxGDIObject,
21392 _swigt__p_wxIcon,
21393 _swigt__p_wxLocale,
21394 _swigt__ptrdiff_t,
21395 _swigt__std__ptrdiff_t,
21396 _swigt__p_wxRegion,
21397 _swigt__p_wxConfigBase,
21398 _swigt__p_wxLanguageInfo,
21399 _swigt__p_wxWindowDC,
21400 _swigt__p_wxPrintData,
21401 _swigt__p_wxBrushList,
21402 _swigt__p_wxFontList,
21403 _swigt__p_wxPen,
21404 _swigt__p_wxBufferedPaintDC,
21405 _swigt__p_wxPaintDC,
21406 _swigt__p_wxPenList,
21407 _swigt__p_int,
21408 _swigt__p_wxMetaFile,
21409 _swigt__p_unsigned_long,
21410 _swigt__p_wxNativeFontInfo,
21411 _swigt__p_wxEncodingConverter,
21412 _swigt__p_wxColourDatabase,
21413 0
21414 };
21415
21416
21417 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21418
21419 static swig_const_info swig_const_table[] = {
21420 {0, 0, 0, 0.0, 0, 0}};
21421
21422 #ifdef __cplusplus
21423 }
21424 #endif
21425
21426
21427 #ifdef __cplusplus
21428 extern "C" {
21429 #endif
21430
21431 /* Python-specific SWIG API */
21432 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21433 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21434 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21435
21436 /* -----------------------------------------------------------------------------
21437 * global variable support code.
21438 * ----------------------------------------------------------------------------- */
21439
21440 typedef struct swig_globalvar {
21441 char *name; /* Name of global variable */
21442 PyObject *(*get_attr)(); /* Return the current value */
21443 int (*set_attr)(PyObject *); /* Set the value */
21444 struct swig_globalvar *next;
21445 } swig_globalvar;
21446
21447 typedef struct swig_varlinkobject {
21448 PyObject_HEAD
21449 swig_globalvar *vars;
21450 } swig_varlinkobject;
21451
21452 static PyObject *
21453 swig_varlink_repr(swig_varlinkobject *v) {
21454 v = v;
21455 return PyString_FromString("<Swig global variables>");
21456 }
21457
21458 static int
21459 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21460 swig_globalvar *var;
21461 flags = flags;
21462 fprintf(fp,"Swig global variables { ");
21463 for (var = v->vars; var; var=var->next) {
21464 fprintf(fp,"%s", var->name);
21465 if (var->next) fprintf(fp,", ");
21466 }
21467 fprintf(fp," }\n");
21468 return 0;
21469 }
21470
21471 static PyObject *
21472 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21473 swig_globalvar *var = v->vars;
21474 while (var) {
21475 if (strcmp(var->name,n) == 0) {
21476 return (*var->get_attr)();
21477 }
21478 var = var->next;
21479 }
21480 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21481 return NULL;
21482 }
21483
21484 static int
21485 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21486 swig_globalvar *var = v->vars;
21487 while (var) {
21488 if (strcmp(var->name,n) == 0) {
21489 return (*var->set_attr)(p);
21490 }
21491 var = var->next;
21492 }
21493 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21494 return 1;
21495 }
21496
21497 static PyTypeObject varlinktype = {
21498 PyObject_HEAD_INIT(0)
21499 0, /* Number of items in variable part (ob_size) */
21500 (char *)"swigvarlink", /* Type name (tp_name) */
21501 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21502 0, /* Itemsize (tp_itemsize) */
21503 0, /* Deallocator (tp_dealloc) */
21504 (printfunc) swig_varlink_print, /* Print (tp_print) */
21505 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21506 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21507 0, /* tp_compare */
21508 (reprfunc) swig_varlink_repr, /* tp_repr */
21509 0, /* tp_as_number */
21510 0, /* tp_as_sequence */
21511 0, /* tp_as_mapping */
21512 0, /* tp_hash */
21513 0, /* tp_call */
21514 0, /* tp_str */
21515 0, /* tp_getattro */
21516 0, /* tp_setattro */
21517 0, /* tp_as_buffer */
21518 0, /* tp_flags */
21519 0, /* tp_doc */
21520 #if PY_VERSION_HEX >= 0x02000000
21521 0, /* tp_traverse */
21522 0, /* tp_clear */
21523 #endif
21524 #if PY_VERSION_HEX >= 0x02010000
21525 0, /* tp_richcompare */
21526 0, /* tp_weaklistoffset */
21527 #endif
21528 #if PY_VERSION_HEX >= 0x02020000
21529 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21530 #endif
21531 #if PY_VERSION_HEX >= 0x02030000
21532 0, /* tp_del */
21533 #endif
21534 #ifdef COUNT_ALLOCS
21535 0,0,0,0 /* tp_alloc -> tp_next */
21536 #endif
21537 };
21538
21539 /* Create a variable linking object for use later */
21540 static PyObject *
21541 SWIG_Python_newvarlink(void) {
21542 swig_varlinkobject *result = 0;
21543 result = PyMem_NEW(swig_varlinkobject,1);
21544 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21545 result->ob_type = &varlinktype;
21546 result->vars = 0;
21547 result->ob_refcnt = 0;
21548 Py_XINCREF((PyObject *) result);
21549 return ((PyObject*) result);
21550 }
21551
21552 static void
21553 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21554 swig_varlinkobject *v;
21555 swig_globalvar *gv;
21556 v= (swig_varlinkobject *) p;
21557 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21558 gv->name = (char *) malloc(strlen(name)+1);
21559 strcpy(gv->name,name);
21560 gv->get_attr = get_attr;
21561 gv->set_attr = set_attr;
21562 gv->next = v->vars;
21563 v->vars = gv;
21564 }
21565
21566 /* -----------------------------------------------------------------------------
21567 * constants/methods manipulation
21568 * ----------------------------------------------------------------------------- */
21569
21570 /* Install Constants */
21571 static void
21572 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21573 PyObject *obj = 0;
21574 size_t i;
21575 for (i = 0; constants[i].type; i++) {
21576 switch(constants[i].type) {
21577 case SWIG_PY_INT:
21578 obj = PyInt_FromLong(constants[i].lvalue);
21579 break;
21580 case SWIG_PY_FLOAT:
21581 obj = PyFloat_FromDouble(constants[i].dvalue);
21582 break;
21583 case SWIG_PY_STRING:
21584 if (constants[i].pvalue) {
21585 obj = PyString_FromString((char *) constants[i].pvalue);
21586 } else {
21587 Py_INCREF(Py_None);
21588 obj = Py_None;
21589 }
21590 break;
21591 case SWIG_PY_POINTER:
21592 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21593 break;
21594 case SWIG_PY_BINARY:
21595 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21596 break;
21597 default:
21598 obj = 0;
21599 break;
21600 }
21601 if (obj) {
21602 PyDict_SetItemString(d,constants[i].name,obj);
21603 Py_DECREF(obj);
21604 }
21605 }
21606 }
21607
21608 /* -----------------------------------------------------------------------------*/
21609 /* Fix SwigMethods to carry the callback ptrs when needed */
21610 /* -----------------------------------------------------------------------------*/
21611
21612 static void
21613 SWIG_Python_FixMethods(PyMethodDef *methods,
21614 swig_const_info *const_table,
21615 swig_type_info **types,
21616 swig_type_info **types_initial) {
21617 size_t i;
21618 for (i = 0; methods[i].ml_name; ++i) {
21619 char *c = methods[i].ml_doc;
21620 if (c && (c = strstr(c, "swig_ptr: "))) {
21621 int j;
21622 swig_const_info *ci = 0;
21623 char *name = c + 10;
21624 for (j = 0; const_table[j].type; j++) {
21625 if (strncmp(const_table[j].name, name,
21626 strlen(const_table[j].name)) == 0) {
21627 ci = &(const_table[j]);
21628 break;
21629 }
21630 }
21631 if (ci) {
21632 size_t shift = (ci->ptype) - types;
21633 swig_type_info *ty = types_initial[shift];
21634 size_t ldoc = (c - methods[i].ml_doc);
21635 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21636 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21637 char *buff = ndoc;
21638 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21639 strncpy(buff, methods[i].ml_doc, ldoc);
21640 buff += ldoc;
21641 strncpy(buff, "swig_ptr: ", 10);
21642 buff += 10;
21643 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21644 methods[i].ml_doc = ndoc;
21645 }
21646 }
21647 }
21648 }
21649
21650 /* -----------------------------------------------------------------------------*
21651 * Initialize type list
21652 * -----------------------------------------------------------------------------*/
21653
21654 #if PY_MAJOR_VERSION < 2
21655 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21656 is copied out of Python/modsupport.c in python version 2.3.4 */
21657 static int
21658 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21659 {
21660 PyObject *dict;
21661 if (!PyModule_Check(m)) {
21662 PyErr_SetString(PyExc_TypeError,
21663 "PyModule_AddObject() needs module as first arg");
21664 return -1;
21665 }
21666 if (!o) {
21667 PyErr_SetString(PyExc_TypeError,
21668 "PyModule_AddObject() needs non-NULL value");
21669 return -1;
21670 }
21671
21672 dict = PyModule_GetDict(m);
21673 if (dict == NULL) {
21674 /* Internal error -- modules must have a dict! */
21675 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21676 PyModule_GetName(m));
21677 return -1;
21678 }
21679 if (PyDict_SetItemString(dict, name, o))
21680 return -1;
21681 Py_DECREF(o);
21682 return 0;
21683 }
21684 #endif
21685
21686 static swig_type_info **
21687 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21688 static PyMethodDef swig_empty_runtime_method_table[] = {
21689 {
21690 NULL, NULL, 0, NULL
21691 }
21692 };/* Sentinel */
21693
21694 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21695 swig_empty_runtime_method_table);
21696 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21697 if (pointer && module) {
21698 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21699 }
21700 return type_list_handle;
21701 }
21702
21703 static swig_type_info **
21704 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21705 swig_type_info **type_pointer;
21706
21707 /* first check if module already created */
21708 type_pointer = SWIG_Python_GetTypeListHandle();
21709 if (type_pointer) {
21710 return type_pointer;
21711 } else {
21712 /* create a new module and variable */
21713 return SWIG_Python_SetTypeListHandle(type_list_handle);
21714 }
21715 }
21716
21717 #ifdef __cplusplus
21718 }
21719 #endif
21720
21721 /* -----------------------------------------------------------------------------*
21722 * Partial Init method
21723 * -----------------------------------------------------------------------------*/
21724
21725 #ifdef SWIG_LINK_RUNTIME
21726 #ifdef __cplusplus
21727 extern "C"
21728 #endif
21729 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21730 #endif
21731
21732 #ifdef __cplusplus
21733 extern "C"
21734 #endif
21735 SWIGEXPORT(void) SWIG_init(void) {
21736 static PyObject *SWIG_globals = 0;
21737 static int typeinit = 0;
21738 PyObject *m, *d;
21739 int i;
21740 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21741
21742 /* Fix SwigMethods to carry the callback ptrs when needed */
21743 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21744
21745 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21746 d = PyModule_GetDict(m);
21747
21748 if (!typeinit) {
21749 #ifdef SWIG_LINK_RUNTIME
21750 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21751 #else
21752 # ifndef SWIG_STATIC_RUNTIME
21753 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21754 # endif
21755 #endif
21756 for (i = 0; swig_types_initial[i]; i++) {
21757 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21758 }
21759 typeinit = 1;
21760 }
21761 SWIG_InstallConstants(d,swig_const_table);
21762
21763 {
21764 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21765 }
21766 {
21767 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21768 }
21769 {
21770 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21771 }
21772 {
21773 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21774 }
21775 {
21776 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21777 }
21778 {
21779 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21780 }
21781 {
21782 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21783 }
21784 {
21785 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21786 }
21787 {
21788 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21789 }
21790 {
21791 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21792 }
21793 {
21794 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21795 }
21796 {
21797 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21798 }
21799 {
21800 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21801 }
21802 {
21803 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21804 }
21805 {
21806 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21807 }
21808 {
21809 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21810 }
21811 {
21812 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21813 }
21814 {
21815 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21816 }
21817 {
21818 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21819 }
21820 {
21821 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21822 }
21823 {
21824 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21825 }
21826 {
21827 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21828 }
21829 {
21830 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21831 }
21832 {
21833 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21834 }
21835 {
21836 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21837 }
21838 {
21839 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21840 }
21841 {
21842 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21843 }
21844 {
21845 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
21846 }
21847 {
21848 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
21849 }
21850 {
21851 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
21852 }
21853 {
21854 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
21855 }
21856 {
21857 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
21858 }
21859 {
21860 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
21861 }
21862 {
21863 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
21864 }
21865 {
21866 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
21867 }
21868 {
21869 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
21870 }
21871 {
21872 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
21873 }
21874 {
21875 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
21876 }
21877 {
21878 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
21879 }
21880 {
21881 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
21882 }
21883 {
21884 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
21885 }
21886 {
21887 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
21888 }
21889 {
21890 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
21891 }
21892 {
21893 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
21894 }
21895 {
21896 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
21897 }
21898 {
21899 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
21900 }
21901 {
21902 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
21903 }
21904 {
21905 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
21906 }
21907 {
21908 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
21909 }
21910 {
21911 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
21912 }
21913 {
21914 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
21915 }
21916 {
21917 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
21918 }
21919 {
21920 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
21921 }
21922 {
21923 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
21924 }
21925 {
21926 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
21927 }
21928 {
21929 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
21930 }
21931 {
21932 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
21933 }
21934 {
21935 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
21936 }
21937 {
21938 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
21939 }
21940 {
21941 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
21942 }
21943 {
21944 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
21945 }
21946 {
21947 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
21948 }
21949 {
21950 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
21951 }
21952 {
21953 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
21954 }
21955 {
21956 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
21957 }
21958 {
21959 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
21960 }
21961 {
21962 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
21963 }
21964 {
21965 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
21966 }
21967 {
21968 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
21969 }
21970 {
21971 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
21972 }
21973 {
21974 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
21975 }
21976 {
21977 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
21978 }
21979 {
21980 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
21981 }
21982 {
21983 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
21984 }
21985 {
21986 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
21987 }
21988 {
21989 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
21990 }
21991 {
21992 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
21993 }
21994 {
21995 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
21996 }
21997 {
21998 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
21999 }
22000 {
22001 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22002 }
22003 {
22004 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22005 }
22006 {
22007 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22008 }
22009 {
22010 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22011 }
22012 {
22013 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22014 }
22015 {
22016 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22017 }
22018 {
22019 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22020 }
22021 {
22022 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22023 }
22024 {
22025 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22026 }
22027 {
22028 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22029 }
22030 {
22031 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22032 }
22033 {
22034 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22035 }
22036 {
22037 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22038 }
22039 {
22040 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22041 }
22042 {
22043 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22044 }
22045 {
22046 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22047 }
22048 {
22049 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22050 }
22051 {
22052 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22053 }
22054 {
22055 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22056 }
22057 {
22058 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22059 }
22060 {
22061 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22062 }
22063 {
22064 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22065 }
22066 {
22067 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22068 }
22069 {
22070 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22071 }
22072 {
22073 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22074 }
22075 {
22076 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22077 }
22078 {
22079 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22080 }
22081 {
22082 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22083 }
22084 {
22085 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22086 }
22087 {
22088 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22089 }
22090 {
22091 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22092 }
22093 {
22094 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22095 }
22096 {
22097 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22098 }
22099 {
22100 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22101 }
22102 {
22103 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22104 }
22105 {
22106 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22107 }
22108 {
22109 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22110 }
22111 {
22112 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22113 }
22114 {
22115 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22116 }
22117 {
22118 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22119 }
22120 {
22121 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22122 }
22123 {
22124 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22125 }
22126 {
22127 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22128 }
22129 {
22130 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22131 }
22132 {
22133 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22134 }
22135 {
22136 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22137 }
22138 {
22139 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22140 }
22141 {
22142 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22143 }
22144
22145 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22146
22147 {
22148 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22149 }
22150 {
22151 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22152 }
22153 {
22154 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22155 }
22156 {
22157 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22158 }
22159 {
22160 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22161 }
22162 {
22163 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22164 }
22165 {
22166 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22167 }
22168 {
22169 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22170 }
22171 {
22172 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22173 }
22174 {
22175 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22176 }
22177 {
22178 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22179 }
22180 {
22181 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22182 }
22183 {
22184 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22185 }
22186 {
22187 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22188 }
22189 {
22190 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22191 }
22192 {
22193 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22194 }
22195 {
22196 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22197 }
22198 {
22199 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22200 }
22201 {
22202 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22203 }
22204 {
22205 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22206 }
22207 {
22208 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22209 }
22210 {
22211 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22212 }
22213 {
22214 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22215 }
22216 {
22217 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22218 }
22219 {
22220 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22221 }
22222 {
22223 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22224 }
22225 {
22226 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22227 }
22228 {
22229 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22230 }
22231 {
22232 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22233 }
22234 {
22235 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22236 }
22237 {
22238 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22239 }
22240 {
22241 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22242 }
22243 {
22244 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22245 }
22246 {
22247 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22248 }
22249 {
22250 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22251 }
22252 {
22253 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22254 }
22255 {
22256 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22257 }
22258 {
22259 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22260 }
22261 {
22262 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22263 }
22264 {
22265 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22266 }
22267 {
22268 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22269 }
22270 {
22271 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22272 }
22273 {
22274 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22275 }
22276 {
22277 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22278 }
22279 {
22280 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22281 }
22282 {
22283 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22284 }
22285 {
22286 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22287 }
22288 {
22289 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22290 }
22291 {
22292 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22293 }
22294 {
22295 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22296 }
22297 {
22298 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22299 }
22300 {
22301 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22302 }
22303 {
22304 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22305 }
22306 {
22307 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22308 }
22309 {
22310 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22311 }
22312 {
22313 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22314 }
22315 {
22316 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22317 }
22318 {
22319 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22320 }
22321 {
22322 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22323 }
22324 {
22325 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22326 }
22327 {
22328 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22329 }
22330 {
22331 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22332 }
22333 {
22334 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22335 }
22336 {
22337 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22338 }
22339 {
22340 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22341 }
22342 {
22343 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22344 }
22345 {
22346 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22347 }
22348 {
22349 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22350 }
22351 {
22352 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22353 }
22354 {
22355 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22356 }
22357 {
22358 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22359 }
22360 {
22361 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22362 }
22363 {
22364 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22365 }
22366 {
22367 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22368 }
22369 {
22370 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22371 }
22372 {
22373 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22374 }
22375 {
22376 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22377 }
22378 {
22379 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22380 }
22381 {
22382 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22383 }
22384 {
22385 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22386 }
22387 {
22388 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22389 }
22390 {
22391 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22392 }
22393 {
22394 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22395 }
22396 {
22397 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22398 }
22399 {
22400 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22401 }
22402 {
22403 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22404 }
22405 {
22406 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22407 }
22408 {
22409 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22410 }
22411 {
22412 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22413 }
22414 {
22415 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22416 }
22417 {
22418 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22419 }
22420 {
22421 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22422 }
22423 {
22424 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22425 }
22426 {
22427 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22428 }
22429 {
22430 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22431 }
22432 {
22433 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22434 }
22435 {
22436 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22437 }
22438 {
22439 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22440 }
22441 {
22442 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22443 }
22444 {
22445 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22446 }
22447 {
22448 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22449 }
22450 {
22451 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22452 }
22453 {
22454 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22455 }
22456 {
22457 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22458 }
22459 {
22460 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22461 }
22462 {
22463 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22464 }
22465 {
22466 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22467 }
22468 {
22469 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22470 }
22471 {
22472 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22473 }
22474 {
22475 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22476 }
22477 {
22478 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22479 }
22480 {
22481 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22482 }
22483 {
22484 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22485 }
22486 {
22487 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22488 }
22489 {
22490 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22491 }
22492 {
22493 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22494 }
22495 {
22496 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22497 }
22498 {
22499 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22500 }
22501 {
22502 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22503 }
22504 {
22505 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22506 }
22507 {
22508 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22509 }
22510 {
22511 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22512 }
22513 {
22514 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22515 }
22516 {
22517 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22518 }
22519 {
22520 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22521 }
22522 {
22523 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22524 }
22525 {
22526 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22527 }
22528 {
22529 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22530 }
22531 {
22532 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22533 }
22534 {
22535 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22536 }
22537 {
22538 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22539 }
22540 {
22541 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22542 }
22543 {
22544 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22545 }
22546 {
22547 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22548 }
22549 {
22550 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22551 }
22552 {
22553 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22554 }
22555 {
22556 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22557 }
22558 {
22559 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22560 }
22561 {
22562 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22563 }
22564 {
22565 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22566 }
22567 {
22568 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22569 }
22570 {
22571 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22572 }
22573 {
22574 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22575 }
22576 {
22577 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22578 }
22579 {
22580 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22581 }
22582 {
22583 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22584 }
22585 {
22586 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22587 }
22588 {
22589 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22590 }
22591 {
22592 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22593 }
22594 {
22595 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22596 }
22597 {
22598 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22599 }
22600 {
22601 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22602 }
22603 {
22604 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22605 }
22606 {
22607 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22608 }
22609 {
22610 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22611 }
22612 {
22613 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22614 }
22615 {
22616 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22617 }
22618 {
22619 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22620 }
22621 {
22622 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22623 }
22624 {
22625 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22626 }
22627 {
22628 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22629 }
22630 {
22631 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22632 }
22633 {
22634 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22635 }
22636 {
22637 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22638 }
22639 {
22640 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22641 }
22642 {
22643 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22644 }
22645 {
22646 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22647 }
22648 {
22649 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22650 }
22651 {
22652 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22653 }
22654 {
22655 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22656 }
22657 {
22658 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22659 }
22660 {
22661 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22662 }
22663 {
22664 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22665 }
22666 {
22667 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22668 }
22669 {
22670 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22671 }
22672 {
22673 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22674 }
22675 {
22676 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22677 }
22678 {
22679 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22680 }
22681 {
22682 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22683 }
22684 {
22685 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22686 }
22687 {
22688 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22689 }
22690 {
22691 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22692 }
22693 {
22694 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22695 }
22696 {
22697 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22698 }
22699 {
22700 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22701 }
22702 {
22703 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22704 }
22705 {
22706 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22707 }
22708 {
22709 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22710 }
22711 {
22712 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22713 }
22714 {
22715 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22716 }
22717 {
22718 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22719 }
22720 {
22721 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22722 }
22723 {
22724 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22725 }
22726 {
22727 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22728 }
22729 {
22730 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
22905 }
22906 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
22907 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
22908 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
22909 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
22910 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
22911 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
22912 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
22913 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
22914 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
22915 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
22916 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
22917 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
22918 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
22919 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
22920 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
22921 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
22922 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
22923 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
22924 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
22925 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
22926 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
22927 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
22928 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
22929 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
22930 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
22931 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
22932 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
22933 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
22934 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
22935 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
22936 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
22937 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
22938 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
22939 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
22940 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
22941 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
22942 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
22943 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
22944 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
22945 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
22946 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
22947 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
22948 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
22949 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
22950 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
22951 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
22952 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
22953
22954 // Work around a chicken/egg problem in drawlist.cpp
22955 wxPyDrawList_SetAPIPtr();
22956
22957 }
22958
wxWidgets (Impactor)